import java.io.*;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Solution {
    static final int INF = (int) 1e9;
    static final int mod = (int) (1e9 + 7);
    static final int UNCALC = -1;
    static int n, a, b;
    static int longest[];
    static int memo[];

    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        n = sc.nextInt();
        a = sc.nextInt();
        b = sc.nextInt();
        longest = new int[n];
        char[] s = sc.next().toCharArray();
        for (int i = 0; i < n; i++) {
            char[] tmp = new char[n - i];
            int c = 0;
            for (int j = i; j < n; j++)
                tmp[c++] = s[j];
            int[] z = zAlgo(tmp);
            int idx = i + 1;
            for (int j = 1; j < z.length; j++, idx++) {
                longest[idx] = Math.max(Math.min(z[j], idx), longest[idx]);
            }
        }
        memo = new int[n];
        Arrays.fill(memo, UNCALC);
        out.println(dp(0));
        out.flush();
        out.close();
    }

    static int dp(int i) {
        if (i >= n) return 0;
        if (memo[i] != UNCALC) return memo[i];
        int min = a + dp(i + 1);
        for (int j = 1; j <= longest[i]; j++) {
            int nxt = i + j + 1;
            min = Math.min(min, b + dp(nxt));
        }
        return memo[i] = min;
    }

    static int[] zAlgo(char[] s) {
        int n = s.length;
        int[] z = new int[n];
        for (int i = 1, l = 0, r = 0; i < n; ++i) {
            if (i <= r)
                z[i] = Math.min(r - i + 1, z[i - l]);
            while (i + z[i] < n && s[z[i]] == s[i + z[i]])
                ++z[i];
            if (i + z[i] - 1 > r)
                r = i + z[l = i] - 1;
        }
        return z;
    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream system) {
            br = new BufferedReader(new InputStreamReader(system));
        }

        public Scanner(String file) throws Exception {
            br = new BufferedReader(new FileReader(file));
        }

        public String next() throws IOException {
            while (st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

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

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

        public double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

        public char nextChar() throws IOException {
            return next().charAt(0);
        }

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

        public boolean ready() throws IOException {
            return br.ready();
        }

        public void waitForInput() throws InterruptedException {
            Thread.sleep(3000);
        }

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

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

        public double[] nextDoubleArray(int n) throws IOException {
            double[] ans = new double[n];
            for (int i = 0; i < n; i++)
                ans[i] = nextDouble();
            return ans;
        }

    }
}


import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;

public class F1121 {

	final int oo = (int) 1e9;

	int n, a, b;
	char[] s;
	int[] furthest;

	int[] memo;
	int dp(int at) {
		if(at == n) return 0;
		if(memo[at] != -1) return memo[at];
		//either encode single character
		int single = a + dp(at + 1);
		//or encode a substring
		int multiple = oo;
		for(int i = at; i < n; ++i) {
			if(furthest[at] >= i) {
				int cur = b + dp(i + 1);
				multiple = Math.min(cur, multiple);
			}
		}
		int ans = Math.min(single, multiple);
		memo[at] = ans;
		return ans;
	}

	public void solve(Scanner in, PrintWriter out) {
		n = in.nextInt();
		a = in.nextInt();
		b = in.nextInt();
		String str = in.next();
		s = str.toCharArray();

		furthest = new int[n];
		Arrays.fill(furthest, -1);

		for(int i = 0; i < n; ++i) {
			int[] z = zValues(str.substring(i));
			for(int j = i; j < n; ++j) {
				int match = z[j - i];
				int l = j, r = l + Math.min(j - i - 1, match - 1);
				if(l > r) continue;
				if(furthest[l] < r) furthest[l] = r;
			}
		}

		memo = new int[n];
		Arrays.fill(memo, -1);

		out.println(dp(0));
	}

	int[] zValues(String string) {
		int n = string.length();
		char[] s = string.toCharArray();
		int[] z = new int[n];
		int L = 0, R = 0;
		for (int i = 1; i < n; ++i) {
			if (i > R) {
				L = R = i;
				while (R < n && s[R - L] == s[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 && s[R - L] == s[R])
						R++;
					z[i] = R - L;
					R--;
				}
			}
		}
		return z;
	}

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		new F1121().solve(in, out);
		in.close();
		out.close();
	}
}


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 { # we totally made this one together

        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 { // we totally made this one together

        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 Main {

    private void solve() throws Exception {
        n = nextInt();
        a = nextLong();
        b = nextLong();
        s = nextToken();
        memo = new Long[n];
        out.println(doit(0));
    }

    Long[] memo;
    long a;
    long b;
    int n;
    String s;

    long doit(int i){
        if(i == n) return 0L;
        else if(memo[i] == null){
            long res = a + doit(i+1);
            if(s.substring(0,i).contains(s.substring(i,i+1))) {
                int l = i;
                int r = n;
                while(l < r-1){
                    int mid = (l+r)/2;
                    if(s.substring(0,i).contains(s.substring(i,mid+1))) l = mid;
                    else r = mid;
                }

                for(int j = i; j <= l; j++) res = Math.min(res, b + doit(j+1));
            }
            memo[i] = res;
        }
        return memo[i];
    }

    public static void main(String[] args) {
        new Main().run();
    }

    private BufferedReader in;
    private PrintWriter out;
    private StringTokenizer tokenizer;

    public void run() {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            out = new PrintWriter(System.out);
            solve();
            in.close();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

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

    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    private float nextFloat() throws IOException {
        return Float.parseFloat(nextToken());
    }

    private String nextLine() throws IOException {
        return new String(in.readLine());
    }

    private String nextToken() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(in.readLine());
        }
        return tokenizer.nextToken();
    }
}


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

public class Main {

    private void solve() throws Exception {
        n = nextInt();
        a = nextLong();
        b = nextLong();
        s = nextToken();
        memo = new Long[n];
        out.println(doit(0));
    }

    Long[] memo;
    long a;
    long b;
    int n;
    String s;

    long doit(int i){
        if(i == n) return 0L;
        else if(memo[i] == null){
            long res = a + doit(i+1);
            if(s.substring(0,i).contains(s.substring(i,i+1))) {
                int l = i;
                if(s.substring(0,i).contains(s.substring(i,n))) l = n-1;
                else {
                    int r = n;
                    while(l < r-1){
                        int mid = (l+r)/2;
                        if(s.substring(0,i).contains(s.substring(i,mid+1))) l = mid;
                        else r = mid;
                    }
                }

                for(int j = i; j <= l; j++) {
                    res = Math.min(res, b + doit(j+1));
                }
            }
            memo[i] = res;
        }
        return memo[i];
    }

    public static void main(String[] args) {
        new Main().run();
    }

    private BufferedReader in;
    private PrintWriter out;
    private StringTokenizer tokenizer;

    public void run() {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            out = new PrintWriter(System.out);
            solve();
            in.close();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

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

    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    private float nextFloat() throws IOException {
        return Float.parseFloat(nextToken());
    }

    private String nextLine() throws IOException {
        return new String(in.readLine());
    }

    private String nextToken() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(in.readLine());
        }
        return tokenizer.nextToken();
    }
}


import java.util.Scanner;

import static java.lang.Math.*;

