#include <bits/stdc++.h>
template <typename T>
void MACRO_VAR_Scan(T& t) {
  std::cin >> t;
}
template <typename First, typename... Rest>
void MACRO_VAR_Scan(First& first, Rest&... rest) {
  std::cin >> first;
  MACRO_VAR_Scan(rest...);
}
template <typename T>
void MACRO_VEC_ROW_Init(int n, T& t) {
  t.resize(n);
}
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Init(int n, First& first, Rest&... rest) {
  first.resize(n);
  MACRO_VEC_ROW_Init(n, rest...);
}
template <typename T>
void MACRO_VEC_ROW_Scan(int p, T& t) {
  std::cin >> t[p];
}
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Scan(int p, First& first, Rest&... rest) {
  std::cin >> first[p];
  MACRO_VEC_ROW_Scan(p, rest...);
}
template <class T>
inline T CHMAX(T& a, const T b) {
  return a = (a < b) ? b : a;
}
template <class T>
inline T CHMIN(T& a, const T b) {
  return a = (a > b) ? b : a;
}
template <class T>
using V = std::vector<T>;
template <class T>
using VV = V<V<T>>;
template <typename S, typename T>
std::ostream& operator<<(std::ostream& os, std::pair<S, T> p) {
  os << "(" << p.first << ", " << p.second << ")";
  return os;
}
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using PAIR = std::pair<ll, ll>;
using PAIRLL = std::pair<ll, ll>;
constexpr ll INFINT = 1 << 30;
constexpr ll INFINT_LIM = (1LL << 31) - 1;
constexpr ll INFLL = 1LL << 60;
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62);
constexpr double EPS = 1e-6;
constexpr ll MOD = 998244353;
constexpr double PI = 3.141592653589793238462643383279;
template <class T, size_t N>
void FILL(T (&a)[N], const T& val) {
  for (auto& x : a) x = val;
}
template <class ARY, size_t N, size_t M, class T>
void FILL(ARY (&a)[N][M], const T& val) {
  for (auto& b : a) FILL(b, val);
}
template <class T>
void FILL(std::vector<T>& a, const T& val) {
  for (auto& x : a) x = val;
}
template <class ARY, class T>
void FILL(std::vector<std::vector<ARY>>& a, const T& val) {
  for (auto& b : a) FILL(b, val);
}
struct HashData {
  ll h1, h2;
  bool operator==(const HashData& rhs) const {
    return h1 == rhs.h1 && h2 == rhs.h2;
  }
  bool operator!=(const HashData& rhs) const { return !(*this == rhs); }
};
class RollingHash {
  template <ll B, ll M>
  class RollingHashPart {
   private:
    size_t len;
    std::vector<ll> pow_b, hash;

   public:
    RollingHashPart() {}
    template <typename T>
    RollingHashPart(const T& s)
        : len(s.size()), pow_b(s.size() + 1), hash(s.size() + 1) {
      pow_b[0] = 1;
      hash[0] = 0;
      for (ll i = 0; i < len; i++) {
        pow_b[i + 1] = (ll)pow_b[i] * B % M;
        hash[i + 1] = ((ll)hash[i] * B + s[i]) % M;
      }
    }
    ll get(ll l, ll r) const {
      ll res = (hash[r] - (ll)hash[l] * pow_b[r - l]) % M;
      if (res < 0) res += M;
      return res;
    }
  };

 public:
  RollingHashPart<1033, 1000000007> rh1;
  RollingHashPart<6037, 999999937> rh2;
  RollingHash() {}
  template <typename T>
  RollingHash(const T& s) : rh1(s), rh2(s) {}
  HashData get(ll l, ll r) const {
    return HashData{rh1.get(l, r), rh2.get(l, r)};
  }
  ll lcp(const RollingHash& rhs, ll l1, ll r1, ll l2, ll r2) const {
    ll lb = 0, ub = std::min(r1 - l1, r2 - l2) + 1;
    while (ub - lb > 1) {
      ll md = (lb + ub) >> 1;
      (get(l1, l1 + md) == rhs.get(l2, l2 + md) ? lb : ub) = md;
    }
    return lb;
  }
};
ll dp[5003];
signed main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);
  ;
  ll n, a, b;
  MACRO_VAR_Scan(n, a, b);
  ;
  std::string s;
  MACRO_VAR_Scan(s);
  ;
  RollingHash rh(s);
  FILL(dp, INFLL);
  dp[0] = 0;
  dp[1] = a;
  for (ll i = (1); i < (n); ++i) {
    CHMIN(dp[i + 1], dp[i] + a);
    ll p = 0;
    for (ll d = (1); d < (n + 1); ++d) {
      if (i + d > n) break;
      while (p + d <= i && rh.get(p, p + d) != rh.get(i, i + d)) ++p;
      if (p + d > i) break;
      CHMIN(dp[i + d], dp[i] + b);
    }
  }
  std::cout << (dp[n]);
  std::cout << "\n";
  ;
  return 0;
}
