import java.io.*;
import java.util.*;

public class Task {

    public static void main(String[] args) throws Exception {

        new Task().go();
    }

    PrintWriter out;
    Reader in;
    BufferedReader br;

    Task() throws IOException {

        try {

            //br = new BufferedReader( new FileReader("input.txt") );
            //in = new Reader("input.txt");
            in = new Reader("input.txt");
            out = new PrintWriter( new BufferedWriter(new FileWriter("output.txt")) );
        }
        catch (Exception e) {

            //br = new BufferedReader( new InputStreamReader( System.in ) );
            in = new Reader();
            out = new PrintWriter( new BufferedWriter(new OutputStreamWriter(System.out)) );
        }
    }

    void go() throws Exception {

        //int t = in.nextInt();
        int t = 1;
        while (t > 0) {
            solve();
            t--;
        }

        out.flush();
        out.close();
    }

    int inf = 2000000000;
    int mod = 1000000007;
    double eps = 0.000000001;

    int n;
    int m;

    ArrayList<Integer>[] g;
    int[] a;

    void solve() throws IOException {

        int n = in.nextInt();
        int a = in.nextInt();
        int b = in.nextInt();
        String s = in.next();
        int[] dp = new int[n];
        for (int i = 0; i < n; i++)
            dp[i] = a * (i + 1);
        for (int i = 1; i < n; i++) {
            dp[i] = Math.min(dp[i - 1] + a, dp[i]);
            String pref = s.substring(0, i);
            String suff = s.substring(i);
            int[] p = kmp(suff + "$" + pref);
            int maxl = 0;
            for (int j = suff.length(); j < p.length; j++) {
                maxl = Math.max(maxl, p[j]);
            }
            for (int j = 0; j < maxl; j++)
                dp[i + j] = Math.min(dp[i + j], dp[i - 1] + b);
            //System.err.println(i + " " + dp[i]);
        }

        out.println(dp[n - 1]);
    }

    int[] kmp(String s) {
        int[] p = new int[s.length()];
        for (int i = 1; i < s.length(); i++) {
            int j = p[i - 1];
            while (j > 0 && s.charAt(i) != s.charAt(j))
                j = p[j - 1];
            p[i] = j;
            if (s.charAt(i) == s.charAt(j)) p[i]++;
        }

        return p;
    }

    class Pair implements Comparable<Pair>{

        int a;
        int b;

        Pair(int a, int b) {

            this.a = a;
            this.b = b;
        }

        public int compareTo(Pair p) {
            if (a != p.a)
                return Integer.compare(a, p.a);
            else
                return Integer.compare(b, p.b);
        }
    }

    class Item {

        int a;
        int b;
        int c;

        Item(int a, int b, int c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }

    }

    class Reader {

        BufferedReader  br;
        StringTokenizer tok;

        Reader(String file) throws IOException {
            br = new BufferedReader( new FileReader(file) );
        }

        Reader() throws IOException {
            br = new BufferedReader( new InputStreamReader(System.in) );
        }

        String next() throws IOException {

            while (tok == null || !tok.hasMoreElements())
                tok = new StringTokenizer(br.readLine());
            return tok.nextToken();
        }

        int nextInt() throws NumberFormatException, IOException {
            return Integer.valueOf(next());
        }

        long nextLong() throws NumberFormatException, IOException {
            return Long.valueOf(next());
        }

        double nextDouble() throws NumberFormatException, IOException {
            return Double.valueOf(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

    }

    static class InputReader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public InputReader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public InputReader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }

}


import java.io.*;
import java.util.*;

public class Task {

    public static void main(String[] args) throws Exception {

        new Task().go();
    }

    PrintWriter out;
    Reader in;
    BufferedReader br;

    Task() throws IOException {

        try {

            //br = new BufferedReader( new FileReader("input.txt") );
            //in = new Reader("input.txt");
            in = new Reader("input.txt");
            out = new PrintWriter( new BufferedWriter(new FileWriter("output.txt")) );
        }
        catch (Exception e) {

            //br = new BufferedReader( new InputStreamReader( System.in ) );
            in = new Reader();
            out = new PrintWriter( new BufferedWriter(new OutputStreamWriter(System.out)) );
        }
    }

    void go() throws Exception {

        //int t = in.nextInt();
        int t = 1;
        while (t > 0) {
            solve();
            t--;
        }

        out.flush();
        out.close();
    }

    int inf = 2000000000;
    int mod = 1000000007;
    double eps = 0.000000001;

    int n;
    int m;

    ArrayList<Integer>[] g;
    int[] a;

    void solve() throws IOException {

        int n = in.nextInt();
        int a = in.nextInt();
        int b = in.nextInt();
        String s = in.next();
        int[] dp = new int[n];
        for (int i = 0; i < n; i++)
            dp[i] = a * (i + 1);
        StringBuilder sb = new StringBuilder();
        sb.append(s.charAt(0));
        for (int i = 1; i < n; i++) {
            String pref = s.substring(0, i);
            String suff = s.substring(i);
            int[] p = kmp(suff + "$" + pref);
            int maxl = 0;
            for (int j = suff.length(); j < p.length; j++) {
                maxl = Math.max(maxl, p[j]);
            }
            for (int j = 0; j < maxl; j++)
                dp[i + j] = Math.min(dp[i + j], dp[i - 1] + b);
        }
        out.println(dp[n - 1]);
    }

    int[] kmp(String s) {
        int[] p = new int[s.length()];
        for (int i = 1; i < s.length(); i++) {
            int j = p[i - 1];
            while (j > 0 && s.charAt(i) != s.charAt(j))
                j = p[j - 1];
            p[i] = j;
            if (s.charAt(i) == s.charAt(j)) p[i]++;
        }

        return p;
    }

    class Pair implements Comparable<Pair>{

        int a;
        int b;

        Pair(int a, int b) {

            this.a = a;
            this.b = b;
        }

        public int compareTo(Pair p) {
            if (a != p.a)
                return Integer.compare(a, p.a);
            else
                return Integer.compare(b, p.b);
        }
    }

    class Item {

        int a;
        int b;
        int c;

        Item(int a, int b, int c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }

    }

    class Reader {

        BufferedReader  br;
        StringTokenizer tok;

        Reader(String file) throws IOException {
            br = new BufferedReader( new FileReader(file) );
        }

        Reader() throws IOException {
            br = new BufferedReader( new InputStreamReader(System.in) );
        }

        String next() throws IOException {

            while (tok == null || !tok.hasMoreElements())
                tok = new StringTokenizer(br.readLine());
            return tok.nextToken();
        }

        int nextInt() throws NumberFormatException, IOException {
            return Integer.valueOf(next());
        }

        long nextLong() throws NumberFormatException, IOException {
            return Long.valueOf(next());
        }

        double nextDouble() throws NumberFormatException, IOException {
            return Double.valueOf(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

    }

    static class InputReader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public InputReader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public InputReader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }

}


import java.io.*;
import java.util.*;

public class Task {

    public static void main(String[] args) throws Exception {

        new Task().go();
    }

    PrintWriter out;
    Reader in;
    BufferedReader br;

    Task() throws IOException {

        try {

            //br = new BufferedReader( new FileReader("input.txt") );
            //in = new Reader("input.txt");
            in = new Reader("input.txt");
            out = new PrintWriter( new BufferedWriter(new FileWriter("output.txt")) );
        }
        catch (Exception e) {

            //br = new BufferedReader( new InputStreamReader( System.in ) );
            in = new Reader();
            out = new PrintWriter( new BufferedWriter(new OutputStreamWriter(System.out)) );
        }
    }

    void go() throws Exception {

        //int t = in.nextInt();
        int t = 1;
        while (t > 0) {
            solve();
            t--;
        }

        out.flush();
        out.close();
    }

    int inf = 2000000000;
    int mod = 1000000007;
    double eps = 0.000000001;

    int n;
    int m;

    ArrayList<Integer>[] g;
    int[] a;

    void solve() throws IOException {

        int n = in.nextInt();
        int a = in.nextInt();
        int b = in.nextInt();
        String s = in.next();
        int[] dp = new int[n];
        dp[0] = a;
        StringBuilder sb = new StringBuilder();
        sb.append(s.charAt(0));
        for (int i = 1; i < n; i++) {
            dp[i] = dp[i - 1] + a;
            sb.append(s.charAt(i));
            int[] p = kmp(sb.reverse().toString());
            for (int j = 1; j < p.length; j++) {
                if (p[j] > 0) {
                    dp[i] = Math.min(dp[i], dp[i - p[j]] + b);
                }
            }
        }

        out.println(dp[n - 1]);
    }