public class D {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int a = in.nextInt();
        int b = in.nextInt();
        String s = in.next();
        int mas[] = new int[n];
        char tek[] = new char[n];
        int dp[] = new int[n];
        dp[0] = a;
        for (int i = 1; i < n; i++) {
            dp[i] = dp[i - 1] + a;
            int m = 0;
            for (int j = 0; j <= i; j++) {
                tek[m++] = s.charAt(j);
            }
            for (int j = 0; j < m / 2; j++) {
                char sw = tek[j];
                tek[j] = tek[m - j - 1];
                tek[m - 1 - j] = sw;
            }

            int l = 0, r = 0;
            for (int j = 1; j < m; j++) {
                if (mas[j - l] + j < r) mas[j] = mas[j - l];
                else {
                    mas[j] = max(r - j, 0);
                    while (mas[j] + j < m && tek[mas[j]] == tek[j + mas[j]]) {
                        mas[j]++;
                    }
                    if (mas[j] > 0) {
                        r = j + mas[j];
                        l = j;
                    }
                }
            }

            for (int j = 0; j < m; j++) {
                int t = min(mas[j], j);
                dp[i] = min(dp[i], dp[i - t] + b);
            }
            for (int j = 0; j < n; j++) {
                mas[j] = 0;
            }
        }
        System.out.println(dp[n - 1]);
    }
}


import java.util.Scanner;

import static java.lang.Math.*;

public class D {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int a = in.nextInt();
        int b = in.nextInt();
        String s = in.next();
        int mas[] = new int[n];
        char tek[] = new char[n];
        int dp[] = new int[n];
        dp[0] = a;
        for (int i = 1; i < n; i++) {
            dp[i] = dp[i - 1] + a;
            int m = 0;
            for (int j = 0; j <= i; j++) {
                tek[m++] = s.charAt(j);
            }
            for (int j = 0; j < m / 2; j++) {
                char sw = tek[j];
                tek[j] = tek[m - j - 1];
                tek[m - 1 - j] = sw;
            }

            int l = 0, r = 0;
            for (int j = 1; j < m; j++) {
                if (mas[j - l] + j < r) mas[j] = mas[j - l];
                else {
                    mas[j] = max(r - j, 0);
                    while (mas[j] + j < m && s.charAt(mas[j]) == s.charAt(j + mas[j])) {
                        mas[j]++;
                    }
                    if (mas[j] > 0) {
                        r = j + mas[j];
                        l = j;
                    }
                }
            }

            for (int j = 0; j < m; j++) {
                int t = min(mas[j], j);
                dp[i] = min(dp[i], dp[i - t] + b);
            }
        }
        System.out.println(dp[n-1]);
    }
}


import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class MainS {
    static final long MOD = 999998693, INF = 1_000_000_000_000_000_000L,BASE = 31;
    static final int INf = 1_000_000_000;
    static FastReader reader;
    static PrintWriter writer;
    public static void main(String[] args) {
        Thread t = new Thread(null, new O(), "Integer.MAX_VALUE", 100000000);
        t.start();
    }
    static class O implements Runnable {
        public void run() {
            try {
                magic();
            }
            catch (Exception e) {
                e.printStackTrace();
                System.exit(1);
            }
        }
    }
    public static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine(){
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }
    static int n,a,b,max_match[];
    static long dp[];
    static String s;
    static void magic() throws IOException {
        reader = new FastReader();
        writer = new PrintWriter(System.out, true);
        n = reader.nextInt();
        a = reader.nextInt();
        b = reader.nextInt();
        s = reader.next();
        dp = new long[n];
        Arrays.fill(dp, -1);
        max_match = new int[n];
        for(int i=1;i<n;++i) {
            max_match[i] = findMax(s.substring(0, i), s.substring(i, n));
        }
//        writer.println("max match array");
//        for(int i=0;i<n;++i) {
//            writer.print(max_match[i]+" ");
//        }
//        writer.println();
        writer.println(f(0));
    }
    static long f(int idx) {
        //writer.println("idx : "+idx);
        if(idx==n) {
            return 0;
        }
        if(dp[idx]!=-1) {
            return dp[idx];
        }
        if(max_match[idx]>0) {
            return dp[idx] = min(a + f(idx+1), b + f(idx + max_match[idx]));
        }
        else {
            return a+f(idx+1);
        }
    }
    static int[] computeLPS(String pattern) {
        int M = pattern.length();
        int lps[] = new int[M];
        int idx = 1;
        int len = 0;
        while(idx<M)
        {
            if(pattern.charAt(len)==pattern.charAt(idx))
                lps[idx++] = ++len;
            else if(len>0)
                len = lps[len-1];
            else lps[idx++] = 0;
        }
        return lps;
    }
    static int findMax(String text, String pattern) {
       // writer.println("text : " + text + " pattern : "+pattern);
        int lps[] = computeLPS(pattern);
        int N = text.length();
        int M = pattern.length();
        int i = 0,j = 0,max = 0;
        while(i<N)
        {
            if(text.charAt(i)==pattern.charAt(j))
            {
                ++i;
                ++j;
                max = max(max, j);
                if(j==M)
                {
                    //System.out.println("found a match at "+(i-j));
                    j = lps[j-1];
                }
            }
            else if(i<N)
            {
                if(j>0)
                    j = lps[j-1];
                else i++;
            }
        }
        return max;
    }
}


import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class MainS {
    static final long MOD = 999998693, INF = 1_000_000_000_000_000_000L,BASE = 31;
    static final int INf = 1_000_000_000;
    static FastReader reader;
    static PrintWriter writer;
    public static void main(String[] args) {
        Thread t = new Thread(null, new O(), "Integer.MAX_VALUE", 100000000);
        t.start();
    }
    static class O implements Runnable {
        public void run() {
            try {
                magic();
            }
            catch (Exception e) {
                e.printStackTrace();
                System.exit(1);
            }
        }
    }
    public static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine(){
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }
    static int n,a,b,hashes[],map[],hash[][],fidx[];
    static long pow[],dp[];
    static void magic() throws IOException {
        reader = new FastReader();
        writer = new PrintWriter(System.out, true);
        n = reader.nextInt();
        a = reader.nextInt();
        b = reader.nextInt();
        int sz = ( n* (n+1) )/2;
        hashes = new int[sz];
        pow = new long[n];
        dp = new long[n];
        hash = new int[n][n];
        Arrays.fill(dp, -1);
        pow[0]++;
        for(int i=1;i<n;++i) {
            pow[i] = (pow[i-1] * BASE) % MOD;
        }
        char c[] = reader.next().toCharArray();
        int idx = 0;
        for(int i=0;i<n;++i) {
            long curr_hash = 0;
            for(int j=i;j<n;++j) {
                curr_hash += (c[j]-'a'+1) * pow[j-i];
                curr_hash%=MOD;
                hash[i][j] = (int)curr_hash;
                hashes[idx++] = hash[i][j];
            }
        }
//        writer.println("hashes two d array : ");
//        for(int i=0;i<n;++i) {
//            for(int j=i;j<n;++j) {
//                writer.print(hash[i][j]+" ");
//            }
//            writer.println();
//        }
//        writer.println("hashes array : ");
//        for(int e : hashes) {
//            writer.print(e+" ");
//        }
//        writer.println();
        compress0(hashes, hashes.length);
        idx = 0;
        for(int i=0;i<n;++i) {
            for(int j=i;j<n;++j) {
                hash[i][j] = hashes[idx++];
            }
        }
//        writer.println("hashes two d array : ");
//        for(int i=0;i<n;++i) {
//            for(int j=i;j<n;++j) {
//                writer.print(hash[i][j]+" ");
//            }
//            writer.println();
//        }
////        writer.println("hashes array : ");
////        for(int e : hashes) {
////            writer.print(e+" ");
////        }
////        writer.println();
        fidx = new int[sz];
        Arrays.fill(fidx, Integer.MAX_VALUE);
        for(int i=0;i<sz;++i) {
            if(fidx[hashes[i]]==Integer.MAX_VALUE) {
                fidx[hashes[i]] = i;
            }
        }
//        writer.println("Fidx array : ");
//        for(int i=0;i<sz;++i) {
//            writer.print(fidx[i]+" ");
//        }
//        writer.println();
        writer.println(f(0));
    }
    static long f(int idx) {
        //writer.println("idx : "+idx);
        if(idx==n) {
            return 0;
        }
        if(dp[idx]!=-1) {
            return dp[idx];
        }
        long min = a + f(idx+1);
        int till_where = (idx*(idx+1))/2 - 1;
        if(idx==0) {
            till_where = -1;
        }
        //writer.println("till where : "+ till_where + "idx : "+idx);
        for(int i=idx;i<n;++i) {
            if(fidx[hash[idx][i]]<=till_where) {
                //writer.println("can take "+idx+" "+i);
                min = min(min, b + f(i+1));
            }
            else {
                break;
            }
        }
        return dp[idx] = min;
    }
    static void compress0(int arr[],int n)
    {
        map = new int[n];
        for(int i=0;i<n;++i)
            map[i] = arr[i];
        Arrays.sort(map);
        int low,high,mid;
        for(int i=0;i<n;++i)
        {
            low = 0;
            high = n-1;
            while(low<high)
            {
                mid = (low+high)>>1;
                if(map[mid]==arr[i])
                {
                    low = mid;
                    break;
                }
                if(map[mid]>arr[i])
                    high = --mid;
                else low = ++mid;
            }
            arr[i] = low;
        }
    }
}


