#include <bits/stdc++.h>
#define ent '\n'
#define int long long

#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("Ofast,unroll-loops,fast-math,O3")

using namespace std;

const int maxn = 5000 + 12;
const int mod = 999'999'873;
const int MOD = 1e9 + 9;

int dp[maxn][maxn], cost[maxn][maxn];
int ptr[maxn][maxn], nxt[maxn][maxn];
int snxt[maxn][maxn];
int pref[maxn], pw[maxn];
int pr[maxn], p[maxn];
int n, m, k;
int a, b, c;

pair<int, int> get(int l, int r) {
    int res = pref[r] - pref[l - 1] * pw[r - l + 1], ser = pr[r] - pr[l - 1] * p[r - l + 1];
    res %= mod, ser %= MOD;
    if(res < 0) res += mod;
    if(ser < 0) ser += MOD;
    return {res, ser};
}

void solve() {
    string s;
    cin >> n >> s >> a >> b >> c;

    bool fg = 1;
    for(int i = 0; i < n; i++) {
        fg &= (s[i] == 'a');
    }

    s = '+' + s;

    pw[0] = p[0] = 1;
    for(int i = 1; i <= n; i++) {
        pw[i] = pw[i - 1] * 31 % mod;
        pref[i] = (pref[i - 1] * 31 + s[i] - 'a' + 1) % mod;

        p[i] = p[i - 1] * 29 % MOD;
        pr[i] = (pr[i - 1] * 29 + s[i] - 'a' + 1) % MOD;
    }

    for(int i = 0; i <= n; i++) {
        for(int j = 0; j <= n; j++) {
            dp[i][j] = 1e18;
        }
        dp[i][i] = a;
    }

    for(int len = 1; len <= n; len++) {
        map<pair<int, int>, int> last;
        for(int i = n - len + 1; i >= 1; i--) {
            int j = i + len - 1;
            pair<int, int> h = get(i, j);
            ptr[i][j] = i;
            cost[i][j] = c;
            nxt[i][j] = n + 1;

            if(last.count(h)) {
                nxt[i][j] = last[h];
            }
            if(j + len - 1 <= n) {
                last[get(j, j + len - 1)] = j;
            }
        }
    }

    for(int r = 1; r <= n; r++) {
        dp[r][r] = min(a, dp[r][r]);
        for(int l = r; l >= 1; l--) {
            if(l < r) {
                dp[l][r] = min(dp[l][r], min(dp[l + 1][r], dp[l][r - 1]) + a);
            }

            int len = r - l + 1, cost = dp[l][r] + b;
            while(ptr[l][r] <= n) {
                cost += c;
                dp[l][ptr[l][r] + len - 1] = min(dp[l][ptr[l][r] + len - 1], cost);
                cost += (nxt[ptr[l][r]][ptr[l][r] + len - 1] - (ptr[l][r] + len)) * a;
                ptr[l][r] = nxt[ptr[l][r]][ptr[l][r] + len - 1];
            }
        }
    }

    cout << dp[1][n] << ent;
}

int32_t main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int t = 1;
    // cin >> t;
    while (t--) {
        solve();
    }
}