    int[] kmp(String s) {
        int n = s.length();
        s = s.substring(0, n / 2) + "$" + s.substring(n / 2);
        int[] p = new int[s.length()];
        for (int i = 1; i < s.length(); i++) {
            int j = p[i - 1];
            while (j > 0 && s.charAt(i) != s.charAt(j))
                j = p[j - 1];
            p[i] = j;
            if (s.charAt(i) == s.charAt(j)) p[i]++;
        }

        return p;
    }

    class Pair implements Comparable<Pair>{

        int a;
        int b;

        Pair(int a, int b) {

            this.a = a;
            this.b = b;
        }

        public int compareTo(Pair p) {
            if (a != p.a)
                return Integer.compare(a, p.a);
            else
                return Integer.compare(b, p.b);
        }
    }

    class Item {

        int a;
        int b;
        int c;

        Item(int a, int b, int c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }

    }

    class Reader {

        BufferedReader  br;
        StringTokenizer tok;

        Reader(String file) throws IOException {
            br = new BufferedReader( new FileReader(file) );
        }

        Reader() throws IOException {
            br = new BufferedReader( new InputStreamReader(System.in) );
        }

        String next() throws IOException {

            while (tok == null || !tok.hasMoreElements())
                tok = new StringTokenizer(br.readLine());
            return tok.nextToken();
        }

        int nextInt() throws NumberFormatException, IOException {
            return Integer.valueOf(next());
        }

        long nextLong() throws NumberFormatException, IOException {
            return Long.valueOf(next());
        }

        double nextDouble() throws NumberFormatException, IOException {
            return Double.valueOf(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

    }

    static class InputReader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public InputReader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public InputReader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }

}


import java.io.*;
import java.util.*;

public class Task {

    public static void main(String[] args) throws IOException {

        new Task().go();
    }

    PrintWriter out;
    Reader in;
    BufferedReader br;

    Task() throws IOException {

        try {

            //br = new BufferedReader( new FileReader("input.txt") );
            in = new Reader("input.txt");
            out = new PrintWriter( new BufferedWriter(new FileWriter("output.txt")) );
        }
        catch (Exception e) {

            //br = new BufferedReader( new InputStreamReader( System.in ) );
            in = new Reader();
            out = new PrintWriter( new BufferedWriter(new OutputStreamWriter(System.out)) );
        }
    }

    void go() throws IOException {

        int t = 1;
        while (t > 0) {
            solve();
            //out.println();
            t--;
        }

        out.flush();
        out.close();
    }

    int inf = 2000000000;
    int mod = 1000000007;
    double eps = 0.000000001;

    int n;
    int m;

    int[] a;
    ArrayList<Integer>[] g;
    void solve() throws IOException {
        int n = in.nextInt();
        int a = in.nextInt();
        int b = in.nextInt();
        String s = in.next();
        HashSet<String> set = new HashSet<>();
        int[] d = new int[n];
        d[0] = a;
        set.add(s.charAt(0) + "");
        for (int i = 1; i < n; i++) {
            StringBuilder sb = new StringBuilder();
            d[i] = a + d[i - 1];
            for (int j = i; j > 0; j--) {
                sb.append(s.charAt(j));
                if (set.contains(sb.toString()))
                    d[i] = Math.min(d[i], d[j - 1] + b);
                set.add(sb.toString());
            }
        }

        out.print(d[n - 1]);
    }

    class Pair implements Comparable<Pair>{
        int a;
        int b;

        Pair(int a, int b) {
            this.a = a;
            this.b = b;
        }

        public int compareTo(Pair p) {
            if (a > p.a) return 1;
            if (a < p.a) return -1;
            if (b > p.b) return 1;
            if (b < p.b) return -1;
            return 0;
        }
    }

    class P2 extends Pair {
        P2(int a, int b) {
            super(a, b);
        }
    }

    class Item {

        int a;
        int b;
        int c;

        Item(int a, int b, int c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }

    }

    class Reader {

        BufferedReader  br;
        StringTokenizer tok;

        Reader(String file) throws IOException {
            br = new BufferedReader( new FileReader(file) );
        }

        Reader() throws IOException {
            br = new BufferedReader( new InputStreamReader(System.in) );
        }

        String next() throws IOException {

            while (tok == null || !tok.hasMoreElements())
                tok = new StringTokenizer(br.readLine());
            return tok.nextToken();
        }

        int nextInt() throws NumberFormatException, IOException {
            return Integer.valueOf(next());
        }

        long nextLong() throws NumberFormatException, IOException {
            return Long.valueOf(next());
        }