import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class MainS {
    static final long MOD = 999998693, INF = 1_000_000_000_000_000_000L,BASE = 31;
    static final int INf = 1_000_000_000;
    static FastReader reader;
    static PrintWriter writer;
    public static void main(String[] args) {
        Thread t = new Thread(null, new O(), "Integer.MAX_VALUE", 100000000);
        t.start();
    }
    static class O implements Runnable {
        public void run() {
            try {
                magic();
            }
            catch (Exception e) {
                e.printStackTrace();
                System.exit(1);
            }
        }
    }
    public static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine(){
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }
    static int n,a,b,hashes[],map[],hash[][],fidx[];
    static long pow[],dp[];
    static void magic() throws IOException {
        reader = new FastReader();
        writer = new PrintWriter(System.out, true);
        n = reader.nextInt();
        a = reader.nextInt();
        b = reader.nextInt();
        int sz = ( n* (n+1) )/2;
        hashes = new int[sz];
        pow = new long[n];
        dp = new long[n];
        hash = new int[n][n];
        Arrays.fill(dp, -1);
        pow[0]++;
        for(int i=1;i<n;++i) {
            pow[i] = (pow[i-1] * BASE) % MOD;
        }
        char c[] = reader.next().toCharArray();
        int idx = 0;
        for(int i=0;i<n;++i) {
            long curr_hash = 0;
            for(int j=i;j<n;++j) {
                curr_hash += 1L * (c[j]-'a'+1) * pow[j-i];
                curr_hash%=MOD;
                hash[i][j] = (int)curr_hash;
                hashes[idx++] = hash[i][j];
            }
        }
//        writer.println("hashes two d array : ");
//        for(int i=0;i<n;++i) {
//            for(int j=i;j<n;++j) {
//                writer.print(hash[i][j]+" ");
//            }
//            writer.println();
//        }
//        writer.println("hashes array : ");
//        for(int e : hashes) {
//            writer.print(e+" ");
//        }
//        writer.println();
        compress0(hashes, hashes.length);
        idx = 0;
        for(int i=0;i<n;++i) {
            for(int j=i;j<n;++j) {
                hash[i][j] = hashes[idx++];
            }
        }
        idx = 0;
        for(int i=0;i<n;++i) {
            for(int j=0;j<=i;++j) {
                hashes[idx++] = hash[j][i];
            }
        }
//        writer.println("hashes two d array : ");
//        for(int i=0;i<n;++i) {
//            for(int j=i;j<n;++j) {
//                writer.print(hash[i][j]+" ");
//            }
//            writer.println();
//        }
//        writer.println("hashes array : ");
//        for(int e : hashes) {
//            writer.print(e+" ");
//        }
//        writer.println();
        fidx = new int[sz];
        Arrays.fill(fidx, Integer.MAX_VALUE);
        for(int i=0;i<sz;++i) {
            if(fidx[hashes[i]]==Integer.MAX_VALUE) {
                fidx[hashes[i]] = i;
            }
        }
//        writer.println("Fidx array : ");
//        for(int i=0;i<sz;++i) {
//            writer.print(fidx[i]+" ");
//        }
//        writer.println();
        writer.println(f(0));
    }
    static long f(int idx) {
        //writer.println("idx : "+idx);
        if(idx==n) {
            return 0;
        }
        if(dp[idx]!=-1) {
            return dp[idx];
        }
        long min = a + f(idx+1);
        int till_where = (idx*(idx+1))/2 - 1;
        if(idx==0) {
            till_where = -1;
        }
        //writer.println("till where : "+ till_where + " idx : "+idx);
        for(int i=idx;i<n;++i) {
            if(fidx[hash[idx][i]]<=till_where) {
                //writer.println("can take "+idx+" "+i);
                min = min(min, b + f(i+1));
            }
            else {
                break;
            }
        }
        return dp[idx] = min;
    }
    static void compress0(int arr[],int n)
    {
        map = new int[n];
        for(int i=0;i<n;++i)
            map[i] = arr[i];
        Arrays.sort(map);
        int low,high,mid;
        for(int i=0;i<n;++i)
        {
            low = 0;
            high = n-1;
            while(low<high)
            {
                mid = (low+high)>>1;
                if(map[mid]==arr[i])
                {
                    low = mid;
                    break;
                }
                if(map[mid]>arr[i])
                    high = --mid;
                else low = ++mid;
            }
            arr[i] = low;
        }
    }
}


