#include "bits/stdc++.h"
#define rep(i, a, n) for (auto i = a; i <= (n); ++i)
#define revrep(i, a, n) for (auto i = n; i >= (a); --i)
#define all(a) a.begin(), a.end()
#define sz(a) (int)(a).size()
template<class T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, T b) { if (b < a) { a = b; return 1; } return 0; }
using namespace std;

template<class A, class B> string to_string(const pair<A, B> &p);
template<class A, class B, class C> string to_string(const tuple<A, B, C> &p);
template<class A, class B, class C, class D> string to_string(const tuple<A, B, C, D> &p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string) s); }
string to_string(char c) { return "'" + string(1, c) + "'"; }
string to_string(bool x) { return x ? "true" : "false"; }
template<size_t L> string to_string(const bitset<L> &x) { return x.to_string(); }
template<class A, class T = typename A::value_type> string to_string(const A &v) {
	bool first = 1;
	string res = "{";
	for (const auto &x: v) {
		if (!first) res += ", ";
		first = 0;
		res += to_string(x);
	}
	res += "}";
	return res;
}
template<class A, class B> string to_string(const pair<A, B> &p) {
	return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template<class A, class B, class C> string to_string(const tuple<A, B, C> &p) {
	return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template<class A, class B, class C, class D> string to_string(const tuple<A, B, C, D> &p) {
	return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}

void debug_out() { cerr << endl; }
template<class H, class... T> void debug_out(const H& h, const T&... t) {
	cerr << " " << to_string(h);
	debug_out(t...);
}
#ifndef ONLINE_JUDGE
	#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
	#define debug(...) if (0) puts("No effect.")
#endif

using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;

struct Max {
	int val;
	Max(int val = -0x3f3f3f3f): val(val) {}
	friend Max operator +(Max a, Max b) { return max(a.val, b.val); }
};
void info_apply(Max &a, Max b) {
	a.val = max(a.val, b.val);
}

/**
 * Author: Yuhao Yao
 * Date: 24-01-07
 * Description: 2D Segment Tree of range $[oL, oR] \times [iL, iR]$. Point apply and thus no lazy propogation.
 *  Always define a global $apply$ function to tell segment tree how you apply modification. 
 *  Combine is set as + operation. If you use your own struct, then please define constructor and + operation.
 *  In constructor, $q$ is the number of $pointApply$ you will use. $oL$, $oR$, Note that range parameters can be negative.
 * Usage: Point Add and Range (Rectangle) Sum.
 *  void info_apply(int \&a, int b) { a += b; } // global
 *  ...
 *  SegTree2D<int> pseg(-5, 5, -5, 5, 1); // [-5, 5] * [-5, 5] and 1 update.
 *  int rt = 0; // empty node.
 *  rt = pseg.point_apply(rt, 2, -1, 1); // add 1 to position (2, -1).
 *  int sum = pseg.range_ask(rt, 3, 4, -2, -1); // ask the sum in rectangle [3, 4] * [-2, -1].
 * Time: O(\log (oR - oL + 1) \times \log(iR - iL + 1)) per operation.
 * Status: tested on https://qoj.ac/contest/819/problem/2548.
 */
template<class Info>
struct SegTree2D {
	struct iNode { Info info; int ls, rs; };
	struct oNode { int id; int ls, rs; };
	
	int oL, oR, iL, iR;
	// change to array to accelerate, since allocating takes time. (saves ~ 200ms when allocating 1e7)
	vector<iNode> it;
	vector<oNode> ot;

	// node 0 is left as virtual empty node.
	SegTree2D(int oL, int oR, int iL, int iR, int q): oL(oL), oR(oR), iL(iL), iR(iR), it(1), ot(1) {
		it.reserve(q * (__lg(oR - oL + 1) + 2) * (__lg(iR - iL + 1) + 2) + 1);
		ot.reserve(q * (__lg(oR - oL + 1) + 2) + 1);
	}

	// return new root id.
	template<class... T>
	int point_apply(int rt, int op, int ip, const T&... val) {
		auto idfs = [&](auto &dfs, int &i, int l, int r) {
			if (!i) {
				it.push_back({});
				i = sz(it) - 1;
			}
			if (l == r) {
				info_apply(it[i].info, val...);
				return;
			}
			int mid = (l + r) >> 1;
			auto &[info, ls, rs] = it[i];
			if (ip <= mid) dfs(dfs, ls, l, mid);
			else dfs(dfs, rs, mid + 1, r);
			info = it[ls].info + it[rs].info;
		};
		auto odfs = [&](auto &dfs, int &i, int l, int r) {
			if (!i) {
				ot.push_back({});
				i = sz(ot) - 1;
			}
			idfs(idfs, ot[i].id, iL, iR);
			if (l == r) return;
			int mid = (l + r) >> 1;
			if (op <= mid) dfs(dfs, ot[i].ls, l, mid);
			else dfs(dfs, ot[i].rs, mid + 1, r);
		};
		odfs(odfs, rt, oL, oR);
		return rt;
	}

	Info range_ask(int rt, int qol, int qor, int qil, int qir) {
		Info res{};
		auto idfs = [&](auto &dfs, int i, int l, int r) {
			if (!i || qir < l || r < qil) return;
			if (qil <= l && r <= qir) {
				res = res + it[i].info;
				return;
			}
			int mid = (l + r) >> 1;
			dfs(dfs, it[i].ls, l, mid);
			dfs(dfs, it[i].rs, mid + 1, r);
		};
		auto odfs = [&](auto &dfs, int i, int l, int r) {
			if (!i || qor < l || r < qol) return;
			if (qol <= l && r <= qor) {
				idfs(idfs, ot[i].id, iL, iR);
				return;
			}
			int mid = (l + r) >> 1;
			dfs(dfs, ot[i].ls, l, mid);
			dfs(dfs, ot[i].rs, mid + 1, r);
		};
		odfs(odfs, rt, oL, oR);
		return res;
	}
};


int main() {
	ios::sync_with_stdio(0); cin.tie(0);

	int n, r, b; cin >> n >> r >> b;
	string s; cin >> s;
	vi psr(n + 1), psb(n + 1);
	rep(i, 1, n) psr[i] = psr[i - 1] + (s[i - 1] == 'R');
	rep(i, 1, n) psb[i] = psb[i - 1] + (s[i - 1] == 'B');

	vi rts(r + b, 0), dp(n + 1,0);
	SegTree2D<Max> seg(-n, n, -n, n, n + 1);
	rts[0] = seg.point_apply(rts[0], 0, 0, 0);
	rep(i, 1, n) {
		dp[i] = dp[i - 1];
		int rem = i % (r + b);
		int x = psr[i] - 1ll * i * r / (r + b);
		int y = psb[i] - 1ll * i * b / (r + b);
		chmax(dp[i], seg.range_ask(rts[rem], x, n, y, n).val + i / (r + b));
		rts[rem] = seg.point_apply(rts[rem], x, y, dp[i] - i / (r + b));
	}
	printf("%d\n", dp[n]);
	return 0;
}