        double nextDouble() throws NumberFormatException, IOException {
            return Double.valueOf(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

        int[] nextIntArray(int n) throws IOException {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

        ArrayList<Integer>[] nextGraph(int n, int m) throws IOException {
            ArrayList<Integer>[] g = new ArrayList[n];
            for (int i = 0; i < n; i++)
                g[i] = new ArrayList<>();
            for (int i = 0; i < m; i++) {
                int x = nextInt() - 1;
                int y = nextInt() - 1;
                g[x].add(y);
                g[y].add(x);
            }

            return g;
        }

    }

}


/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
If I'm the sun, you're the moon
Because when I go up, you go down
*******************************
I'm working for the day I will surpass you
https://www.a2oj.com/Ladder16.html
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class F2
   {
      public static void main(String omkar[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int N = Integer.parseInt(st.nextToken());
         int A = Integer.parseInt(st.nextToken());
         int B = Integer.parseInt(st.nextToken());
         String input = infile.readLine();
         char[] arr = input.toCharArray();
         //bucket lengths
         long[] dp = new long[N];
         Arrays.fill(dp, Integer.MAX_VALUE);
         dp[0] = A;
         int prev = 0;
         StringBuilder sb;
         for(int i=1; i < N; i++)
         {
            //check previous substrings
            dp[i] = Math.min(dp[i], dp[i-1]+A);
            String text = input.substring(0, prev+1);
            sb = new StringBuilder();
            for(int a=i; a < N; a++)
            {
               sb.append(arr[a]);
               if(kmp(sb.toString(), text) > 0)
                  dp[a] = Math.min(dp[a], dp[i-1]+B);
               else
                  break;
            }
            prev++;
         }
         System.out.println(dp[N-1]);
      }
      public static int kmp(String pat, String txt)
       {
           int M = pat.length();
           int N = txt.length();
           int lps[] = new int[M];
           int j = 0;
           computeLPSArray(pat,M,lps);
           int i = 0;
           int res = 0;
           int next_i = 0;
           while (i < N)
           {
               if (pat.charAt(j) == txt.charAt(i))
               {
                   j++;
                   i++;
               }
               if (j == M)
               {
                   j = lps[j-1];
                   res++;
                   if (lps[j]!=0)
                       i = ++next_i;
                   j = 0;
               }
               else if (i < N && pat.charAt(j) != txt.charAt(i))
               {
                   if (j != 0)
                       j = lps[j-1];
                   else
                       i = i+1;
               }
           }
           return res;
       }
       public static void computeLPSArray(String pat, int M, int lps[])
       {
           int len = 0;
           int i = 1;
           lps[0] = 0;
           while (i < M)
           {
               if (pat.charAt(i) == pat.charAt(len))
               {
                   len++;
                   lps[i] = len;
                   i++;
               }
               else
               {
                   if (len != 0)
                   {
                       len = lps[len-1];
                   }
                   else
                   {
                       lps[i] = len;
                       i++;
                   }
               }
           }
       }
   }


/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
If I'm the sun, you're the moon
Because when I go up, you go down
*******************************
I'm working for the day I will surpass you
https://www.a2oj.com/Ladder16.html
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class F2
   {
      public static void main(String omkar[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int N = Integer.parseInt(st.nextToken());
         int A = Integer.parseInt(st.nextToken());
         int B = Integer.parseInt(st.nextToken());
         String input = infile.readLine();
         char[] arr = input.toCharArray();
         //bucket lengths
         long[] dp = new long[N];
         Arrays.fill(dp, Integer.MAX_VALUE);
         dp[0] = A;
         int prev = 0;
         StringBuilder sb;
         for(int i=1; i < N; i++)
         {
            //check previous substrings
            dp[i] = Math.min(dp[i], dp[i-1]+A);
            String text = input.substring(0, prev+1);
            sb = new StringBuilder();
            for(int a=i; a < N; a++)
            {
               sb.append(arr[a]);
               if(kmp(sb.toString(), text) > 0)
                  dp[a] = Math.min(dp[a], dp[i-1]+B);
            }
            prev++;
         }
         System.out.println(dp[N-1]);
      }
      public static int kmp(String pat, String txt)
       {
           int M = pat.length();
           int N = txt.length();

           // create lps[] that will hold the longest
           // prefix suffix values for pattern
           int lps[] = new int[M];
           int j = 0;  // index for pat[]

           // Preprocess the pattern (calculate lps[]
           // array)
           computeLPSArray(pat,M,lps);

           int i = 0;  // index for txt[]
           int res = 0;
           int next_i = 0;

           while (i < N)
           {
               if (pat.charAt(j) == txt.charAt(i))
               {
                   j++;
                   i++;
               }
               if (j == M)
               {
                   // When we find pattern first time,
                   // we iterate again to check if there
                   // exists more pattern
                   j = lps[j-1];
                   res++;

                   // We start i to check for more than once
                   // appearance of pattern, we will reset i
                   // to previous start+1
                   if (lps[j]!=0)
                       i = ++next_i;
                   j = 0;
               }

               // mismatch after j matches
               else if (i < N && pat.charAt(j) != txt.charAt(i))
               {
                   // Do not match lps[0..lps[j-1]] characters,
                   // they will match anyway
                   if (j != 0)
                       j = lps[j-1];
                   else
                       i = i+1;
               }
           }
           return res;
       }
       public static void computeLPSArray(String pat, int M, int lps[])
       {
           // length of the previous longest prefix suffix
           int len = 0;
           int i = 1;
           lps[0] = 0;  // lps[0] is always 0

           // the loop calculates lps[i] for i = 1 to M-1
           while (i < M)
           {
               if (pat.charAt(i) == pat.charAt(len))
               {
                   len++;
                   lps[i] = len;
                   i++;
               }
               else  // (pat[i] != pat[len])
               {
                   // This is tricky. Consider the example.
                   // AAACAAAA and i = 7. The idea is similar
                   // to search step.
                   if (len != 0)
                   {
                       len = lps[len-1];

                       // Also, note that we do not increment
                       // i here
                   }
                   else  // if (len == 0)
                   {
                       lps[i] = len;
                       i++;
                   }
               }
           }
       }
   }


/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
If I'm the sun, you're the moon
Because when I go up, you go down
*******************************
I'm working for the day I will surpass you
https://www.a2oj.com/Ladder16.html
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class F2
   {
      public static void main(String omkar[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int N = Integer.parseInt(st.nextToken());
         int A = Integer.parseInt(st.nextToken());
         int B = Integer.parseInt(st.nextToken());
         String input = infile.readLine();
         char[] arr = input.toCharArray();
         //bucket lengths
         long[] dp = new long[N];
         Arrays.fill(dp, Integer.MAX_VALUE);
         dp[0] = A;
         int prev = 0;
         StringBuilder sb;
         for(int i=1; i < N; i++)
         {
            //check previous substrings
            dp[i] = Math.min(dp[i], dp[i-1]+A);
            String text = input.substring(0, prev+1);
            //bin search brain tumor
            int low = i;
            int high = N-1;
            while(low != high)
            {
               int mid = (low+high+1)/2;
               if(kmp(input.substring(i, mid+1), text) > 0)
                  low = mid;
               else
                  high = mid-1;
            }
            if(kmp(input.substring(i, i+1), text) == 0)
               low = 0;
            for(int a=i; a <= low; a++)
               dp[a] = Math.min(dp[a], dp[i-1]+B);
            prev++;
         }
         System.out.println(dp[N-1]);
      }
      public static int kmp(String pat, String txt)
       {
           int M = pat.length();
           int N = txt.length();
           int lps[] = new int[M];
           int j = 0;
           computeLPSArray(pat,M,lps);
           int i = 0;
           int res = 0;
           int next_i = 0;
           while (i < N)
           {
               if (pat.charAt(j) == txt.charAt(i))
               {
                   j++;
                   i++;
               }
               if (j == M)
               {
                   j = lps[j-1];
                   res++;
                   if (lps[j]!=0)
                       i = ++next_i;
                   j = 0;
                   return 69;
               }
               else if (i < N && pat.charAt(j) != txt.charAt(i))
               {
                   if (j != 0)
                       j = lps[j-1];
                   else
                       i = i+1;
               }
           }
           return res;
       }
       public static void computeLPSArray(String pat, int M, int lps[])
       {
           int len = 0;
           int i = 1;
           lps[0] = 0;
           while (i < M)
           {
               if (pat.charAt(i) == pat.charAt(len))
               {
                   len++;
                   lps[i] = len;
                   i++;
               }
               else
               {
                   if (len != 0)
                   {
                       len = lps[len-1];
                   }
                   else
                   {
                       lps[i] = len;
                       i++;
                   }
               }
           }
       }
   }


/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
If I'm the sun, you're the moon
Because when I go up, you go down
*******************************
I'm working for the day I will surpass you
https://www.a2oj.com/Ladder16.html
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class F
   {
      static int BASE = 7;
      public static void main(String omkar[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int N = Integer.parseInt(st.nextToken());
         int A = Integer.parseInt(st.nextToken());
         int B = Integer.parseInt(st.nextToken());
         String input = infile.readLine();
         char[] arr = input.toCharArray();
         HashSet<Integer> seen = new HashSet<Integer>();
         int[] exp = new int[5002];
         exp[0] = 1;
         for(int i=1; i <= 5001; i++)
            exp[i] = exp[i-1]*BASE;
         long[] dp = new long[N];
         Arrays.fill(dp, Integer.MAX_VALUE);
         dp[0] = A;
         seen.add(exp[0]*arr[0]);
         for(int i=1; i < N; i++)
         {
            //check previous hashes
            dp[i] = Math.min(dp[i], dp[i-1]+A);
            int hash = exp[0]*arr[i];
            if(seen.contains(hash))
               dp[i] = Math.min(dp[i], dp[i-1]+B);
            for(int a=i+1; a < N; a++)
            {
               hash += exp[a-i]*arr[a];
               if(seen.contains(hash))
                  dp[a] = Math.min(dp[a], dp[i-1]+B);
            }
            //update hashes
            hash = 0;
            for(int a=i; a >= 0; a--)
            {
               hash *= BASE;
               hash += exp[0]*arr[a];
               seen.add(hash);
            }
         }
         System.out.println(dp[N-1]);
      }
   }


/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
If I'm the sun, you're the moon
Because when I go up, you go down
*******************************
I'm working for the day I will surpass you
https://www.a2oj.com/Ladder16.html
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class F
   {
      static int BASE = 7;
      public static void main(String omkar[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int N = Integer.parseInt(st.nextToken());
         int A = Integer.parseInt(st.nextToken());
         int B = Integer.parseInt(st.nextToken());
         String input = infile.readLine();
         char[] arr = input.toCharArray();
         //bucket lengths
         HashSet<Integer>[] seen = new HashSet[N+1];
         for(int i=1; i <= N; i++)
            seen[i] = new HashSet<Integer>();
         int[] exp = new int[5002];
         exp[0] = 1;
         for(int i=1; i <= 5001; i++)
            exp[i] = exp[i-1]*BASE;
         long[] dp = new long[N];
         Arrays.fill(dp, Integer.MAX_VALUE);
         dp[0] = A;
         seen[1].add(exp[0]*arr[0]);
         for(int i=1; i < N; i++)
         {
            //check previous hashes
            dp[i] = Math.min(dp[i], dp[i-1]+A);
            int hash = exp[0]*arr[i];
            if(seen[1].contains(hash))
               dp[i] = Math.min(dp[i], dp[i-1]+B);
            for(int a=i+1; a < N; a++)
            {
               hash += exp[a-i]*arr[a];
               if(seen[a-i+1].contains(hash))
                  dp[a] = Math.min(dp[a], dp[i-1]+B);
            }
            //update hashes
            hash = 0;
            int boof = 1;
            for(int a=i; a >= 0; a--)
            {
               hash *= BASE;
               hash += exp[0]*arr[a];
               seen[boof++].add(hash);
            }
         }
         System.out.println(dp[N-1]);
      }
   }


/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
If I'm the sun, you're the moon
Because when I go up, you go down
*******************************
I'm working for the day I will surpass you
https://www.a2oj.com/Ladder16.html
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class F
   {
      static long BASE = 7L;
      public static void main(String omkar[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int N = Integer.parseInt(st.nextToken());
         int A = Integer.parseInt(st.nextToken());
         int B = Integer.parseInt(st.nextToken());
         String input = infile.readLine();
         char[] arr = input.toCharArray();
         HashSet<Long> seen = new HashSet<Long>();
         long[] exp = new long[5002];
         exp[0] = 1L;
         for(int i=1; i <= 5001; i++)
            exp[i] = exp[i-1]*BASE;
         long[] dp = new long[N];
         Arrays.fill(dp, Long.MAX_VALUE);
         dp[0] = A;
         seen.add(exp[0]*arr[0]);
         for(int i=1; i < N; i++)
         {
            //check previous hashes
            dp[i] = Math.min(dp[i], dp[i-1]+A);
            long hash = exp[0]*arr[i];
            if(seen.contains(hash))
               dp[i] = Math.min(dp[i], dp[i-1]+B);
            for(int a=i+1; a < N; a++)
            {
               hash += exp[a-i]*arr[a];
               if(seen.contains(hash))
                  dp[a] = Math.min(dp[a], dp[i-1]+B);
            }
            //update hashes
            hash = 0;
            for(int a=i; a >= 0; a--)
            {
               hash *= BASE;
               hash += exp[0]*arr[a];
               seen.add(hash);
            }
         }
         System.out.println(dp[N-1]);
      }
   }


/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
If I'm the sun, you're the moon
Because when I go up, you go down
*******************************
I'm working for the day I will surpass you
https://www.a2oj.com/Ladder16.html
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class F2
   {
      public static void main(String omkar[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int N = Integer.parseInt(st.nextToken());
         int A = Integer.parseInt(st.nextToken());
         int B = Integer.parseInt(st.nextToken());
         String input = infile.readLine();
         char[] arr = input.toCharArray();
         //bucket lengths
         long[] dp = new long[N];
         Arrays.fill(dp, Integer.MAX_VALUE);
         dp[0] = A;
         int prev = 0;
         StringBuilder sb;
         for(int i=1; i < N; i++)
         {
            //check previous substrings
            dp[i] = Math.min(dp[i], dp[i-1]+A);
            String text = input.substring(0, prev+1);
            for(int a=i; a < N; a++)
            {
               if(kmp(input.substring(i, a+1), text) > 0)
                  dp[a] = Math.min(dp[a], dp[i-1]+B);
               else
                  break;
            }
            prev++;
         }
         System.out.println(dp[N-1]);
      }
      public static int kmp(String pat, String txt)
       {
           int M = pat.length();
           int N = txt.length();
           int lps[] = new int[M];
           int j = 0;
           computeLPSArray(pat,M,lps);
           int i = 0;
           int res = 0;
           int next_i = 0;
           while (i < N)
           {
               if (pat.charAt(j) == txt.charAt(i))
               {
                   j++;
                   i++;
               }
               if (j == M)
               {
                   j = lps[j-1];
                   res++;
                   if (lps[j]!=0)
                       i = ++next_i;
                   j = 0;
               }
               else if (i < N && pat.charAt(j) != txt.charAt(i))
               {
                   if (j != 0)
                       j = lps[j-1];
                   else
                       i = i+1;
               }
           }
           return res;
       }
       public static void computeLPSArray(String pat, int M, int lps[])
       {
           int len = 0;
           int i = 1;
           lps[0] = 0;
           while (i < M)
           {
               if (pat.charAt(i) == pat.charAt(len))
               {
                   len++;
                   lps[i] = len;
                   i++;
               }
               else
               {
                   if (len != 0)
                   {
                       len = lps[len-1];
                   }
                   else
                   {
                       lps[i] = len;
                       i++;
                   }
               }
           }
       }
   }


import java.io.*;
import java.util.*;

public class Main{
    public static void main(String[] args){
        try {
            new Main().solve();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    SuffixAutomaton automaton=new SuffixAutomaton();
    private void solve() throws Exception {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        int n=in.nextInt(),a=in.nextInt(),b=in.nextInt();
        char[]s=(" "+in.next()).toCharArray();
        int[]dp=new int[n+1];
        Arrays.fill(dp,0x3f3f3f3f);
        dp[0]=0;
        for(int i=1;i<s.length;i++){
            SuffixAutomaton.State cur=automaton.root;
            int len=0;
            while(cur!=null&&i+len<s.length){
                cur=cur.get(s[i+len]);len++;
            }
            if(cur==null) len--;
            dp[i]=Math.min(dp[i-1]+a,dp[i]);
            if(len!=0){
                dp[i+len-1]=Math.min(dp[i-1]+b,dp[i+len-1]);
            }
            automaton.put(s[i]);
        }
        out.println(dp[n]);
        out.flush();
    }
    class SuffixAutomaton {
        private final char base = 'a';
        private State root, strLast, topoLast;
        private int size;

        public SuffixAutomaton() {
            topoLast = strLast = root = new State(0);
            size = 1;
        }

        public SuffixAutomaton build(String s) {
            strLast = root;
            for (char c : s.toCharArray()) put(c);
            //     put(EndChar);//加入一个结尾字符，构建广义SAM时防止多个串连在一起
            return this;
        }

        public void put(char c) {
            State cur, p;//当前状态
            if (strLast.contains(c)) {
                //广义SAM构建
                cur = strLast.get(c);
                cur.endpos += 1;
                if (strLast.length + 1 != cur.length)
                    cur = addExtraState(strLast, c);
            } else {
                size++;
                cur = new State(strLast.length + 1);
                cur.topo = topoLast;
                cur.endpos = 1;
                for (p = strLast; p != null && !p.contains(c); p = p.link)
                    p.put(c, cur);
                if (p != null) {
                    State q = p.get(c);
                    if (p.length + 1 == q.length) {
                        cur.link = q;
                    } else cur.link = addExtraState(p, c);
                } else cur.link = root;
                topoLast = cur;
            }
            strLast = cur;
            //add(cur); //将cur及其link加入states
        }

        public State addExtraState(State p, char c) {
            size++;
            State q = p.get(c);
            State clone = new State(q);
            clone.length = p.length + 1;
            for (; p != null && p.get(c) == q; p = p.link)
                p.put(c, clone);
            q.link = q.topo = clone;
            return clone;
        }

        public void buildEndPos() {
            State cur = topoLast;
            while (cur.topo != null) {
                if (cur.link != null) cur.link.endpos += cur.endpos;
                cur = cur.topo;
            }
        }

        public State root() {
            return root;
        }

        public class State {
            int length, endpos = 0;
            State link, topo;//right集合的父集，拓扑序的前一个
            private State[] next = new State[26];

            public State(int len) {
                length = len;
            }

            public State(State copy) {
                link = copy.link;
                next = copy.next.clone();
                topo = copy.topo;
            }

            public State get(char c) {
                return next[c - base];
            }

            public void put(char c, State s) {
                next[c - base] = s;
            }

            public boolean contains(char c) {
                return next[c - base] != null;
            }
        }
    }
    class InputReader{
        StreamTokenizer tokenizer;
        public InputReader(InputStream stream){
            tokenizer=new StreamTokenizer(new BufferedReader(new InputStreamReader(stream)));
            tokenizer.ordinaryChars(33,126);
            tokenizer.wordChars(33,126);
        }
        public String next() throws IOException {
            tokenizer.nextToken();
            return tokenizer.sval;
        }
        public int nextInt() throws IOException {
            return Integer.parseInt(next());
        }
        public long nextLong() throws IOException {
            return Long.parseLong(next());
        }
        public boolean hasNext() throws IOException {
            int res=tokenizer.nextToken();
            tokenizer.pushBack();
            return res!=tokenizer.TT_EOF;
        }
    }
}


import java.io.*;
import java.util.*;

public class Main{
    public static void main(String[] args){
        try {
            new Main().solve();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    SuffixAutomaton automaton=new SuffixAutomaton();
    private void solve() throws Exception {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
        int n=in.nextInt(),a=in.nextInt(),b=in.nextInt();
        char[]s=in.next().toCharArray();
        int ans=0;
        for(int i=0;i<s.length;i++){
            SuffixAutomaton.State cur=automaton.root;
            int len=0;
            while(cur!=null&&i+len<s.length){
                cur=cur.get(s[i+len]);len++;
            }
            if(cur==null) len--;
            if(len==0||len*a<b){
                ans+=a;automaton.put(s[i]);
            }else{
                ans+=b;
                for(;len>0;len--)automaton.put(s[i++]);
                i--;
            }
        }
        out.println(ans);
        out.flush();
    }
    class SuffixAutomaton {
        private final char base = 'a';
        private State root, strLast, topoLast;
        private int size;

        public SuffixAutomaton() {
            topoLast = strLast = root = new State(0);
            size = 1;
        }

        public SuffixAutomaton build(String s) {
            strLast = root;
            for (char c : s.toCharArray()) put(c);
            //     put(EndChar);//加入一个结尾字符，构建广义SAM时防止多个串连在一起
            return this;
        }

        public void put(char c) {
            State cur, p;//当前状态
            if (strLast.contains(c)) {
                //广义SAM构建
                cur = strLast.get(c);
                cur.endpos += 1;
                if (strLast.length + 1 != cur.length)
                    cur = addExtraState(strLast, c);
            } else {
                size++;
                cur = new State(strLast.length + 1);
                cur.topo = topoLast;
                cur.endpos = 1;
                for (p = strLast; p != null && !p.contains(c); p = p.link)
                    p.put(c, cur);
                if (p != null) {
                    State q = p.get(c);
                    if (p.length + 1 == q.length) {
                        cur.link = q;
                    } else cur.link = addExtraState(p, c);
                } else cur.link = root;
                topoLast = cur;
            }
            strLast = cur;
            //add(cur); //将cur及其link加入states
        }

        public State addExtraState(State p, char c) {
            size++;
            State q = p.get(c);
            State clone = new State(q);
            clone.length = p.length + 1;
            for (; p != null && p.get(c) == q; p = p.link)
                p.put(c, clone);
            q.link = q.topo = clone;
            return clone;
        }

        public void buildEndPos() {
            State cur = topoLast;
            while (cur.topo != null) {
                if (cur.link != null) cur.link.endpos += cur.endpos;
                cur = cur.topo;
            }
        }

        public State root() {
            return root;
        }

        public class State {
            int length, endpos = 0;
            State link, topo;//right集合的父集，拓扑序的前一个
            private State[] next = new State[26];

            public State(int len) {
                length = len;
            }

            public State(State copy) {
                link = copy.link;
                next = copy.next.clone();
                topo = copy.topo;
            }

            public State get(char c) {
                return next[c - base];
            }

            public void put(char c, State s) {
                next[c - base] = s;
            }

            public boolean contains(char c) {
                return next[c - base] != null;
            }
        }
    }
    class InputReader{
        StreamTokenizer tokenizer;
        public InputReader(InputStream stream){
            tokenizer=new StreamTokenizer(new BufferedReader(new InputStreamReader(stream)));
            tokenizer.ordinaryChars(33,126);
            tokenizer.wordChars(33,126);
        }
        public String next() throws IOException {
            tokenizer.nextToken();
            return tokenizer.sval;
        }
        public int nextInt() throws IOException {
            return Integer.parseInt(next());
        }
        public long nextLong() throws IOException {
            return Long.parseLong(next());
        }
        public boolean hasNext() throws IOException {
            int res=tokenizer.nextToken();
            tokenizer.pushBack();
            return res!=tokenizer.TT_EOF;
        }
    }
}


import java.io.*;
import java.util.*;

public class F_CompressString {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader inp = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Solver solver = new Solver();
        solver.solve(inp, out);
        out.close();
    }

    static class Solver {
        private static boolean KMPSearch(String pat, String txt) {
            int M = pat.length(), N = txt.length(), j = 0, i = 0;
            int lps[] = new int[M];
            computeLPSArray(pat,M,lps);
            while (i < N) {
                if (pat.charAt(j) == txt.charAt(i)) j++; i++;
                if (j == M) return true;
                else if (i < N && pat.charAt(j) != txt.charAt(i)) {
                    if (j != 0) j = lps[j-1];
                    else i = i+1;
                }
            }
            return false;
        }
        private static void computeLPSArray(String pat, int M, int lps[]) {
            int len = 0, i = 1;
            lps[0] = 0;
            while (i < M) {
                if (pat.charAt(i) == pat.charAt(len)) lps[i++] = ++len;
                else if (len != 0) len = lps[len-1];
                else lps[i++] = len;
            }
        }

        private void solve(InputReader inp, PrintWriter out) {
            int n = inp.nextInt(), a = inp.nextInt(), b = inp.nextInt();
            String s = inp.next();
            char[] c = s.toCharArray();
            ArrayList<Integer>[] substrings = new ArrayList[n];
            for (int i = 0; i < n; i++) substrings[i] = new ArrayList<>();
            StringBuilder txt = new StringBuilder();
            for (int i = 1; i < n; i++) {
                txt.append(c[i-1]);
                String kmpText = txt.toString();
                if (!KMPSearch("" + c[i], kmpText)) continue;
                int l = i, r = n - 1;
                while (l < r - 1) {
                    int mid = l + ((r - l) >> 1);
                    if (KMPSearch(s.substring(i, mid + 1), kmpText)) l = mid;
                    else r = mid - 1;
                }
                if (KMPSearch(s.substring(i, r + 1), kmpText)) l = r;
                for (int j = l; j >= i; j--) substrings[j].add(i);
            }
            int[] dp = new int[n];
            dp[0] = a;
            for (int i = 1; i < n; i++) dp[i] = dp[i-1] + a;
            for (int i = 1; i < n; i++) {
                dp[i] = Math.min(dp[i], dp[i-1] + a);
                for (int start: substrings[i]) dp[i] = Math.min(dp[i], dp[start - 1] + b);
            }
            out.print(dp[n-1]);
        }
    }

    static class InputReader {
        BufferedReader reader;
        StringTokenizer tokenizer;

        InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }
    }
}


import java.io.*;
import java.util.*;

public class F_CompressString {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader inp = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Solver solver = new Solver();
        solver.solve(inp, out);
        out.close();
    }

    static class Solver {

        private int[] getZarr(String str) {
            int[] Z = new int[str.length()];
            int n = str.length(), L = 0, R = 0;
            for (int i = 1; i < n; ++i) {
                if (i > R) {
                    L = R = i;
                    while (R < n && str.charAt(R - L) == str.charAt(R)) R++;
                    Z[i] = R - L;
                    R--;
                } else {
                    int k = i - L;
                    if (Z[k] < R - i + 1) Z[i] = Z[k];
                    else {
                        L = i;
                        while (R < n && str.charAt(R - L) == str.charAt(R)) R++;
                        Z[i] = R - L;
                        R--;
                    }
                }
            }
            return Z;
        }

        private void solve(InputReader inp, PrintWriter out) {
            int n = inp.nextInt(), a = inp.nextInt(), b = inp.nextInt();
            String s = inp.next();
            ArrayList<Integer>[] substrings = new ArrayList[n];
            for (int i = 0; i < n; i++) substrings[i] = new ArrayList<>();

            StringBuilder txt = new StringBuilder();
            for (int i = 1; i < n; i++) {
                txt.append(s.charAt(i-1));
                String pattern = s.substring(i);
                int[] z = getZarr(pattern + "$" + txt);
                int max = -1;
                for (int j = pattern.length() + 1; j < z.length; j++) max = Math.max(max, z[j]);
                for (int j = i; j < i + max; j++) substrings[j].add(i);
            }

            int[] dp = new int[n];
            dp[0] = a;
            for (int i = 1; i < n; i++) dp[i] = dp[i-1] + a;
            for (int i = 1; i < n; i++) {
                dp[i] = Math.min(dp[i], dp[i-1] + a);
                for (int start: substrings[i]) {
                    dp[i] = Math.min(dp[i], dp[start - 1] + b);
                }
            }
            out.print(dp[n-1]);
        }
    }

    static class InputReader {
        BufferedReader reader;
        StringTokenizer tokenizer;

        InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }
    }
}


import java.io.*;
import java.util.*;

public class F_CompressString {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader inp = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Solver solver = new Solver();
        solver.solve(inp, out);
        out.close();
    }

    static class Solver {

        private static boolean KMPSearch(String pat, String txt) {
            int M = pat.length(), N = txt.length(), j = 0, i = 0;
            int lps[] = new int[M];
            computeLPSArray(pat,M,lps);
            while (i < N) {
                if (pat.charAt(j) == txt.charAt(i)) {
                    j++; i++;
                } if (j == M) {
                    return true;
                } else if (i < N && pat.charAt(j) != txt.charAt(i)) {
                    if (j != 0) j = lps[j-1];
                    else i = i+1;
                }
            }
            return false;
        }
        private static void computeLPSArray(String pat, int M, int lps[]) {
            int len = 0, i = 1;
            lps[0] = 0;
            while (i < M) {
                if (pat.charAt(i) == pat.charAt(len)) {
                    len++;
                    lps[i] = len;
                    i++;
                } else {
                    if (len != 0) len = lps[len-1];
                    else {
                        lps[i] = len;
                        i++;
                    }
                }
            }
        }

        private void solve(InputReader inp, PrintWriter out) {
            int n = inp.nextInt(), a = inp.nextInt(), b = inp.nextInt();
            String s = inp.next();

            char[] c = s.toCharArray();
            ArrayList<Integer>[] substrings = new ArrayList[n];
            for (int i = 0; i < n; i++) substrings[i] = new ArrayList<>();
            StringBuilder txt = new StringBuilder();
            for (int i = 1; i < n; i++) {
                txt.append(c[i-1]);
                String kmpText = txt.toString();
                if (!KMPSearch("" + c[i], kmpText)) continue;
                int l = i, r = n - 1;
                while (l < r - 1) {
                    int mid = l + ((r - l) >> 1);
                    if (KMPSearch(s.substring(i, mid + 1), kmpText)) l = mid;
                    else r = mid - 1;
                }
                if (KMPSearch(s.substring(i, r + 1), kmpText)) l = r;
                for (int j = l; j >= i; j--) substrings[j].add(i);
            }

            int[] dp = new int[n];
            dp[0] = a;
            for (int i = 1; i < n; i++) dp[i] = dp[i-1] + a;
            for (int i = 1; i < n; i++) {
                dp[i] = Math.min(dp[i], dp[i-1] + a);
                for (int start: substrings[i]) {
                    dp[i] = Math.min(dp[i], dp[start - 1] + b);
                }
            }
            out.print(dp[n-1]);
        }
    }

    static class InputReader {
        BufferedReader reader;
        StringTokenizer tokenizer;

        InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }
    }
}


import java.io.*;
import java.util.*;
import java.util.function.Consumer;

import static java.lang.Math.*;

public class A {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("");

    String next() throws IOException {
        if (!tok.hasMoreElements()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    char S[];

    void solve() throws IOException {
        int n = nextInt();
        int a = nextInt();
        int b = nextInt();
        S = next().toCharArray();
        int dp[] = new int[n];
        dp[0] = a;
        boolean can[][] = new boolean[n][n];
        int l[] = new int[n + 1];
        int ll[] = new int[n + 1];
        int size1 = 0;
        int size2 = 0;
        for (int i = 0; i < n; i++) {
            char c = S[i];
            size1 = 0;
            for (int j = -1; j < i - 1; j++) {
                //l.add(j);
                l[size1++] = j;
            }
            for (int j = i; j <= i * 2 + 2 && j < n && size1 > 0; j++) {
                c = S[j];
                //LinkedList<Integer> ll = new LinkedList<>();
                size2 = 0;
                for (int ind = 0; ind < size1; ind++) {
                    int k = l[ind];
                    if (k + 1 < i && S[k + 1] == c) {
                        //ll.add(k + 1);
                        ll[size2++] = k + 1;
                    }
                }
                l = ll;
                size1 = size2;
                if (size1 > 0) {
                    can[i][j] = true;
                }
            }
        }

        for (int i = 1; i < n; i++) {
            int mn = dp[i - 1] + a;
            int mid = max(i / 2 - 2, 0);
            for (int j = i; j >= mid; j--) {
                if (can[j][i]) {
                    int dd = b;
                    if (j > 0) {
                        dd += dp[j - 1];
                    }
                    mn = min(mn, dd);
                }
            }
            dp[i] = mn;
        }
        System.out.print(dp[n - 1]);
    }

    public static void main(String[] args) throws IOException {
        new A().solve();
    }
}


import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class A {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("");

    String next() throws IOException {
        if (!tok.hasMoreElements()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    long mod = 1000000007;
    long p = 107;

    class pair {
        int h, t;

        pair(int h1, int t1) {
            h = h1;
            t = t1;
        }
    }

    char S[];

    ArrayList<pair> Hash;

    void solve() throws IOException {
        int n = nextInt();
        int a = nextInt();
        int b = nextInt();
        S = next().toCharArray();
        Hash = new ArrayList<>((n * (n + 1)) / 2);
        int pol = (n - n % 2) / 2;
        for (int i = 0; i < n; i++) {
            int hash = 0;
            for (int j = i; j > -1 && pol >= i - j + 1; j--) {
                hash = (int) ((hash * p + S[j]) % mod);
                Hash.add(new pair(hash, i));
            }
        }
        Collections.sort(Hash, new Comparator<pair>() {
            @Override
            public int compare(pair o1, pair o2) {
                if (o1.h == o2.h) {
                    return o1.t - o2.t;
                } else {
                    return o1.h - o2.h;
                }
            }
        });
        boolean can[][] = new boolean[n][n];
        for (int i = 0; i < n; i++) {
            int mid = max(i / 2 - 2, 0);
            int hash = 0;
            for (int j = i; j >= mid; j--) {
                hash = (int) ((hash * p + S[j]) % mod);
                int l = 0;
                int r = Hash.size() - 1;
                while (l + 1 < r) {
                    int md = (l + r) / 2;
                    if (Hash.get(md).h < hash) {
                        l = md;
                    } else {
                        r = md;
                    }
                }
                if (Hash.get(l).h == hash) {
                    if (Hash.get(l).t < j) {
                        can[j][i] = true;
                    }
                }
                if (Hash.get(r).h == hash) {
                    if (Hash.get(r).t < j) {
                        can[j][i] = true;
                    }
                }
            }
        }
        //System.out.println(Hash.size());
        int dp[] = new int[n];
        dp[0] = a;
        for (int i = 1; i < n; i++) {
            int mn = dp[i - 1] + a;
            int mid = max(i / 2 - 2, 0);
            for (int j = i; j >= mid; j--) {
                if (can[j][i]) {
                    int dd = b;
                    if (j > 0) {
                        dd += dp[j - 1];
                    }
                    mn = min(mn, dd);
                }
            }
            dp[i] = mn;
        }
        System.out.print(dp[n - 1]);
    }

    public static void main(String[] args) throws IOException {
        new A().solve();
    }
}


import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class A {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("");

    String next() throws IOException {
        if (!tok.hasMoreElements()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    long mod = 1000000007;
    long p = 107;

    class pair {
        long h;
        int t;

        pair(long h1, int t1) {
            h = h1;
            t = t1;
        }
    }

    char S[];

    ArrayList<pair> Hash;

    void solve() throws IOException {
        int n = nextInt();
        int a = nextInt();
        int b = nextInt();
        S = next().toCharArray();
        Hash = new ArrayList<>(n * n);
        for (int i = 0; i < n; i++) {
            long hash = 0;
            for (int j = i; j > -1; j--) {
                hash = (hash * p + S[j]) % mod;
                Hash.add(new pair(hash, i));
            }
        }
        Collections.sort(Hash, new Comparator<pair>() {
            @Override
            public int compare(pair o1, pair o2) {
                if (o1.h == o2.h) {
                    return o1.t - o2.t;
                } else {
                    if (o1.h > o2.h) {
                        return 1;
                    } else {
                        return -1;
                    }
                }
            }
        });
        boolean can[][] = new boolean[n][n];
        for (int i = 0; i < n; i++) {
            int mid = max(i / 2 - 2, 0);
            long hash = 0;
            for (int j = i; j >= mid; j--) {
                hash = (hash * p + S[j]) % mod;
                int l = 0;
                int r = Hash.size() - 1;
                while (l + 1 < r) {
                    int md = (l + r) / 2;
                    if (Hash.get(md).h < hash) {
                        l = md;
                    } else {
                        r = md;
                    }
                }
                if (Hash.get(l).h == hash) {
                    if (Hash.get(l).t < j) {
                        can[j][i] = true;
                    }
                }
                if (Hash.get(r).h == hash) {
                    if (Hash.get(r).t < j) {
                        can[j][i] = true;
                    }
                }
            }
        }
        int dp[] = new int[n];
        dp[0] = a;
        for (int i = 1; i < n; i++) {
            int mn = dp[i - 1] + a;
            int mid = max(i / 2 - 2, 0);
            for (int j = i; j >= mid; j--) {
                if (can[j][i]) {
                    int dd = b;
                    if (j > 0) {
                        dd += dp[j - 1];
                    }
                    mn = min(mn, dd);
                }
            }
            dp[i] = mn;
        }
        System.out.print(dp[n - 1]);
    }

    public static void main(String[] args) throws IOException {
        new A().solve();
    }
}


import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class A {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("");

    String next() throws IOException {
        if (!tok.hasMoreElements()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    char S[];

    ArrayList<Integer> last;

    int ind = 0;
    int vert[][];

    void solve() throws IOException {
        int n = nextInt();
        int a = nextInt();
        int b = nextInt();
        S = next().toCharArray();
        last = new ArrayList<>(n);
        vert = new int[(n * (n + 1)) / 2 + 1][];
        vert[0] = new int[26];
        last.add(0);
        boolean can[][] = new boolean[n][n];
        for (int i = 0; i < n; i++) {
            int c = S[i];
            int v = 0;
            for (int j = i; /*j <= i * 2 + 2 && */ j < n; j++) {
                c = S[j] - 'a';
                //v = v.g[c];
                v = vert[v][c];
                if (v != 0) {
                    can[i][j] = true;
                } else {
                    break;
                }
            }
            c = S[i] - 'a';
            for (int j = 0; j < last.size(); j++) {
                v = last.get(j);
                if (vert[v][c] == 0) {
                    vert[v][c] = ++ind;
                    vert[ind] = new int[26];
                }
                last.set(j, vert[v][c]);
            }
            last.add(0);
        }
        int dp[] = new int[n];
        dp[0] = a;
        for (int i = 1; i < n; i++) {
            int mn = dp[i - 1] + a;
            int mid = max(i / 2 - 2, 0);
            for (int j = i; j >= mid; j--) {
                if (can[j][i]) {
                    int dd = b;
                    if (j > 0) {
                        dd += dp[j - 1];
                    }
                    mn = min(mn, dd);
                }
            }
            dp[i] = mn;
        }
        System.out.print(dp[n - 1]);
    }

    public static void main(String[] args) throws IOException {
        new A().solve();
    }
}


import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class A {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("");

    String next() throws IOException {
        if (!tok.hasMoreElements()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    char S[];

    ArrayList<Integer> last;

    int ind = 0;
    int vert[][];

    void solve() throws IOException {
        int n = nextInt();
        int a = nextInt();
        int b = nextInt();
        S = next().toCharArray();
        last = new ArrayList<>(n);
        vert = new int[(n * (n + 1)) / 2][26];
        last.add(0);
        boolean can[][] = new boolean[n][n];
        for (int i = 0; i < n; i++) {
            int c = S[i];
            int v = 0;
            for (int j = i; /*j <= i * 2 + 2 && */ j < n; j++) {
                c = S[j] - 'a';
                //v = v.g[c];
                v = vert[v][c];
                if (v != 0) {
                    can[i][j] = true;
                } else {
                    break;
                }
            }
            c = S[i] - 'a';
            for (int j = 0; j < last.size(); j++) {
                v = last.get(j);
                if (vert[v][c] == 0) {
                    vert[v][c] = ++ind;
                }
                last.set(j, vert[v][c]);
            }
            last.add(0);
        }
        System.out.println(ind);
        int dp[] = new int[n];
        dp[0] = a;
        for (int i = 1; i < n; i++) {
            int mn = dp[i - 1] + a;
            int mid = max(i / 2 - 2, 0);
            for (int j = i; j >= mid; j--) {
                if (can[j][i]) {
                    int dd = b;
                    if (j > 0) {
                        dd += dp[j - 1];
                    }
                    mn = min(mn, dd);
                }
            }
            dp[i] = mn;
        }
        System.out.print(dp[n - 1]);
    }

    public static void main(String[] args) throws IOException {
        new A().solve();
    }
}


import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class A {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("");

    String next() throws IOException {
        if (!tok.hasMoreElements()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    char S[];

    void solve() throws IOException {
        int n = nextInt();
        int a = nextInt();
        int b = nextInt();
        S = next().toCharArray();
        int last[][] = new int[n][n];
        for (int i = 0; i < n; i++) {
            int v = -1;
            char c = S[i];
            for (int j = i - 1; j > -1; j--) {
                if (S[j] == c) {
                    v = j;
                    break;
                }
            }
            last[i][i] = v;
            for (int j = i + 1; j < n; j++) {
                v = last[i][j - 1];
                c = S[j];
                int len = j - i - 1;
                while (v != -1) {
                    if (S[v + 1] == c) {
                        v++;
                        break;
                    } else {
                        v = last[v - len][v];
                    }
                }
                last[i][j] = v;
            }
        }
        int minS[][] = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                int v = last[i][j];
                int len = j - i;
                if (v != -1) {
                    int v1 = minS[v - len][v];
                    if (v1 != -1) {
                        v = v1;
                    }
                }
                minS[i][j] = v;
            }
        }
        int dp[] = new int[n];
        dp[0] = a;
        for (int i = 1; i < n; i++) {
            int mn = dp[i - 1] + a;
            int mid = max(i / 2 - 2, 0);
            for (int j = i; j >= mid; j--) {
                if (minS[j][i] != -1 && minS[j][i] < j) {
                    int dd = b;
                    if (j > 0) {
                        dd += dp[j - 1];
                    }
                    mn = min(mn, dd);
                }
            }
            dp[i] = mn;
        }
        System.out.print(dp[n - 1]);
    }

    public static void main(String[] args) throws IOException {
        new A().solve();
    }
}


import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class A {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("");

    String next() throws IOException {
        if (!tok.hasMoreElements()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    char S[];

    void solve() throws IOException {
        int n = nextInt();
        int a = nextInt();
        int b = nextInt();
        S = next().toCharArray();
        int last[][] = new int[n][n];
        for (int i = 0; i < n; i++) {
            int v = -1;
            char c = S[i];
            for (int j = i - 1; j > -1; j--) {
                if (S[j] == c) {
                    v = j;
                    break;
                }
            }
            last[i][i] = v;
            for (int j = i + 1; j < n; j++) {
                v = last[i][j - 1];
                c = S[j];
                int len = j - i - 1;
                while (v != -1) {
                    if (S[v + 1] == c) {
                        v++;
                        break;
                    } else {
                        v = last[v - len][v];
                    }
                }
                last[i][j] = v;
            }
        }
        int superS[][] = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                int v = last[i][j];
                int len = j - i;
                while (v >= i) {
                    v = last[v - len][v];
                }
                superS[i][j] = v;
            }
        }
        int dp[] = new int[n];
        dp[0] = a;
        for (int i = 1; i < n; i++) {
            int mn = dp[i - 1] + a;
            int mid = max(i / 2 - 2, 0);
            for (int j = i; j >= mid; j--) {
                if (superS[j][i] != -1) {
                    int dd = b;
                    if (j > 0) {
                        dd += dp[j - 1];
                    }
                    mn = min(mn, dd);
                }
            }
            dp[i] = mn;
        }
        System.out.print(dp[n - 1]);
    }

    public static void main(String[] args) throws IOException {
        new A().solve();
    }
}


import java.io.*;
import java.util.*;
import java.util.function.Consumer;

import static java.lang.Math.*;

public class A {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("");

    String next() throws IOException {
        if (!tok.hasMoreElements()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    char S[];

    void solve() throws IOException {
        int n = nextInt();
        int a = nextInt();
        int b = nextInt();
        S = next().toCharArray();
        int dp[] = new int[n];
        dp[0] = a;
        boolean can[][] = new boolean[n][n];
        int pol = (n - n % 2) / 2;
        for (int i = 0; i < n; i++) {
            char c = S[i];
            LinkedList<Integer> l = new LinkedList<>();
            for (int j = -1; j < i - 1; j++) {
                l.add(j);
            }
            for (int j = i; j <= i * 2 + 2 && j < n && l.size() > 0; j++) {
                c = S[j];
                LinkedList<Integer> ll = new LinkedList<>();
                for (int k : l) {
                    if (k + 1 < i && S[k + 1] == c) {
                        ll.add(k + 1);
                    }
                }
                l = ll;
                if (l.size() > 0) {
                    can[i][j] = true;
                }
            }
        }

        for (int i = 1; i < n; i++) {
            int mn = dp[i - 1] + a;
            int mid = max(i / 2 - 2, 0);
            for (int j = i; j >= mid; j--) {
                if (can[j][i]) {
                    int dd = b;
                    if (j > 0) {
                        dd += dp[j - 1];
                    }
                    mn = min(mn, dd);
                }
            }
            dp[i] = mn;
        }
        System.out.print(dp[n - 1]);
    }

    public static void main(String[] args) throws IOException {
        new A().solve();
    }
}


import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class A {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("");

    String next() throws IOException {
        if (!tok.hasMoreElements()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    char S[];

    void solve() throws IOException {
        int n = nextInt();
        int a = nextInt();
        int b = nextInt();
        S = next().toCharArray();
        int last[][] = new int[n][n];
        for (int i = 0; i < n; i++) {
            int v = -1;
            char c = S[i];
            for (int j = i - 1; j > -1; j--) {
                if (S[j] == c) {
                    v = j;
                    break;
                }
            }
            last[i][i] = v;
            for (int j = i + 1; j < n; j++) {
                v = last[i][j - 1];
                c = S[j];
                int len = j - i - 1;
                while (v != -1) {
                    if (v + 1 < i && S[v + 1] == c) {
                        v++;
                        break;
                    } else {
                        v = last[v - len][v];
                    }
                }
                last[i][j] = v;
            }
        }
        int dp[] = new int[n];
        dp[0] = a;
        for (int i = 1; i < n; i++) {
            int mn = dp[i - 1] + a;
            int mid = max(i / 2 - 2, 0);
            for (int j = i; j >= mid; j--) {
                if (last[j][i] != -1) {
                    int dd = b;
                    if (j > 0) {
                        dd += dp[j - 1];
                    }
                    mn = min(mn, dd);
                }
            }
            dp[i] = mn;
        }
        System.out.print(dp[n - 1]);
    }

    public static void main(String[] args) throws IOException {
        new A().solve();
    }
}


import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class A {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("");

    String next() throws IOException {
        if (!tok.hasMoreElements()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    long mod = 1000000007;
    long p = 107;

    class pair {
        int h, t;

        pair(int h1, int t1) {
            h = h1;
            t = t1;
        }
    }

    char S[];

    ArrayList<pair> Hash;

    void solve() throws IOException {
        int n = nextInt();
        int a = nextInt();
        int b = nextInt();
        S = next().toCharArray();
        Hash = new ArrayList<>(n * n);
        for (int i = 0; i < n; i++) {
            int hash = 0;
            for (int j = i; j > -1; j--) {
                hash = (int) ((hash * p + S[j]) % mod);
                Hash.add(new pair(hash, i));
            }
        }
        Collections.sort(Hash, new Comparator<pair>() {
            @Override
            public int compare(pair o1, pair o2) {
                if (o1.h == o2.h) {
                    return o1.t - o2.t;
                } else {
                    return o1.h - o2.h;
                }
            }
        });
        boolean can[][] = new boolean[n][n];
        for (int i = 0; i < n; i++) {
            int mid = max(i / 2 - 2, 0);
            int hash = 0;
            for (int j = i; j >= mid; j--) {
                hash = (int) ((hash * p + S[j]) % mod);
                int l = 0;
                int r = Hash.size() - 1;
                while (l + 1 < r) {
                    int md = (l + r) / 2;
                    if (Hash.get(md).h < hash) {
                        l = md;
                    } else {
                        r = md;
                    }
                }
                if (Hash.get(l).h == hash) {
                    if (Hash.get(l).t < j) {
                        can[j][i] = true;
                    }
                }
                if (Hash.get(r).h == hash) {
                    if (Hash.get(r).t < j) {
                        can[j][i] = true;
                    }
                }
            }
        }
        int dp[] = new int[n];
        dp[0] = a;
        for (int i = 1; i < n; i++) {
            int mn = dp[i - 1] + a;
            int mid = max(i / 2 - 2, 0);
            for (int j = i; j >= mid; j--) {
                if (can[j][i]) {
                    int dd = b;
                    if (j > 0) {
                        dd += dp[j - 1];
                    }
                    mn = min(mn, dd);
                }
            }
            dp[i] = mn;
        }
        System.out.print(dp[n - 1]);
    }

    public static void main(String[] args) throws IOException {
        new A().solve();
    }
}


import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class A {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("");

    String next() throws IOException {
        if (!tok.hasMoreElements()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    long mod = 1000000007;
    long p = 107;

    class pair {
        int h, t;

        pair(int h1, int t1) {
            h = h1;
            t = t1;
        }
    }

    char S[];

    ArrayList<pair> Hash;

    void solve() throws IOException {
        int n = nextInt();
        int a = nextInt();
        int b = nextInt();
        S = next().toCharArray();
        Hash = new ArrayList<>((n * (n + 1)) / 2);
        for (int i = 0; i < n; i++) {
            int hash = 0;
            for (int j = i; j > -1; j--) {
                hash = (int) ((hash * p + S[j]) % mod);
                Hash.add(new pair(hash, i));
            }
        }
        Collections.sort(Hash, new Comparator<pair>() {
            @Override
            public int compare(pair o1, pair o2) {
                if (o1.h == o2.h) {
                    return o1.t - o2.t;
                } else {
                    return o1.h - o2.h;
                }
            }
        });
        boolean can[][] = new boolean[n][n];
        for (int i = 0; i < n; i++) {
            int mid = max(i / 2 - 2, 0);
            int hash = 0;
            for (int j = i; j >= mid; j--) {
                hash = (int) ((hash * p + S[j]) % mod);
                int l = 0;
                int r = Hash.size() - 1;
                while (l + 1 < r) {
                    int md = (l + r) / 2;
                    if (Hash.get(md).h < hash) {
                        l = md;
                    } else {
                        r = md;
                    }
                }
                if (Hash.get(l).h == hash) {
                    if (Hash.get(l).t < j) {
                        can[j][i] = true;
                    }
                }
                if (Hash.get(r).h == hash) {
                    if (Hash.get(r).t < j) {
                        can[j][i] = true;
                    }
                }
            }
        }
        //System.out.println(Hash.size());
        int dp[] = new int[n];
        dp[0] = a;
        for (int i = 1; i < n; i++) {
            int mn = dp[i - 1] + a;
            int mid = max(i / 2 - 2, 0);
            for (int j = i; j >= mid; j--) {
                if (can[j][i]) {
                    int dd = b;
                    if (j > 0) {
                        dd += dp[j - 1];
                    }
                    mn = min(mn, dd);
                }
            }
            dp[i] = mn;
        }
        System.out.print(dp[n - 1]);
    }

    public static void main(String[] args) throws IOException {
        new A().solve();
    }
}


import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class A {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("");

    String next() throws IOException {
        if (!tok.hasMoreElements()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    char S[];

    ArrayList<Integer> last;

    int ind = 0;
    int vert[][];

    void solve() throws IOException {
        int n = nextInt();
        int a = nextInt();
        int b = nextInt();
        S = next().toCharArray();
        last = new ArrayList<>(n);
        vert = new int[(n * (n + 1)) / 2][26];
        last.add(0);
        boolean can[][] = new boolean[n][n];
        for (int i = 0; i < n; i++) {
            int c = S[i];
            int v = 0;
            for (int j = i; /*j <= i * 2 + 2 && */ j < n; j++) {
                c = S[j] - 'a';
                //v = v.g[c];
                v = vert[v][c];
                if (v != 0) {
                    can[i][j] = true;
                } else {
                    break;
                }
            }
            c = S[i] - 'a';
            for (int j = 0; j < last.size(); j++) {
                v = last.get(j);
                if (vert[v][c] == 0) {
                    vert[v][c] = ++ind;
                }
                last.set(j, vert[v][c]);
            }
            last.add(0);
        }
        int dp[] = new int[n];
        dp[0] = a;
        for (int i = 1; i < n; i++) {
            int mn = dp[i - 1] + a;
            int mid = max(i / 2 - 2, 0);
            for (int j = i; j >= mid; j--) {
                if (can[j][i]) {
                    int dd = b;
                    if (j > 0) {
                        dd += dp[j - 1];
                    }
                    mn = min(mn, dd);
                }
            }
            dp[i] = mn;
        }
        System.out.print(dp[n - 1]);
    }

    public static void main(String[] args) throws IOException {
        new A().solve();
    }
}


import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class A {
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("");

    String next() throws IOException {
        if (!tok.hasMoreElements()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    char S[];

    class Vertex {
        Vertex g[];

        Vertex() {
            g = new Vertex[26];
        }
    }

    Vertex root = new Vertex();

    ArrayList<Vertex> last;

    void solve() throws IOException {
        int n = nextInt();
        int a = nextInt();
        int b = nextInt();
        S = next().toCharArray();
        last = new ArrayList<>(n);
        last.add(root);
        boolean can[][] = new boolean[n][n];
        for (int i = 0; i < n; i++) {
            int c = S[i];
            Vertex v = root;
            for (int j = i; /*j <= i * 2 + 2 && */ j < n; j++) {
                c = S[j] - 'a';
                v = v.g[c];
                if (v != null) {
                    can[i][j] = true;
                } else {
                    break;
                }
            }
            c = S[i] - 'a';
            for (int j = 0; j < last.size(); j++) {
                v = last.get(j);
                if (v.g[c] == null) {
                    v.g[c] = new Vertex();
                }
                last.set(j, v.g[c]);
            }
            last.add(root);
        }

        int dp[] = new int[n];
        dp[0] = a;
        for (int i = 1; i < n; i++) {
            int mn = dp[i - 1] + a;
            int mid = max(i / 2 - 2, 0);
            for (int j = i; j >= mid; j--) {
                if (can[j][i]) {
                    int dd = b;
                    if (j > 0) {
                        dd += dp[j - 1];
                    }
                    mn = min(mn, dd);
                }
            }
            dp[i] = mn;
        }
        System.out.print(dp[n - 1]);
    }

    public static void main(String[] args) throws IOException {
        new A().solve();
    }
}


import java.io.*;
import java.text.*;
import java.util.*;
import java.math.*;
public class template {
	public static void main(String[] args) throws Exception {
		new template().run();
	}
	public void run() throws Exception {
		FastScanner f = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int n = f.nextInt(), a = f.nextInt(), b = f.nextInt();
		int[] dp = new int[n+1];
		char[] arr = f.next().toCharArray();
		for(int i = 0; i < n; i++) {
			dp[i+1] = dp[i] + a;
			int[] z = new int[i+1];
			int l = i, r = i;
			for(int j = i-1; j >= 0; j--) {
				if(j >= l) z[j] = Math.min(z[i + j - r], j - l + 1);
				while(j - z[j] >= 0 && arr[i-z[j]] == arr[j-z[j]])
					z[j]++;
				if(j - z[j] + 1 < l) {
					l = j - z[j] + 1;
					r = j;
				}
				dp[i+1] = Math.min(dp[i+1], b + dp[Math.max(j, i - z[j]) + 1]);
				//System.out.println(Arrays.toString(z));
			}
		}
		//System.out.println();
		//System.out.println(Arrays.toString(dp));
		out.println(dp[n]);
		out.flush();
	}
    static class FastScanner {
        public BufferedReader reader;
        public StringTokenizer tokenizer;
        public FastScanner() {
            reader = new BufferedReader(new InputStreamReader(System.in), 32768);
            tokenizer = null;
        }
        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
        	return Long.parseLong(next());
        }
        public double nextDouble() {
        	return Double.parseDouble(next());
        }
        public String nextLine() {
        	try {
        		return reader.readLine();
        	} catch(IOException e) {
        		throw new RuntimeException(e);
        	}
        }
    }
}