import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class MainS {
    static final long MOD = 999998693, INF = 1_000_000_000_000_000_000L,BASE = 31;
    static final int INf = 1_000_000_000;
    static FastReader reader;
    static PrintWriter writer;
    public static void main(String[] args) {
        Thread t = new Thread(null, new O(), "Integer.MAX_VALUE", 100000000);
        t.start();
    }
    static class O implements Runnable {
        public void run() {
            try {
                magic();
            }
            catch (Exception e) {
                e.printStackTrace();
                System.exit(1);
            }
        }
    }
    public static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine(){
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }
    static int n,a,b,hashes[],map[],hash[][],fidx[];
    static long pow[],dp[];
    static void magic() throws IOException {
        reader = new FastReader();
        writer = new PrintWriter(System.out, true);
        n = reader.nextInt();
        a = reader.nextInt();
        b = reader.nextInt();
        int sz = ( n* (n+1) )/2;
        hashes = new int[sz];
        pow = new long[n];
        dp = new long[n];
        hash = new int[n][n];
        Arrays.fill(dp, -1);
        pow[0]++;
        for(int i=1;i<n;++i) {
            pow[i] = (pow[i-1] * BASE) % MOD;
        }
        char c[] = reader.next().toCharArray();
        int idx = 0;
        for(int i=0;i<n;++i) {
            long curr_hash = 0;
            for(int j=i;j<n;++j) {
                curr_hash += (c[j]-'a'+1) * pow[j-i];
                curr_hash%=MOD;
                hash[i][j] = (int)curr_hash;
                hashes[idx++] = hash[i][j];
            }
        }
//        writer.println("hashes two d array : ");
//        for(int i=0;i<n;++i) {
//            for(int j=i;j<n;++j) {
//                writer.print(hash[i][j]+" ");
//            }
//            writer.println();
//        }
//        writer.println("hashes array : ");
//        for(int e : hashes) {
//            writer.print(e+" ");
//        }
//        writer.println();
        compress0(hashes, hashes.length);
        idx = 0;
        for(int i=0;i<n;++i) {
            for(int j=i;j<n;++j) {
                hash[i][j] = hashes[idx++];
            }
        }
//        writer.println("hashes two d array : ");
//        for(int i=0;i<n;++i) {
//            for(int j=i;j<n;++j) {
//                writer.print(hash[i][j]+" ");
//            }
//            writer.println();
//        }
////        writer.println("hashes array : ");
////        for(int e : hashes) {
////            writer.print(e+" ");
////        }
////        writer.println();
        fidx = new int[sz];
        Arrays.fill(fidx, Integer.MAX_VALUE);
        for(int i=0;i<sz;++i) {
            if(fidx[hashes[i]]==Integer.MAX_VALUE) {
                fidx[hashes[i]] = i;
            }
        }
//        writer.println("Fidx array : ");
//        for(int i=0;i<sz;++i) {
//            writer.print(fidx[i]+" ");
//        }
//        writer.println();
        writer.println(f(0));
    }
    static long f(int idx) {
        //writer.println("idx : "+idx);
        if(idx==n) {
            return 0;
        }
        if(dp[idx]!=-1) {
            return dp[idx];
        }
        long min = a + f(idx+1);
        int till_where = (idx * (idx-1) )/2;
        if(idx==0) {
            till_where = -1;
        }
        //writer.println("till where : "+ till_where + "idx : "+idx);
        for(int i=idx;i<n;++i) {
            if(fidx[hash[idx][i]]<=till_where) {
                //writer.println("can take "+idx+" "+i);
                min = min(min, b + f(i+1));
            }
            else {
                break;
            }
        }
        return dp[idx] = min;
    }
    static void compress0(int arr[],int n)
    {
        map = new int[n];
        for(int i=0;i<n;++i)
            map[i] = arr[i];
        Arrays.sort(map);
        int low,high,mid;
        for(int i=0;i<n;++i)
        {
            low = 0;
            high = n-1;
            while(low<high)
            {
                mid = (low+high)>>1;
                if(map[mid]==arr[i])
                {
                    low = mid;
                    break;
                }
                if(map[mid]>arr[i])
                    high = --mid;
                else low = ++mid;
            }
            arr[i] = low;
        }
    }
}


import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class MainS {
    static final long MOD = 999998693, INF = 1_000_000_000_000_000_000L,BASE = 31;
    static final int INf = 1_000_000_000;
    static FastReader reader;
    static PrintWriter writer;
    public static void main(String[] args) {
        Thread t = new Thread(null, new O(), "Integer.MAX_VALUE", 100000000);
        t.start();
    }
    static class O implements Runnable {
        public void run() {
            try {
                magic();
            }
            catch (Exception e) {
                e.printStackTrace();
                System.exit(1);
            }
        }
    }
    public static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine(){
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }
    static int n,a,b,hashes[],map[],hash[][],fidx[];
    static long pow[],dp[];
    static void magic() throws IOException {
        reader = new FastReader();
        writer = new PrintWriter(System.out, true);
        n = reader.nextInt();
        a = reader.nextInt();
        b = reader.nextInt();
        int sz = ( n* (n+1) )/2;
        hashes = new int[sz];
        pow = new long[n];
        dp = new long[n];
        hash = new int[n][n];
        Arrays.fill(dp, -1);
        pow[0]++;
        for(int i=1;i<n;++i) {
            pow[i] = (pow[i-1] * BASE) % MOD;
        }
        char c[] = reader.next().toCharArray();
        int idx = 0;
        for(int i=0;i<n;++i) {
            long curr_hash = 0;
            for(int j=i;j<n;++j) {
                curr_hash += (c[j]-'a'+1) * pow[j-i];
                curr_hash%=MOD;
                hash[i][j] = (int)curr_hash;
                hashes[idx++] = hash[i][j];
            }
        }
//        writer.println("hashes two d array : ");
//        for(int i=0;i<n;++i) {
//            for(int j=i;j<n;++j) {
//                writer.print(hash[i][j]+" ");
//            }
//            writer.println();
//        }
//        writer.println("hashes array : ");
//        for(int e : hashes) {
//            writer.print(e+" ");
//        }
//        writer.println();
        compress0(hashes, hashes.length);
        idx = 0;
        for(int i=0;i<n;++i) {
            for(int j=i;j<n;++j) {
                hash[i][j] = hashes[idx++];
            }
        }
//        writer.println("hashes two d array : ");
//        for(int i=0;i<n;++i) {
//            for(int j=i;j<n;++j) {
//                writer.print(hash[i][j]+" ");
//            }
//            writer.println();
//        }
////        writer.println("hashes array : ");
////        for(int e : hashes) {
////            writer.print(e+" ");
////        }
////        writer.println();
        fidx = new int[sz];
        Arrays.fill(fidx, Integer.MAX_VALUE);
        for(int i=0;i<sz;++i) {
            if(fidx[hashes[i]]==Integer.MAX_VALUE) {
                fidx[hashes[i]] = i;
            }
        }
//        writer.println("Fidx array : ");
//        for(int i=0;i<sz;++i) {
//            writer.print(fidx[i]+" ");
//        }
//        writer.println();
        writer.println(f(0));
    }
    static long f(int idx) {
        //writer.println("idx : "+idx);
        if(idx==n) {
            return 0;
        }
        if(dp[idx]!=-1) {
            return dp[idx];
        }
        long min = a + f(idx+1);
        int till_where = (idx * (idx+1) )/2;
        if(idx==0) {
            till_where = -1;
        }
        //writer.println("till where : "+ till_where + "idx : "+idx);
        for(int i=idx;i<n;++i) {
            if(fidx[hash[idx][i]]<=till_where) {
                //writer.println("can take "+idx+" "+i);
                min = min(min, b + f(i+1));
            }
            else {
                break;
            }
        }
        return dp[idx] = min;
    }
    static void compress0(int arr[],int n)
    {
        map = new int[n];
        for(int i=0;i<n;++i)
            map[i] = arr[i];
        Arrays.sort(map);
        int low,high,mid;
        for(int i=0;i<n;++i)
        {
            low = 0;
            high = n-1;
            while(low<high)
            {
                mid = (low+high)>>1;
                if(map[mid]==arr[i])
                {
                    low = mid;
                    break;
                }
                if(map[mid]>arr[i])
                    high = --mid;
                else low = ++mid;
            }
            arr[i] = low;
        }
    }
}


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

public class CF1121F {
      final int ALPHA = 26, OFFSET = 'a';
      int sz, MAX, last, len[], link[], trie[][];
      void suffixAutomaton() {
            MAX = (s.length << 1);
            sz = 1;  last = 0;
            len = new int[MAX];
            link = new int[MAX];
            trie = new int[ALPHA][MAX];
            link[0] = -1;
      }
      void add(char cc) {
            int c = cc - OFFSET;
		int cur = sz++;
		len[cur] = len[last] + 1;
		int p = last;
		while(p != -1 && trie[c][p] == 0) {
			trie[c][p] = cur;
			p = link[p];
		}
		if(p == -1) {
			link[cur] = 0;
		} else {
			int q = trie[c][p];
			if(len[p] + 1 == len[q]) {
				link[cur] = q;
			} else {
				int clone = sz++;
				len[clone] = len[p] + 1;
				link[clone] = link[q];
				for(int i = 0 ; i < ALPHA ; i++)
					trie[i][clone] = trie[i][q];
				while(p != -1 && trie[c][p] == q) {
					trie[c][p] = clone;
					p = link[p];
				}
				link[q] = link[cur] = clone;
			}
		}
            last = cur;
      }
      int sublen(int ind) {
            int res = 0, node = 0;
            for(int i = ind ; i < s.length ; i++) {
                  int let = s[i] - OFFSET;
                  if(trie[let][node] == 0) break;
                  res++;
                  node = trie[let][node];
            }
            return res;
      }
      char[] s;
      public CF1121F() {
            FS scan = new FS();
            int n = scan.nextInt(), a = scan.nextInt(), b = scan.nextInt();
            int minlen = (b + a - 1) / a;
            s = scan.next().toCharArray();
            suffixAutomaton();
            int res = 0, ind = 0;
            while(ind < n) {
                  int max = sublen(ind);
                  if(max >= minlen && max > 0) {
                        res += b;
                        int end = ind + max;
                        while(ind < end) add(s[ind++]);
                  } else {
                        res += a;
                        add(s[ind++]);
                  }
            }
            System.out.println(res);
      }
      class FS {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            StringTokenizer st = new StringTokenizer("");
            public String next() {
                  while(!st.hasMoreTokens()) {
                        try { st = new StringTokenizer(br.readLine()); }
                        catch(Exception e) { e.printStackTrace(); }
                  }
                  return st.nextToken();
            }
            public int nextInt() { return Integer.parseInt(next()); }
      }
      public static void main(String[] args) { new CF1121F(); }
}


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

public class CF1121F {
      final int ALPHA = 26, OFFSET = 'a';
      int sz, MAX, last, len[], link[], trie[][];
      void suffixAutomaton() {
            MAX = (s.length << 1);
            sz = 1;  last = 0;
            len = new int[MAX];
            link = new int[MAX];
            trie = new int[ALPHA][MAX];
            link[0] = -1;
      }
      void add(char cc) {
            int c = cc - OFFSET;
		int cur = sz++;
		len[cur] = len[last] + 1;
		int p = last;
		while(p != -1 && trie[c][p] == 0) {
			trie[c][p] = cur;
			p = link[p];
		}
		if(p == -1) {
			link[cur] = 0;
		} else {
			int q = trie[c][p];
			if(len[p] + 1 == len[q]) {
				link[cur] = q;
			} else {
				int clone = sz++;
				len[clone] = len[p] + 1;
				link[clone] = link[q];
				for(int i = 0 ; i < ALPHA ; i++)
					trie[i][clone] = trie[i][q];
				while(p != -1 && trie[c][p] == q) {
					trie[c][p] = clone;
					p = link[p];
				}
				link[q] = link[cur] = clone;
			}
		}
            last = cur;
      }
      int go(int at) {
            if(at == n) return 0;
            if(dp[at] != -1) return dp[at];
            int res = a + go(at + 1);
            for(int i = at ; i < n ; i++) {
                  if(substring[at][i]) res = Math.min(res, b + go(i + 1));
                  else break;
            }
            dp[at] = res;
            return res;
      }
      int a, b, n, dp[];
      char[] s;
      boolean[][] substring;
      public CF1121F() {
            FS scan = new FS();
            n = scan.nextInt();  a = scan.nextInt();  b = scan.nextInt();
            s = scan.next().toCharArray();
            suffixAutomaton();
            substring = new boolean[n][n];
            for(int i = 0 ; i < n ; i++) {
                  int node = 0;
                  for(int j = i ; j < n ; j++) {
                        int let = s[j] - OFFSET;
                        if(trie[let][node] == 0) break;
                        substring[i][j] = true;
                        node = trie[let][node];
                  }
                  add(s[i]);
            }
            dp = new int[n];
            Arrays.fill(dp, -1);
            System.out.println(go(0));
      }
      class FS {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            StringTokenizer st = new StringTokenizer("");
            public String next() {
                  while(!st.hasMoreTokens()) {
                        try { st = new StringTokenizer(br.readLine()); }
                        catch(Exception e) { e.printStackTrace(); }
                  }
                  return st.nextToken();
            }
            public int nextInt() { return Integer.parseInt(next()); }
      }
      public static void main(String[] args) { new CF1121F(); }
}


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

public class CF1121F {
      final int ALPHA = 26, OFFSET = 'a';
      int sz, MAX, last, len[], link[], trie[][];
      void suffixAutomaton() {
            MAX = (s.length << 1);
            sz = 1;  last = 0;
            len = new int[MAX];
            link = new int[MAX];
            trie = new int[ALPHA][MAX];
            link[0] = -1;
      }
      void add(char cc) {
            int c = cc - OFFSET;
		int cur = sz++;
		len[cur] = len[last] + 1;
		int p = last;
		while(p != -1 && trie[c][p] == 0) {
			trie[c][p] = cur;
			p = link[p];
		}
		if(p == -1) {
			link[cur] = 0;
		} else {
			int q = trie[c][p];
			if(len[p] + 1 == len[q]) {
				link[cur] = q;
			} else {
				int clone = sz++;
				len[clone] = len[p] + 1;
				link[clone] = link[q];
				for(int i = 0 ; i < ALPHA ; i++)
					trie[i][clone] = trie[i][q];
				while(p != -1 && trie[c][p] == q) {
					trie[c][p] = clone;
					p = link[p];
				}
				link[q] = link[cur] = clone;
			}
		}
            last = cur;
      }
      int sublen(int ind) {
            int res = 0, node = 0;
            for(int i = ind ; i < s.length ; i++) {
                  int let = s[i] - OFFSET;
                  if(trie[let][node] == 0) break;
                  res++;
                  node = trie[let][node];
            }
            return res;
      }
      char[] s;
      public CF1121F() {
            FS scan = new FS();
            int n = scan.nextInt(), a = scan.nextInt(), b = scan.nextInt();
            s = scan.next().toCharArray();
            suffixAutomaton();
            int res = 0, ind = 0;
            while(ind < n) {
                  int max = sublen(ind);
                  if(b < max * a) {
                        res += b;
                        int end = ind + max;
                        while(ind < end) add(s[ind++]);
                  } else {
                        res += a;
                        add(s[ind++]);
                  }
            }
            System.out.println(res);
      }
      class FS {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            StringTokenizer st = new StringTokenizer("");
            public String next() {
                  while(!st.hasMoreTokens()) {
                        try { st = new StringTokenizer(br.readLine()); }
                        catch(Exception e) { e.printStackTrace(); }
                  }
                  return st.nextToken();
            }
            public int nextInt() { return Integer.parseInt(next()); }
      }
      public static void main(String[] args) { new CF1121F(); }
}


import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class CompressString {
    private static long MOD = 1_000_000_349;
    private static long FACT = 103;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int a = sc.nextInt();
        int b = sc.nextInt();
        sc.nextLine();
        char[] str = sc.nextLine().toCharArray();
        int cost = 0;
        // length that it is worth using b at
        int minLen = b / a;
        Set<Long> subStrings = new HashSet<>();
        subStrings.add(0L);
        for (int i = 0; i < n; ) {
            int best = -1;
            long hash = 0;
            int upperBound = Math.min(2 * i, n);
            for (int j = i + minLen; j < upperBound; j++) {
                hash = (hash * FACT) % MOD;
                hash += str[j];
                if (subStrings.contains(hash)) {
                    best = j;
                }
            }
            if (best == -1) {
                cost += a;
                best = i;
            } else {
                cost += b;
            }
            for (int j = i; j <= best; j++) {
                Set<Long> toAdd = new HashSet<>();
                for (Long s : subStrings) {
                    toAdd.add((str[j] + s * FACT) % MOD);
                }
                subStrings.addAll(toAdd);
            }
            i = best+1;
        }
        System.out.println(cost);

    }
}


import java.util.Scanner;

// https://codeforces.com/contest/1121/problem/F
public class CompressStringZAlgorithm {

    /**
     * Computes the longest-prefix array of a string
     * corresponding to a itself (the Z-array).
     * The ith index of the output array contains the length of the longest
     * substring starting at index i that has that pattern
     *

     * Example:
     * str =     [a, b, a, a, b, a, a]
     * z-array = [7, 0, 1, 4, 0, 1, 1]
     *

     * One can also easily use this algorithm for finding an arbitrary
     * pattern. For example, if you want to find the pattern 'aba' in
     * 'cabadat', just call this method on the string 'aba!cabadat',
     * where ! is a separator character not in the string. Then the
     * end of the returned array will contain the pattern desired.
     *
     * @return The Z-array of the string str
     */
    public static int[] zAlgorithm(char[] str) {
        int n = str.length;
        int[] zArray = new int[n];
        int x = 0;
        int y = 0;
        for (int i = 1; i < zArray.length; i++) {
            zArray[i] = Math.max(0, Math.min(y - i, zArray[i - x]));
            while (i + zArray[i] < n && str[zArray[i]] == str[i + zArray[i]]) {
                x = i;
                y = i + zArray[i];
                zArray[i]++;
            }
        }
        zArray[0] = n;
        return zArray;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int a = sc.nextInt();
        int b = sc.nextInt();
        sc.nextLine();
        char[] str = sc.nextLine().toCharArray();

        // best[i]: min cost for making first i characters
        int[] best = new int[n];
        best[0] = a;
        for (int i = 1; i < n; i++) {
            best[i] = best[i - 1] + a;
            char[] c = new char[i + 1];
            for (int j = 0; j <= i; j++) {
                c[j] = str[i - j];
            }
            int[] z = zAlgorithm(c);
            //must make sure you don't use the same thing twice
            //https://codeforces.com/contest/1121/submission/50800964
            for (int j = 1; j < z.length; j++) {
                // if we choose to repeat z[j], then we must ensure that we
                // repeat it at a spot after we find it (i-j)
                if (i - j  best[i - z[j]] + b) {
                        best[i] = best[i - z[j]] + b;
                    }
                }
            }
        }
        System.out.println(best[n - 1]);
    }
}


import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class CompressString {
    private static long MOD = 1_000_000_349;
    private static long FACT = 103;
    private static long FACTINV = 961165384;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int a = sc.nextInt();
        int b = sc.nextInt();
        sc.nextLine();
        char[] str = sc.nextLine().toCharArray();
        int cost = 0;
        // length that it is worth using b at
        int minLen = b / a;
        Set<Long> subStrings = new HashSet<>();
        subStrings.add(0L);
        for (int i = 0; i < n; ) {
            int best = -1;
            long hash = 0;
            int upperBound = Math.min(2 * i, n);
            for (int j = i + minLen; j < upperBound; j++) {
                hash = (str[j] + hash * FACT) % MOD;
                if (subStrings.contains(hash)) {
                    best = j;
                }
            }
            if (best == -1) {
                cost += a;
                best = i;
            } else {
                cost += b;
            }
            for (int j = i; j <= best; j++) {
                hash = 0;
                long pow = 1;
                for (int k = j; k >= 0; k--) {
                    hash = (str[k] + hash*FACTINV)%MOD;
                    subStrings.add((pow*hash)%MOD);
                }
                pow = (pow*FACT)%MOD;
            }
            i = best + 1;
        }
        System.out.println(cost);
    }
}


import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

// https://codeforces.com/contest/1121/problem/F
public class CompressString {
    private static final long MOD = 1_000_000_349;
    private static final long FACT = 103;//private static final long FACT2 = 3;
    private static final long FACTINV = 961165384;//private static final long FACTINV2 = 333333450;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int a = sc.nextInt();
        int b = sc.nextInt();
        sc.nextLine();
        char[] str = sc.nextLine().toCharArray();
        Set<Pair> subStrings = new HashSet<>();

        // best[i]: min cost for making first i characters
        int[] best = new int[n];
        Arrays.fill(best,n*a);
        best[0] = a;
        subStrings.add(new Pair(str[0],0L));

        for (int i = 1; i < n; i++) {
            Pair hash = new Pair(0L, 0L);
            int upperBound = Math.min(2 * i, n);
            best[i] = Math.min(best[i], best[i-1] + a);
            for (int j = i; j < upperBound; j++) {
                long hashA = (str[j] + hash.a * FACT) % MOD;//long hashB = (str[j] + hash.getValue() * FACT2) % MOD;
                hash = new Pair(hashA, 0L);//hashB);
                if (subStrings.contains(hash)) {
                    best[j] = Math.min(best[j], b + best[i-1]);
                    //System.out.println(i + " " + j + " " + hash);
                }
            }
            hash = new Pair(0L, 0L);
            long pow1 = 1;//long pow2 = 1;
            for (int k = i; k >= 0; k--) {
                long hashA = (str[k] + hash.a * FACTINV) % MOD;//   long hashB = (str[j] + hash.getValue() * FACTINV2) % MOD;
                hash = new Pair(hashA, 0L);// hashV);
                subStrings.add(new Pair((pow1 * hashA) % MOD, 0L));//(pow2 * hashB) % MOD));
                pow1 = (pow1 * FACT) % MOD;//pow2 = (pow2 * FACT2) % MOD;
            }
        }
        System.out.println(best[n-1]);
    }

    public static class Pair {
        long a;
        long b;

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

        @Override
        public boolean equals(Object obj) {
            Pair o = (Pair) obj;
            return a == o.a && b == o.b;
        }

        @Override
        public int hashCode() {
            return Long.hashCode(a) + Long.hashCode(b);
        }

        @Override
        public String toString() {
            return Long.toString(a);
        }
    }
}


import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

// https://codeforces.com/contest/1121/problem/F
public class CompStrFast {
    private static final long MOD = 1_000_000_349;
    private static final long FACT = 103;//private static final long FACT2 = 3;
    private static final long FACTINV = 961165384;//private static final long FACTINV2 = 333333450;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int a = sc.nextInt();
        int b = sc.nextInt();
        sc.nextLine();
        char[] str = sc.nextLine().toCharArray();
        Set<Long> subStrings = new HashSet<>();

        // best[i]: min cost for making first i characters
        int[] best = new int[n];
        Arrays.fill(best, n * a);
        best[0] = a;
        subStrings.add((long) str[0]);

        for (int i = 1; i < n; i++) {
            long hash = 0L;
            int upperBound = Math.min(2 * i, n);
            best[i] = Math.min(best[i], best[i - 1] + a);
            for (int j = i; j < upperBound; j++) {
                long hashA = (str[j] + hash * FACT) % MOD;//long hashB = (str[j] + hash.getValue() * FACT2) % MOD;
                hash = hashA;
                if (subStrings.contains(hash)) {
                    best[j] = Math.min(best[j], b + best[i - 1]);
                    //System.out.println(i + " " + j + " " + hash);
                }
            }
            hash = 0L;
            long pow1 = 1;//long pow2 = 1;
            for (int k = i; k >= 0; k--) {
                long hashA = (str[k] + hash * FACTINV) % MOD;//   long hashB = (str[j] + hash.getValue() * FACTINV2) % MOD;
                hash = hashA;
                subStrings.add((pow1 * hashA) % MOD);//(pow2 * hashB) % MOD));
                pow1 = (pow1 * FACT) % MOD;//pow2 = (pow2 * FACT2) % MOD;
            }
        }
        System.out.println(best[n - 1]);
    }
}


import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class CompressString {
    private static long MOD = 1_000_000_349;
    private static long FACT = 103;
    private static long FACTINV = 961165384;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int a = sc.nextInt();
        int b = sc.nextInt();
        sc.nextLine();
        char[] str = sc.nextLine().toCharArray();
        int cost = 0;
        // length that it is worth using b at
        int minLen = b / a;
        Set<Long> subStrings = new HashSet<>();
        subStrings.add(0L);
        for (int i = 0; i < n; ) {
            int best = -1;
            long hash = 0;
            int upperBound = Math.min(2 * i, n);
            for (int j = i + minLen; j < upperBound; j++) {
                hash = (str[j] + hash * FACT) % MOD;
                if (subStrings.contains(hash)) {
                    best = j;
                }
            }
            if (best == -1) {
                cost += a;
                best = i;
            } else {
                cost += b;
            }
            for (int j = i; j <= best; j++) {
                hash = 0;
                long pow = 1;
                for (int k = j; k >= 0; k--) {
                    hash = (str[k] + hash*FACTINV)%MOD;
                    subStrings.add((pow*hash)%MOD);
                    pow = (pow*FACT)%MOD;
                }
            }
            i = best + 1;
        }
        System.out.println(cost);
    }
}


import javafx.util.Pair;

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class CompressString {
    private static final long MOD = 1_000_000_349;
    private static final long FACT = 103;
    private static final long FACT2 = 3;
    private static final long FACTINV = 961165384;
    private static final long FACTINV2 = 333333450;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int a = sc.nextInt();
        int b = sc.nextInt();
        sc.nextLine();
        char[] str = sc.nextLine().toCharArray();
        int cost = 0;
        // length that it is worth using b at
        int minLen = b / a;
        Set<Pair<Long, Long>> subStrings = new HashSet<>();
        subStrings.add(new Pair<>(0L, 0L));
        for (int i = 0; i < n; ) {
            int best = -1;
            Pair<Long, Long> hash = new Pair<>(0L, 0L);
            int upperBound = Math.min(2 * i, n);
            for (int j = i + minLen; j < upperBound; j++) {
                long hashK = (str[j] + hash.getKey() * FACT) % MOD;
                long hashV = (str[j] + hash.getValue() * FACT2) % MOD;
                hash = new Pair<>(hashK, hashV);
                if (subStrings.contains(hash)) {
                    best = j;
                }
            }
            if (best == -1) {
                cost += a;
                best = i;
            } else {
                cost += b;
            }
            for (int j = i; j <= best; j++) {
                hash = new Pair<>(0L, 0L);
                long pow1 = 1;
                long pow2 = 1;
                for (int k = j; k >= 0; k--) {
                    long hashK = (str[j] + hash.getKey() * FACTINV) % MOD;
                    long hashV = (str[j] + hash.getValue() * FACTINV2) % MOD;
                    hash = new Pair<>(hashK, hashV);
                    subStrings.add(new Pair<>((pow1 * hashK) % MOD, (pow2 * hashV) % MOD));
                    pow1 = (pow1 * FACT) % MOD;
                    pow2 = (pow2 * FACT2) % MOD;
                }
            }
            i = best + 1;
        }
        System.out.println(cost);
    }

}


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

import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Comparator.comparingInt;

public class Main {
    FastScanner in;
    PrintWriter out;

    private void solve() throws IOException {
        int n = in.nextInt(), a = in.nextInt(), b = in.nextInt();
        char[] s = in.next().toCharArray();

        int[] pi = new int[n];
        int[] maxLen = new int[n];
        for (int id = 0; id < n; id++) {
            pi[id] = 0;
            for (int i = 1, j = 0; id + i < n; i++) {
                while (j > 0 && s[id + i] != s[id + j])
                    j = pi[id + j - 1];
                if (s[id + i] == s[id + j])
                    j++;
                pi[id + i] = j;
                if (min((i + 1) / 2, j) > maxLen[id + i])
                    maxLen[id + i] = min((i + 1) / 2, j);
            }
        }

        int[] dp = new int[n];
        for (int i = 0; i < n; i++) {
            dp[i] = (i == 0 ? 0 : dp[i - 1]) + a;
            for (int j = 1; j <= min((i + 1) / 2, maxLen[i]); j++) {
                if (dp[i] > dp[i - j] + b)
                    dp[i] = dp[i - j] + b;
            }
        }
        out.println(dp[n - 1]);
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

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

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

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

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

        boolean hasNextLine() throws IOException {
            return br.ready();
        }

    }

    private void run() throws IOException {
        in = new FastScanner(System.in); // new FastScanner(new FileInputStream(".in"));
        out = new PrintWriter(System.out); // new PrintWriter(new FileOutputStream(".out"));

        solve();

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

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


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

import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Comparator.comparingInt;

public class Main {
    FastScanner in;
    PrintWriter out;

    private void solve() throws IOException {
        int n = in.nextInt(), a = in.nextInt(), b = in.nextInt();
        char[] s = in.next().toCharArray();

        int[] pi = new int[n];
        int[] maxLen = new int[n];
        for (int id = 0; id < n; id++) {
            pi[id] = 0;
            for (int i = 1, j = 0; id + i < n; i++) {
                while (j > 0 && s[id + i] != s[id + j])
                    j = pi[id + j - 1];
                if (s[id + i] == s[id + j])
                    j++;
                pi[id + i] = j;
                if (j > maxLen[id + i])
                    maxLen[id + i] = j;
            }
        }

        int[] dp = new int[n];
        for (int i = 0; i < n; i++) {
            dp[i] = (i == 0 ? 0 : dp[i - 1]) + a;
            for (int j = 1; j <= min((i + 1) / 2, maxLen[i]); j++) {
                if (dp[i] > dp[i - j] + b)
                    dp[i] = dp[i - j] + b;
            }
        }
        out.println(dp[n - 1]);
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

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

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

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

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

        boolean hasNextLine() throws IOException {
            return br.ready();
        }

    }

    private void run() throws IOException {
        in = new FastScanner(System.in); // new FastScanner(new FileInputStream(".in"));
        out = new PrintWriter(System.out); // new PrintWriter(new FileOutputStream(".out"));

        solve();

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

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


import java.util.Scanner;

import static java.lang.Math.min;

public class D {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int a = in.nextInt();
        int b = in.nextInt();
        String s = in.next();
        int p[][] = new int[n][n];
        int x[][] = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                p[i][j] = -1;
                x[i][j] = -1;
            }
        }
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (s.charAt(j) == s.charAt(i)) {
                    p[i][0] = j;
                    x[i][0] = j;
                }
            }
            for (int j = 1; j + i < n; j++) {
                int t = i;
                while (p[t][j - 1] != -1) {
                    if (s.charAt(p[t][j - 1] + j) == s.charAt(i + j)) {
                        p[i][j] = p[t][j - 1];
                        break;
                    }
                    t = p[t][j - 1];
                }
                if (t == 0 && s.charAt(j) == s.charAt(i + j)) {
                    p[i][j] = 0;
                }
            }
        }

        for (int i = 1; i < n; i++) {
            for (int j = 1; j + i < n; j++) {
                int t = i;
                while (p[t][j] != -1) {
                    if (p[t][j] + j < i) {
                        x[i][j] = p[t][j];
                        break;
                    }
                    t = p[t][j];
                }
                if (t == 0 && s.charAt(j) == s.charAt(i + j) && j < i) {
                    x[i][j] = 0;
                }
            }
        }
        int ans[] = new int[n];
        ans[0] = a;
        for (int i = 1; i < n; i++) {
            ans[i] = ans[i - 1] + a;
            for (int j = 0; j < i; j++) {
                if (x[i - j][j] != -1) ans[i] = min(ans[i - j - 1] + b, ans[i]);
            }
        }
        System.out.println(ans[n - 1]);
    }
}


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

import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Comparator.comparingInt;

public class Main {
    FastScanner in;
    PrintWriter out;

    private void solve() throws IOException {
        int n = in.nextInt(), a = in.nextInt(), b = in.nextInt();
        char[] s = in.next().toCharArray();

        int[] pi = new int[n];
        int[] maxLen = new int[n];
        for (int id = 0; id < n; id++) {
            pi[id] = 0;
            for (int i = 1, j = 0; id + i < n; i++) {
                while (j > 0 && s[id + i] != s[id + j])
                    j = pi[id + j - 1];
                if (s[id + i] == s[id + j])
                    j++;
                while (j > (i + 1) / 2)
                    j = pi[id + j - 1];
                pi[id + i] = j;
                if (j > maxLen[id + i])
                    maxLen[id + i] = j;
            }
        }

        int[] dp = new int[n];
        for (int i = 0; i < n; i++) {
            dp[i] = (i == 0 ? 0 : dp[i - 1]) + a;
            for (int j = 1; j <= min((i + 1) / 2, maxLen[i]); j++) {
                if (dp[i] > dp[i - j] + b)
                    dp[i] = dp[i - j] + b;
            }
        }
        out.println(dp[n - 1]);
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

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

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

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

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

        boolean hasNextLine() throws IOException {
            return br.ready();
        }

    }

    private void run() throws IOException {
        in = new FastScanner(System.in); // new FastScanner(new FileInputStream(".in"));
        out = new PrintWriter(System.out); // new PrintWriter(new FileOutputStream(".out"));

        solve();

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

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


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

import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Comparator.comparingInt;

public class Main {
    FastScanner in;
    PrintWriter out;

    int[] Z(StringBuilder s) {
        int n = s.length(), z[] = new int[n];
        for (int i = 1, l = 0, r = 1; i < n; i++) {
            if (i < r)
                z[i] = min(r - i, z[i - l]);
            while (i + z[i] < n && s.charAt(z[i]) == s.charAt(i + z[i]))
                z[i]++;
            if (i + z[i] > r) {
                l = i;
                r = i + z[i];
            }
        }
        return z;
    }

    private void solve() throws IOException {
        int n = in.nextInt(), a = in.nextInt(), b = in.nextInt();
        String s = in.next();

        int[] dp = new int[n];
        for (int i = 0, j = 0; i < n; i++, j = 0) {
            dp[i] = (i == 0 ? 0 : dp[i - 1]) + a;
            for (int c : Z(new StringBuilder(s.substring(0, i + 1)).reverse())) {
                if (min(j, c) > 0 && dp[i] > dp[i - min(j, c)] + b)
                    dp[i] = dp[i - min(j, c)] + b;
                j++;
            }
        }
        out.println(dp[n - 1]);
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

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

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

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

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

        boolean hasNextLine() throws IOException {
            return br.ready();
        }

    }

    private void run() throws IOException {
        in = new FastScanner(System.in); // new FastScanner(new FileInputStream(".in"));
        out = new PrintWriter(System.out); // new PrintWriter(new FileOutputStream(".out"));

        solve();

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

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


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

import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Comparator.comparingInt;

public class Main {
    FastScanner in;
    PrintWriter out;

    int[] pi(StringBuilder s) {
        int n = s.length(), pi[] = new int[n];
        for (int i = 1, j = 0; i < n; i++) {
            while (j > 0 && s.charAt(i) != s.charAt(j))
                j = pi[j - 1];
            if (s.charAt(i) == s.charAt(j))
                j++;
            pi[i] = j;
        }
        return pi;
    }

    private void solve() throws IOException {
        int n = in.nextInt(), a = in.nextInt(), b = in.nextInt();
        String s = in.next();

        int[] dp = new int[n];
        for (int i = 0; i < n; i++) {
            dp[i] = (i == 0 ? 0 : dp[i - 1]) + a;
            int l = 0, r = (i + 1) / 2 + 1;
            while (l + 1 < r) {
                int mid = (l + r) / 2;
                if (maxArray(pi(new StringBuilder(s.substring(0, i - mid + 1) + "#" + s.substring(i - mid + 1, i + 1)).reverse())) >= mid)
                    l = mid;
                else
                    r = mid;
            }
            for (int j = 1; j <= l; j++) {
                if (dp[i] > dp[i - j] + b)
                    dp[i] = dp[i - j] + b;
            }
        }
        out.println(dp[n - 1]);
    }

    int maxArray(int[] a) {
        int max = 0;
        for (int i : a)
            if (i > max)
                max = i;
        return max;
    }

    class FastScanner {
        StringTokenizer st;
        BufferedReader br;

        FastScanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        String next() throws IOException {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }

        boolean hasNext() throws IOException {
            return br.ready() || (st != null && st.hasMoreTokens());
        }

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

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

        double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }

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

        boolean hasNextLine() throws IOException {
            return br.ready();
        }

    }

    private void run() throws IOException {
        in = new FastScanner(System.in); // new FastScanner(new FileInputStream(".in"));
        out = new PrintWriter(System.out); // new PrintWriter(new FileOutputStream(".out"));

        solve();

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

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


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));
            StringBuilder ns = new StringBuilder(sb.toString());
            int[] p = kmp(ns.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 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) {
                    int l = i - p[j];
                    if (l + 1 < p[j]) l = p[j];
                    dp[i] = Math.min(dp[i], dp[l] + 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();
        }
    }

}