text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using pi = pair<int, int>;
void setIO(string name = "") {
cin.tie(0)->sync_with_stdio(0);
if ((int)(name).size()) {
freopen((name + ".in").c_str(), "r", stdin);
freopen((name + ".out").c_str(), "w", stdout);
}
}
int main() {
setIO();
int n;
cin >> n;
string second;
cin >> second;
int q;
cin >> q;
vi p[26];
for (int i = 0; i < n; i++) {
int c = second[i] - 97;
p[c].push_back(i);
}
for (int i = 0; i < q; i++) {
int m;
cin >> m;
char cc;
cin >> cc;
int c = cc - 97;
if ((int)(p[c]).size() == 0) {
cout << min(m, n) << "\n";
} else if ((int)(p[c]).size() == 1) {
cout << 1 + min(m, n - 1) << "\n";
} else {
int l = 0;
int r = 0;
int ms = 0;
while (l <= r && r < (int)(p[c]).size()) {
int diff = (p[c][r] - p[c][l] - 1) - (r - l - 1);
if (diff <= m) {
ms = max(ms, m + (r - l + 1));
ms = min(ms, n);
r++;
} else {
l++;
}
}
cout << ms << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
string s;
int dp[1505][1505][27], ans[1505][27];
int num;
char ch;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> s >> q;
for (int x = 0; x < 26; ++x)
for (int i = 1; i <= n; ++i)
for (int j = i; j <= n; ++j) {
dp[i][j][x] = dp[i][j - 1][x] + (s[j - 1] != x + 'a');
ans[dp[i][j][x]][x] = max(ans[dp[i][j][x]][x], j - i + 1);
}
for (int i = 1; i <= n; ++i)
for (int x = 0; x < 26; ++x) ans[i][x] = max(ans[i][x], ans[i - 1][x]);
char ch;
while (q--) {
cin >> n >> ch;
cout << ans[n][ch - 'a'] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int main() {
string s;
char a, ch;
int q, cnt, l, r, ans;
cin >> n;
cin >> s;
cin >> q;
while (q) {
q--;
cin >> k >> ch;
r = l = ans = cnt = 0;
while (r < n) {
if (cnt <= k) {
if (s[r] != ch) cnt++;
r++;
}
if (cnt > k) {
if (s[l] != ch) cnt--;
l++;
}
ans = max(r - l, ans);
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1512, MAXL = 28;
char s[MAXN];
int memo[MAXL][MAXN], n;
int size_seg[MAXN];
int dist_seg[MAXN];
int solve(int c, int m) {
if (memo[c][m] != -1) {
return memo[c][m];
}
int qtd_seg = 0;
int last_seg_end = -1;
for (int i = 0; i < n; i++) {
int cur_seg = 0, first_i = i;
while (i < n && s[i] - 'a' == c) {
cur_seg++;
i++;
}
if (cur_seg > 0) {
size_seg[qtd_seg] = cur_seg;
dist_seg[qtd_seg] = first_i - 1 - last_seg_end;
last_seg_end = i - 1;
qtd_seg++;
}
}
dist_seg[qtd_seg] = n - 1 - last_seg_end;
size_seg[qtd_seg] = 0;
int answer = 0;
int left = 0;
int budget = m;
int cur_size = 0;
for (int right = 0; right <= qtd_seg; right++) {
cur_size += dist_seg[right] + size_seg[right];
budget -= dist_seg[right];
while (budget < 0) {
budget += dist_seg[left];
cur_size -= dist_seg[left];
if (left > 0) {
cur_size -= size_seg[left - 1];
}
left++;
}
answer = max(answer, min(cur_size + budget, n));
}
return memo[c][m] = answer;
}
int main() {
scanf("%d", &n);
scanf(" %s", s);
for (int i = 0; i < MAXL; i++) {
for (int k = 0; k < MAXN; k++) {
memo[i][k] = -1;
}
}
int q, m;
char c;
scanf("%d", &q);
while (q--) {
scanf("%d %c", &m, &c);
printf("%d\n", solve(c - 'a', m));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int MOD = 1e9 + 7;
int INF = 1e9;
int n, q;
string s;
int dp[1505][1505][2];
int prec[26][2505];
vector<int> arr[26];
void precal(char c) {
int x = c - 'a';
for (int i = 0; i < n; i++)
for (int j = 0; j <= n; j++) {
if (s[i] == c) {
dp[i][j][1] = (i > 0 ? max(dp[i - 1][j][1], dp[i - 1][j][0]) : 0) + 1;
dp[i][j][0] = (i > 0 ? max(dp[i - 1][j][1], dp[i - 1][j][0]) : 0) + 1;
} else {
if (j > 0)
dp[i][j][1] =
(i > 0 ? max(dp[i - 1][j - 1][1], dp[i - 1][j - 1][0]) : 0) + 1;
else
dp[i][j][1] = -INF;
dp[i][j][0] = 0;
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j <= n; j++)
prec[x][j] = max(prec[x][j], max(dp[i][j][1], dp[i][j][0]));
for (int j = 0; j <= n; j++) prec[x][j] = max(prec[x][j], prec[x][j - 1]);
}
int solve() {
cin >> n >> s >> q;
for (char c = 'a'; c <= 'z'; c++) precal(c);
for (int i = 0; i < q; i++) {
int m;
char x;
cin >> m >> x;
cout << prec[x - 'a'][m] << endl;
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 10;
int n;
char s[1666];
int dp[27][1510][1510];
int ans[27][1510];
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) dp[s[i] - 'a'][i][0] = 1;
for (int i = 0; i < 26; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 0; k <= n; k++) {
if (s[j] == i + 'a')
dp[i][j][k] = max(dp[i][j][k], dp[i][j - 1][k] + 1);
else if (k >= 1)
dp[i][j][k] = max(dp[i][j][k], dp[i][j - 1][k - 1] + 1);
if (k >= 1) ans[i][k] = max(ans[i][k], ans[i][k - 1]);
ans[i][k] = max(ans[i][k], dp[i][j][k]);
}
}
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int len;
char c;
scanf("%d %c", &len, &c);
printf("%d\n", ans[c - 'a'][len]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[2000];
int main() {
int n;
while (~scanf("%d", &n)) {
scanf("%s", s);
int q;
scanf("%d", &q);
while (q--) {
int m;
char ch;
scanf("%d %c", &m, &ch);
int l = 0, r = 0;
int res = -1;
int need = 0;
for (int r = 0; r < n; r++) {
if (s[r] != ch) need++;
while (need > m) {
if (s[l] != ch) need--;
l++;
}
res = max(res, r - l + 1);
}
printf("%d\n", res);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = 1510;
int DP[27][N][N];
int ans[27][N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
memset(DP, 0, sizeof(DP));
memset(ans, 0, sizeof(ans));
DP[s[0] - 'a'][0][0] = 1;
for (int i = (int)1; i < (int)N; i++) DP[s[0] - 'a'][0][i] = 1;
for (char ch = 'a'; ch <= 'z'; ch++) {
if (s[0] == ch) continue;
for (int i = (int)1; i < (int)N; i++) DP[ch - 'a'][0][i] = 1;
}
int len = 1;
for (int i = (int)1; i < (int)(int)(s.size()); i++) {
if (s[i] != s[i - 1]) {
len = 1;
} else {
len++;
}
for (char ch = 'a'; ch <= 'z'; ch++) {
if (s[i] == ch) {
DP[ch - 'a'][i][0] = len;
}
for (int j = (int)1; j < (int)N; j++) {
if (ch == s[i])
DP[ch - 'a'][i][j] = 1 + DP[ch - 'a'][i - 1][j];
else
DP[ch - 'a'][i][j] = 1 + DP[ch - 'a'][i - 1][j - 1];
}
}
}
for (char ch = 'a'; ch <= 'z'; ch++) {
for (int j = 0; j < N; j++) {
for (int i = (int)0; i < (int)(int)(s.size()); i++)
ans[ch - 'a'][j] = max(ans[ch - 'a'][j], DP[ch - 'a'][i][j]);
}
}
int q;
cin >> q;
for (int i = (int)0; i < (int)q; i++) {
int m;
char ch;
cin >> m >> ch;
cout << ans[ch - 'a'][m] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int find(string s, int m, int c) {}
int main() {
int n;
cin >> n;
char s[n];
int q, m, i, j, k;
char c;
for (i = 0; i < n; i++) cin >> s[i];
int dp[26][n + 1];
memset(dp, 0, sizeof(dp));
for (i = 0; i < 26; i++) {
for (j = 0; j < n; j++) {
int count = 0;
for (k = j; k < n; k++) {
if (s[k] != (i + 97)) count++;
dp[i][count] = max(dp[i][count], k - j + 1);
}
}
for (j = 1; j <= n; j++) {
dp[i][j] = max(dp[i][j - 1], dp[i][j]);
}
}
cin >> q;
for (i = 0; i < q; i++) {
cin >> m;
cin >> c;
cout << dp[c - 97][m] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int ans[1505][27];
int co[1505][27];
char s[1505], ss[2];
inline void scan_d(int &ret) {
char c;
ret = 0;
while ((c = getchar()) < '0' || c > '9')
;
while (c >= '0' && c <= '9') {
ret = ret * 10 + (c - '0'), c = getchar();
}
}
void Out(int a) {
if (a > 9) Out(a / 10);
putchar(a % 10 + '0');
}
int main() {
int n;
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; ++i) {
int k = s[i] - 'a';
for (int j = 0; j < 26; ++j) co[i][j] = co[i - 1][j];
++co[i][k];
for (int j = 0; j < i; ++j) {
int len = i - j;
for (int f = 0; f < 26; ++f) {
int z = len - co[i][f] + co[j][f];
if (len > ans[z][f]) ans[z][f] = len;
}
}
}
int m;
scanf("%d", &m);
int z;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 26; ++j)
if (ans[i][j] < ans[i - 1][j]) ans[i][j] = ans[i - 1][j];
}
while (m--) {
scan_d(z);
scanf("%s", ss);
Out(ans[z][ss[0] - 'a']);
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[2000];
int main() {
int n, q;
scanf("%d%s%d", &n, s + 1, &q);
while (q--) {
int t;
char c;
scanf("%d %c", &t, &c);
int l = 1, ans = 0;
for (int i = 1; i <= n; i++) {
if (s[i] != c) t--;
while (t < 0)
if (s[l++] != c) t++;
ans = max(ans, i - l + 1);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, i, st, dr, cnt, sol;
char s[1501], c;
int main() {
cin >> n >> ws;
cin >> (s + 1);
cin >> q;
for (i = 1; i <= q; i++) {
cin >> ws >> m >> ws;
cin.get(c);
st = dr = 1;
cnt = sol = 0;
while (dr <= n) {
if (cnt <= m) {
if (s[dr] != c) cnt++;
dr++;
}
if (cnt > m) {
if (s[st] != c) cnt--;
st++;
}
sol = max(sol, dr - st);
}
cout << sol << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
void swap(long long *xp, long long *yp) {
long long temp = *xp;
*xp = *yp;
*yp = temp;
}
const long long maxn = 1e5 + 1;
void print(vector<long long> v) {
long long i, j, n = v.size();
for (i = 0; i < n; i++) {
cout << v[i] << " ";
}
cout << "\n";
}
void scan(vector<long long> &v, long long n) {
for (long long i = 0; i < n; i++) cin >> v[i];
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y / 2;
x = (x * x) % mod;
}
return res % mod;
}
long long modinv(long long x) { return power(x, mod - 2) % mod; }
vector<bool> prime(maxn, true);
void sieve() {
long long n = maxn;
prime[0] = false;
prime[1] = false;
for (long long p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long i = p * p; i <= n; i += p) prime[i] = false;
}
}
}
int main() {
long long int i, j, inc, dec, t, r;
long long int c, d, e, temp, m, p, w, k, x, y, sum, pre, temp2, mid, n, low,
high, ans;
t = 1;
n = 1;
while (t--) {
cin >> n;
string s;
cin >> s;
vector<vector<long long> > dp(26, vector<long long>(n + 1, 0));
for (i = 0; i < n; i++) {
for (j = 0; j < 26; j++) {
sum = 0;
for (k = i; k < n; k++) {
if (s[k] != 'a' + j) {
sum++;
}
dp[j][sum] = max(dp[j][sum], k - i + 1);
}
}
}
for (i = 1; i <= n; i++) {
for (j = 0; j < 26; j++) {
dp[j][i] = max(dp[j][i], dp[j][i - 1]);
}
}
long long q;
cin >> q;
while (q--) {
char ch;
cin >> m >> ch;
long long ind = ch - 'a';
ans = dp[ind][m];
cout << ans << "\n";
;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i;
char a[1505];
int func(char ch, int p) {
int wL = 0, wR = 0;
int bestL = 0, bestWindow = 0;
int zeroCount = 0;
while (wR < n) {
if (zeroCount <= p) {
if (a[wR] != ch) zeroCount++;
wR++;
}
if (zeroCount > p) {
if (a[wL] != ch) zeroCount--;
wL++;
}
if (wR - wL > bestWindow) {
bestWindow = wR - wL;
bestL = wL;
}
}
return bestWindow;
}
int main() {
scanf("%d", &n);
scanf(" %s", a);
int q, p;
char ch;
map<pair<int, char>, int> m;
scanf("%d", &q);
while (q--) {
scanf("%d %ch", &p, &ch);
if (m[{p, ch}]) {
printf("%d\n", m[{p, ch}]);
continue;
}
int ans = func(ch, p);
printf("%d\n", ans);
m[{p, ch}] = ans;
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:667177216")
using namespace std;
const long long MOD = 1000000000 + 7;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int q;
cin >> q;
for (int(i) = 0; (i) < q; (i)++) {
int ans = 0;
int m;
char c;
cin >> m >> c;
int l = 0, r = 0;
int count = 0;
while (r != n) {
while (r != n && (s[r] == c || count < m)) {
if (s[r] != c) count++;
r++;
}
ans = max(ans, r - l);
if (s[l] != c) count--;
l++;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, num, dp[30][1505];
vector<int> pl[30];
char ch;
string nm;
int main(void) {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> nm >> q;
for (int i = 0; i < int((int)(nm).size()); i++) {
for (int j = 0; j < int(26); j++) {
if (nm[i] == j + 'a')
continue;
else
pl[j].push_back(i);
}
}
for (int i = 0; i < int(26); i++) {
dp[i][0] = 0;
int tmp = 1;
for (int j = 1; j < (int)(pl[i]).size(); ++j) {
if (nm[j] != nm[j - 1]) {
dp[i][0] = max(dp[i][0], tmp);
tmp = 1;
} else {
++tmp;
}
}
dp[i][0] = max(dp[i][0], tmp);
for (int j = 1; j <= n; ++j) {
if (j >= (int)(pl[i]).size())
dp[i][j] = n;
else {
int L = 0, R = j - 1;
while (R <= (int)(pl[i]).size() - 1) {
int goL = pl[i][L], goR = pl[i][R];
while (goL >= 1 && nm[goL - 1] == i + 'a') --goL;
while (goR < n - 1 && nm[goR + 1] == i + 'a') ++goR;
dp[i][j] = max(dp[i][j], goR - goL + 1);
++L, ++R;
}
}
}
}
while (q--) {
cin >> num >> ch;
cout << dp[ch - 'a'][num] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[27][1505];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
int n, q, m;
char c;
cin >> n;
cin >> s;
for (int i = (0); i <= (25); i++) {
char ch = i + 'a';
for (int j = (0); j <= (n - 1); j++) {
int tot = 0;
int need = 0;
for (int k = (j); k <= (n - 1); k++) {
tot++;
if (s[k] != ch) need++;
cnt[i][need] = max(cnt[i][need], tot);
}
}
for (int j = (1); j <= (n); j++) cnt[i][j] = max(cnt[i][j], cnt[i][j - 1]);
}
cin >> q;
while (q--) {
cin >> m >> c;
cout << cnt[c - 'a'][m] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long int dp[26][1501];
int main() {
long long int n;
cin >> n;
string s;
cin >> s;
long long int i, j;
for (i = 0; i < n; i++) {
long long int freq[26] = {0};
for (j = i; j < n; j++) {
freq[s[j] - 97]++;
long long int k;
for (k = 0; k < 26; k++) {
dp[k][j - i + 1 - freq[k]] = max(dp[k][j - i + 1 - freq[k]], j - i + 1);
}
}
}
for (i = 0; i < 26; i++) {
for (j = 1; j <= n; j++) dp[i][j] = max(dp[i][j - 1], dp[i][j]);
}
long long int q;
cin >> q;
while (q--) {
long long int oo;
char c;
cin >> oo >> c;
cout << dp[c - 97][oo] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
int N;
cin >> N;
int ct[N][150];
string second;
cin >> second;
memset(ct, 0, sizeof(ct));
for (int j = 0; j < 150; j++) {
for (int i = 0; i < N; i++) {
if (i == 0) {
if (second[i] == j)
ct[i][j] = 1;
else
ct[i][j] = 0;
} else {
if (second[i] == j)
ct[i][j] = ct[i - 1][j] + 1;
else
ct[i][j] = ct[i - 1][j];
}
}
}
int ans[N + 1][150];
memset(ans, 0, sizeof(ans));
for (int i = 97; i < 97 + 26; i++) {
int x = 0;
for (int j = 0; j < N; j++) {
int ct = 0;
for (int k = j; k < N; k++) {
if (second[k] != i or k == N - 1) {
if (second[k] != i) ct += 1;
}
ans[ct][i] = max(ans[ct][i], k - j + 1);
}
for (int k = ct; k <= N; k++) ans[k][i] = max(ans[k][i], ans[k - 1][i]);
}
}
int Q;
cin >> Q;
while (Q--) {
int m;
char c;
cin >> m >> c;
cout << ans[m][c] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int b[20005];
int cnt2 = 0;
int arr[2005];
void findZeroes(int n, int m) {
int wL = 0, wR = 0;
int bestL = 0, bestWindow = 0;
int zeroCount = 0;
while (wR < n) {
if (zeroCount <= m) {
if (arr[wR] == 0) zeroCount++;
wR++;
}
if (zeroCount > m) {
if (arr[wL] == 0) zeroCount--;
wL++;
}
if (wR - wL > bestWindow) {
bestWindow = wR - wL;
bestL = wL;
}
}
for (int i = 0; i < bestWindow; i++) {
if (arr[bestL + i] == 0) {
b[cnt2] = bestL + i;
cnt2++;
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, q, m, a[20004], i, j, ans[20005];
string s;
char c;
cin >> n >> s >> q;
for (i = 0; i < q; i++) {
int maxi = 0;
cnt2 = 0;
cin >> m >> c;
for (j = 0; j < n; j++) {
if (s[j] == c) {
arr[j] = 1;
} else {
arr[j] = 0;
}
}
findZeroes(n, m);
for (j = 0; j < cnt2; j++) {
arr[b[j]] = 1;
}
for (j = 0; j < n; j++) {
ans[j] = 0;
}
if (arr[0] == 1) {
ans[0] = 1;
}
maxi = ans[0];
for (j = 1; j < n; j++) {
if (arr[j] == 1 && arr[j - 1] == 1) {
ans[j] = ans[j - 1] + 1;
} else if (arr[j] == 1 && arr[j - 1] == 0) {
ans[j] = 1;
}
maxi = max(ans[j], maxi);
}
cout << maxi << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
string s;
cin >> s;
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
int m;
char c;
cin >> m >> c;
int ans = 0;
int l = 0, r = 0, oc = 0;
if (s[r] != c) oc = 1;
while (l < s.size()) {
while (true) {
++r;
if (r == s.size()) {
--r;
break;
}
if (s[r] != c) ++oc;
if (oc > m) {
--r;
--oc;
break;
}
}
ans = max(ans, r - l + 1);
if (s[l] != c) --oc;
++l;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, q, i, j, k, len;
cin >> n;
string s;
cin >> s;
len = s.length();
long long int cnt[27][n + 1];
memset(cnt, 0, sizeof cnt);
for (i = 0; i < len; i++) {
for (j = 0; j < 26; j++) {
if (s[i] - 'a' == j)
cnt[j][i + 1] = cnt[j][i] + 1;
else
cnt[j][i + 1] = cnt[j][i];
}
}
long long int dp[27][n + 1];
memset(dp, 0, sizeof dp);
for (i = 0; i < n; i++) {
for (j = i; j < n; j++) {
for (k = 0; k < 26; k++) {
long long int tt = cnt[k][j + 1] - cnt[k][i], l = j - i + 1;
dp[k][l - tt] = max(dp[k][l - tt], l);
}
}
}
for (i = 0; i < 26; i++) {
for (j = 1; j <= n; j++) {
dp[i][j] = max(dp[i][j - 1], dp[i][j]);
}
}
cin >> q;
while (q--) {
char ch;
cin >> j >> ch;
printf("%lld\n", dp[ch - 'a'][j]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char symbol;
string line;
vector<int> digits;
int n, queries, changed;
vector<vector<int> > answer;
void ToDigits(string line) {
for (int i = 0; i < line.length(); i++) {
digits.push_back((line[i] - 'a'));
}
}
int MaxSequence(int Letter) {
vector<int> dp;
dp.push_back(digits[0] == Letter);
int answer = dp[0];
for (int i = 1; i < digits.size(); i++) {
if (digits[i] == Letter) {
dp.push_back(dp[i - 1] + 1);
} else {
dp.push_back(0);
}
answer = max(answer, dp[i]);
}
return answer;
}
int FindAnswer(int Letter, int Change) {
if (!Change) {
return MaxSequence(Letter);
}
if (Change == digits.size()) {
return Change;
}
int n = digits.size();
int i = 0;
int j = 0;
int k = digits[i] != Letter;
int answer = 0;
while (j < n && i <= j) {
answer = max(answer, j - i + 1);
if (k < Change) {
j++;
if (j == n) {
break;
}
if (digits[j] != Letter) {
k++;
}
} else if (k == Change) {
if (j + 1 < n && digits[j + 1] == Letter) {
j++;
} else {
if (digits[i] != Letter) {
k--;
}
i++;
if (i > j) {
j = i;
if (j == n) {
break;
}
k = digits[i] != Letter;
}
}
}
}
return answer;
}
int main() {
cin >> n;
cin >> line;
ToDigits(line);
answer.resize(26);
for (int k = 0; k < 26; k++) {
answer[k].resize(n + 1);
for (int i = 0; i <= n; i++) {
answer[k][i] = FindAnswer(k, i);
}
}
cin >> queries;
for (int q = 0; q < queries; q++) {
cin >> changed >> symbol;
cout << answer[symbol - 'a'][changed] << endl;
;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <class T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
inline int nxt() {
int wow;
scanf("%d", &wow);
return wow;
}
inline long long int lxt() {
long long int wow;
scanf("%lld", &wow);
return wow;
}
inline double dxt() {
double wow;
scanf("%lf", &wow);
return wow;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, q;
string s;
cin >> n >> s >> q;
while (q--) {
int m;
char c;
cin >> m >> c;
string t = "0" + s;
int ans = 1, cur = 0, i = 1, r = 1;
while (i <= n) {
conhan:
if (i > n || r > n) break;
while (r <= n) {
if (t[r] != c) {
if (cur == m) {
for (int l = i; l <= r; l++) {
if (t[l] != c) {
i = l + 1;
r++;
goto conhan;
}
}
} else
cur++;
}
ans = max(ans, r - i + 1);
r++;
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool is[1501];
int has[1501];
map<pair<int, char>, int> ans;
int main() {
ios_base::sync_with_stdio(false);
int tests, n, r, l, i, k;
string s;
char c;
cin >> n >> s >> tests;
while (tests--) {
cin >> k >> c;
if (ans[make_pair(k, c)] != 0) {
cout << ans[make_pair(k, c)] << endl;
continue;
}
memset(is, 0, sizeof(is));
memset(has, 0, sizeof(has));
for (i = 1; i <= n; i++) is[i] = (s[i - 1] == c) ? 1 : 0;
has[1] = is[1];
for (i = 2; i <= n; i++) has[i] = has[i - 1] + is[i];
int mx = -1;
for (l = 1; l <= n; l++) {
for (r = l + k; r <= n; r++) {
if (k + has[r] - has[l - 1] < r - l + 1) break;
mx = max(mx, has[r] - has[l - 1] + k);
}
}
if (mx == -1) mx = k;
mx = min(mx, n);
cout << mx << endl;
ans[make_pair(k, c)] = mx;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1505;
const long long mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const double eps = 1e-6;
int n, q;
char str[maxn];
int num[30][maxn];
int s[maxn];
void Get_Count() {
memset((num), (0), sizeof(num));
for (int i = 1; i <= n; i++) {
s[i] = str[i] - 'a';
for (int j = 0; j < 26; j++) {
num[j][i] = num[j][i - 1];
if (s[i] != j) num[j][i]++;
}
}
}
int main() {
char c[5];
int k;
while (~scanf("%d", &n)) {
scanf("%s", str + 1);
Get_Count();
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d%s", &k, c);
int id = c[0] - 'a';
if (num[id][n] == n) {
printf("%d\n", k);
continue;
}
int *tmp = num[id];
int end = 1;
int ans = 0;
for (int i = 1; i <= n; i++) {
while (end + 1 <= n && tmp[end + 1] - tmp[i - 1] <= k) end++;
int len = end - i + 1;
ans = max(ans, len);
}
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int MOD = 1e4 + 7;
const int oo = 0x3fffffff;
int n, m, k;
string s;
vector<int> a;
vector<pair<int, int>> Q[26];
vector<int> pos[26];
int res[N];
void solve(int x) {
if (Q[x].size() == 0) return;
vector<pair<int, int>>& vec = Q[x];
vector<vector<int>> dp(n + 1, vector<int>(n + 1, 0));
vector<int> global(n + 1, 0);
for (int i = 1; i <= n; i++)
for (int j = 0; j <= i; j++) {
if (a[i - 1] == x) {
dp[i][j] = dp[i - 1][j] + 1;
global[j] = max(global[j], dp[i][j]);
} else {
dp[i][j] = j > 0 ? dp[i - 1][j - 1] + 1 : 0;
global[j] = max(global[j], dp[i][j]);
}
}
for (int i = 1; i <= n; i++) global[i] = max(global[i], global[i - 1]);
for (int i = 0; i <= vec.size() - 1; i++) {
res[vec[i].second] = global[vec[i].first];
}
}
int main() {
cin >> n;
cin >> s;
for (auto c : s) a.push_back(c - 'a');
cin >> m;
int k;
char ch;
for (int i = 0; i <= m - 1; i++) {
cin >> k >> ch;
Q[ch - 'a'].push_back(make_pair(k, i));
pos[ch - 'a'].push_back(i);
}
for (int i = 0; i <= 25; i++) solve(i);
for (int i = 0; i <= m - 1; i++) cout << res[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1505;
int n, q, cnt[26], ans[26][maxn];
char str[maxn], op[2];
int tmp[maxn];
void gmax(int &x, int y) { x = (x > y ? x : y); }
int main() {
scanf("%d", &n);
scanf("%s", str + 1);
for (int i = 0; i <= 25; ++i) {
for (int j = 1; j <= n; ++j)
if (str[j] - 'a' == i)
tmp[j] = 0;
else
tmp[j] = 1;
for (int j = 1; j <= n; ++j) tmp[j] += tmp[j - 1];
for (int j = 1; j <= n; ++j)
for (int k = j; k <= n; ++k) gmax(ans[i][tmp[k] - tmp[j - 1]], k - j + 1);
for (int j = 1; j <= n; ++j) gmax(ans[i][j], ans[i][j - 1]);
}
scanf("%d", &q);
while (q--) {
int d, z;
scanf("%d%s", &d, op);
z = op[0] - 'a';
printf("%d\n", ans[z][d]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)5e3 + 100;
const int mod = (int)1e9 + 7;
const int maxlog = (int)20;
const int P = mod;
int n, cnt[28][maxn], q;
char second[maxn];
int get(int l, int r, char c) { return cnt[c - 'a'][r] - cnt[c - 'a'][l - 1]; }
int first(int m, char c) {
int j = 1;
int res = 0;
for (int i = 1; i <= n; i++) {
j = max(j, i);
while (j <= n && j - i + 1 - get(i, j, c) <= m) ++j;
res = max(res, j - i);
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> second[i];
cnt[second[i] - 'a'][i]++;
}
for (int i = 0; i < 26; i++)
for (int j = 1; j <= n; j++) cnt[i][j] += cnt[i][j - 1];
cin >> q;
while (q--) {
int m;
char c;
cin >> m >> c;
cout << first(m, c) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, m, v[26][2048];
char s[2048], o[4];
int main() {
cin >> n;
cin >> s;
for (int i = 0; i < n; ++i) {
int c[32] = {0};
for (int j = i; j < n; ++j) {
++c[s[j] - 'a'];
for (int k = 0; k < 26; ++k)
v[k][j + 1 - i - c[k]] = max(v[k][j + 1 - i - c[k]], j + 1 - i);
}
}
for (int i = 0; i < 26; ++i)
for (int j = 1; j < 2048; ++j) v[i][j] = max(v[i][j], v[i][j - 1]);
for (cin >> q; q-- > 0;) {
cin >> m >> o;
cout << v[*o - 'a'][m] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
int dp[26][n + 1];
vector<int> count(26, 0);
for (int i = 0; i < s.size(); i++) count[s[i] - 'a']++;
for (int i = 0; i < 26; i++) {
for (int j = 0; j <= n; j++) {
dp[i][j] = 0;
char a = i + 'a';
int maxs = j;
if (count[a - 'a'] + maxs >= n) {
dp[i][j] = n;
continue;
}
int cnt = 0;
int end = 0;
int start = 0;
unordered_map<char, int> m;
int maxl = 0;
while (end < n) {
m[s[end]]++;
if (s[end] == a) {
maxl = max(maxl, end - start + 1);
} else {
if (cnt == maxs) {
while (cnt == maxs && start <= end) {
m[s[start]]--;
if (s[start] != a) cnt--;
start++;
}
cnt++;
maxl = max(maxl, end - start + 1);
} else if (cnt < maxs) {
maxl = max(maxl, end - start + 1);
cnt++;
}
}
end++;
}
dp[i][j] = maxl;
}
}
int q;
cin >> q;
while (q--) {
int m;
char x;
cin >> m >> x;
cout << dp[x - 'a'][m] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
set<long long> gera_primos(long long n) {
set<long long> primos;
vector<bool> crivo(n);
primos.insert(2);
for (long long i = 3; i <= n; i += 2) {
if (crivo[i]) continue;
primos.insert(i);
for (long long j = i; j <= n; j += i) {
crivo[j] = true;
}
}
return primos;
}
struct Node {
long long id, ord, antes;
bool visitado;
long long n;
set<long long> out;
set<long long> in;
Node() {
static long long i = 0;
id = i++;
}
};
struct Cluster {
long long dist, size;
long long soma_dist, soma_size;
};
int main() {
long long n, q;
string s;
cin >> n >> s >> q;
s += '0';
map<char, map<long long, long long>> resp;
for (long long c = 'a'; c < (long long)'z' + 1; c++) {
vector<Cluster> clusters(1);
clusters[0] = {0, 0, 0, 0};
long long start = -1, end = -1;
long long j = 0;
char ant = '\0';
bool clus = false;
for (long long i = 0; i < (long long)n + 1; i++) {
if (s[i] == c) {
if (clus) continue;
clus = true;
j++;
clusters.push_back({0, 0, 0, 0});
if (start == -1) {
end = i - 1;
}
start = i;
clusters[j].dist = start - end - 1;
clusters[j].soma_dist = clusters[j].dist + clusters[j - 1].soma_dist;
} else if (clus) {
clus = false;
clusters[j].size = i - start;
clusters[j].soma_size = clusters[j].size + clusters[j - 1].soma_size;
end = i - 1;
}
}
map<long long, long long> m;
for (long long i = 0; i < (long long)clusters.size(); i++) {
m[clusters[i].soma_dist] = i;
}
for (long long k = 1; k < (long long)n + 1; k++) {
long long maximo = -(long long)1e18;
for (long long i = 1; i < (long long)clusters.size(); i++) {
auto it = m.upper_bound(k + clusters[i].soma_dist);
if (it != m.begin()) it--;
long long j = it->second;
long long size = clusters[j].soma_size - clusters[i - 1].soma_size + k;
maximo = max(maximo, size);
}
resp[c][k] = max(k, min(n, maximo));
}
}
for (long long i = 0; i < (long long)q; i++) {
string s;
long long m;
cin >> m >> s;
char c = s[0];
printf("%lld\n", resp[c][m]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[(int)1505], DP[(int)1505][(int)1505][28], ans[(int)1505][28];
int solve(int n, int m, int c) {
if (DP[n][m][c] != -1) {
return DP[n][m][c];
}
if (n == 0) {
return DP[n][m][c] = 0;
}
if (arr[n] != c and m == 0) {
return DP[n][m][c] = 0;
}
if (arr[n] == c) {
return DP[n][m][c] = 1 + solve(n - 1, m, c);
}
return DP[n][m][c] = 1 + solve(n - 1, m - 1, c);
}
int main() {
memset(DP, -1, sizeof DP);
int n, i, j, k;
scanf("%d", &n);
string s;
cin >> s;
for (i = 0; i < n; i++) {
arr[i + 1] = s[i] - 'a' + 1;
}
int q;
scanf("%d", &q);
for (i = n; i > 0; i--) {
for (j = 26; j > 0; j--) {
int temp = -1;
for (k = n; k > 0; k--) {
if (temp >= k) break;
temp = max(temp, solve(k, i, j));
}
ans[i][j] = temp;
}
}
for (i = 0; i < q; i++) {
int m, c;
char cc;
scanf("%d", &m);
cin >> cc;
c = cc - 'a' + 1;
printf("%d\n", ans[m][c]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q, i, j, k;
string s;
cin >> n >> s >> q;
int a[26][1505] = {};
for (i = 0; i < 26; i++) {
for (j = 0; j < s.size(); j++) {
int used = 0;
for (k = 0; j + k < s.size(); k++) {
if (s[j + k] != 'a' + i) used++;
a[i][used] = max(a[i][used], k + 1);
}
}
for (j = 1; j <= n; j++) {
a[i][j] = max(a[i][j], a[i][j - 1]);
}
}
for (i = 0; i < q; i++) {
int t1;
char t2;
cin >> t1 >> t2;
cout << a[(int)(t2 - 'a')][t1] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
const int maxm = 4e5 + 10;
const int maxb = 26;
const int sigma_size = 62;
const double eps = 1e-8;
const long long mod = 1e9 + 7;
const double pi = acos(-1.0);
const int Ha = 2333;
const long long Linf = 3e12 + 10;
const int inf = 1e9 + 7;
const double Dinf = 1000000007.0;
char s[1510];
int main() {
int n, Q;
while (~scanf("%d%s%d", &n, s, &Q)) {
while (Q--) {
int m;
char op[2];
scanf("%d%s", &m, op);
char c = op[0];
int ans = 0, cnt = m;
int l = 0, r = 0;
while (r < n) {
if (s[r] != c) cnt--;
r++;
if (cnt < 0) {
ans = max(ans, r - l - 1);
while (s[l] == c) l++;
l++;
cnt++;
}
}
ans = max(ans, r - l);
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int n;
int ans(int a, char ch) {
int mxlen = a;
int done = 0;
int pnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] != ch) done++;
while (done > a) {
if (s[pnt] != ch) done--;
pnt++;
}
mxlen = max(mxlen, i - pnt + 1);
}
return mxlen;
}
int main() {
int q;
cin >> n >> s >> q;
int a;
char ch;
while (q--) {
cin >> a >> ch;
cout << ans(a, ch) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
int main() {
long long n, i, j;
cin >> n;
string s;
cin >> s;
long long len = s.length();
long long dp[27][len + 1];
memset(dp, 0, sizeof(dp));
for (long long start = 0; start < 26; start++) {
for (i = 0; i <= len - 1; i++) {
long long rep = 0;
for (j = i; j <= len - 1; j++) {
if (s[j] != char('a' + start)) {
++rep;
}
dp[start][rep] = max(dp[start][rep], j - i + 1);
}
}
for (i = 1; i <= len; i++)
dp[start][i] = max(dp[start][i], dp[start][i - 1]);
}
long long q;
cin >> q;
while (q--) {
long long m;
char c;
cin >> m;
cin >> c;
cout << dp[c - 'a'][m] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sum[26][1510], ans[1510][26];
char str[1510];
int main() {
int N;
scanf("%d%s", &N, str + 1);
for (int i = 1; i <= N; i++) {
sum[str[i] - 'a'][i]++;
}
for (int i = 0; i < 26; i++) {
for (int j = 1; j <= N; j++) sum[i][j] += sum[i][j - 1];
}
for (int c = 0; c < 26; c++) {
for (int i = 1; i <= N; i++) {
for (int j = i; j <= N; j++) {
int m = j - i + 1 - (sum[c][j] - sum[c][i - 1]);
ans[m][c] = max(ans[m][c], j - i + 1);
}
}
}
for (int c = 0; c < 26; c++)
for (int m = 1; m <= N; m++) ans[m][c] = max(ans[m - 1][c], ans[m][c]);
int Q, m;
char ch[2];
scanf("%d", &Q);
while (Q--) {
scanf("%d%s", &m, ch);
printf("%d\n", ans[m][ch[0] - 'a']);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, q, a, p[20005][35], dp[35][20005];
string s;
char c;
int main() {
cin >> n;
cin >> s;
s = '#' + s;
for (int i = 1; i <= n; i++) {
if (i != 1)
for (int j = 0; j <= 27; j++) {
p[i][j] = p[i - 1][j];
}
p[i][s[i] - 'a']++;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
for (int k = 0; k <= 27; k++) {
long long x = j - i + 1;
long long y = p[j][k] - p[i - 1][k];
dp[k][x - y] = max(dp[k][x - y], x);
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 27; j++) {
dp[j][i] = max(dp[j][i], dp[j][i - 1]);
}
}
cin >> q;
while (q--) {
cin >> a >> c;
cout << dp[c - 'a'][a] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1510;
int n;
char s[maxn];
vector<int> a[26], b[26];
int main() {
cin >> n;
scanf("%s", s + 1);
for (register int ch = 0; ch < 26; ++ch) {
a[ch].push_back(0), b[ch].push_back(0);
for (register int i = 1; i <= n; ++i)
if (s[i] == 'a' + ch) a[ch].push_back(i), b[ch].push_back(0x7f7f7f7f);
}
for (register int ch = 0; ch < 26; ++ch) {
int lena = a[ch].size() - 1;
for (register int i = 1; i <= lena; ++i)
for (register int j = i; j <= lena; ++j) {
int nd = a[ch][j] - a[ch][i] - j + i;
b[ch][j - i + 1] = min(b[ch][j - i + 1], nd);
}
}
int Q;
cin >> Q;
while (Q--) {
int m;
scanf("%d", &m);
char c = getchar();
while (c < 'a' || c > 'z') c = getchar();
int ch = c - 'a';
int lenc = a[ch].size() - 1;
if (n - lenc <= m) {
printf("%d\n", n);
continue;
}
int l(1), r(lenc), rec(0);
while (l <= r) {
int mid(l + r >> 1);
if (b[ch][mid] <= m)
rec = mid, l = mid + 1;
else
r = mid - 1;
}
printf("%d\n", m + rec);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
const int INF = 1e18;
const int MOD = 1e9 + 7;
const double PI = acos(-1.0);
char s[N];
int q, pr[N][29], a[N][29], n;
int solve(int m, char ch) {
ch -= 'a';
if (a[m][ch]) {
return a[m][ch] - 1;
}
int mn = 1;
int mx = 0;
for (int i = 1; i <= n; i++) {
while (mn + 1 <= n && pr[mn + 1][ch] - pr[i - 1][ch] <= m) mn++;
mx = max(mx, mn - i + 1);
}
a[m][ch] = mx + 1;
return mx;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 1; i <= n; i++) {
for (char j = 'a'; j <= 'z'; j++) {
pr[i][j - 'a'] = pr[i - 1][j - 'a'];
if (s[i] != j) pr[i][j - 'a'] += 1;
}
}
cin >> q;
while (q--) {
int m;
char ch;
cin >> m >> ch;
cout << solve(m, ch) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {+1, -1, 0, 0};
int dy[] = {0, 0, +1, -1};
int dx2[] = {+1, -1, 0, 0, +1, +1, -1, -1};
int dy2[] = {0, 0, +1, -1, +1, -1, -1, +1};
inline long long squ(long long x) { return (x * x); }
inline long long power(long long bs, long long k) {
long long x = 1LL, y = bs;
if (k == 0) return 1LL;
while (k > 0) {
if (k % 2) x *= y;
y *= y;
k /= 2;
}
return x;
}
int dp[30][1010 * 2], a[1510], n, sm[26][1010 * 2];
char s[1010 * 2];
bool func(int x, int mx, int id) {
int i, j, cnt = 0;
for (i = 0; i <= n - mx; i++) {
cnt = sm[id][i + mx - 1];
if (i > 0) cnt -= sm[id][i - 1];
if (cnt <= x) return true;
}
return false;
}
int main() {
cout.unsetf(ios::floatfield);
cout.precision(6);
cout.setf(ios::fixed, ios::floatfield);
;
scanf("%d", &n);
int i, j;
scanf("%s", s);
memset(sm, 0, sizeof(sm));
for (i = 0; i < n; i++) {
a[i] = s[i] - 'a';
for (j = 0; j < 26; j++) {
if (a[i] != j) sm[j][i] = 1;
}
}
for (j = 0; j < 26; j++) {
for (i = 1; i <= n; i++) sm[j][i] += sm[j][i - 1];
}
int lo, hi, mid;
for (i = 0; i < 26; i++) {
for (j = 1; j <= n; j++) {
lo = 0, hi = n;
while (lo < hi) {
mid = (lo + hi + 1) / 2;
if (func(j, mid, i))
lo = mid;
else
hi = mid - 1;
}
dp[i][j] = lo;
}
}
int q, m, ans;
char c[10];
scanf("%d", &q);
for (i = 0; i < q; i++) {
scanf("%d %s", &m, c);
ans = c[0] - 'a';
printf("%d\n", dp[ans][m]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
char c;
string str;
int n, m, var, st, en, dp[26][1505], ans[26][1505];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> str;
for (int i = 0; i < 26; ++i) {
for (int j = 0; j < n; ++j) {
int cng = 0;
for (int k = j; k < n; ++k) {
if (str[k] != 'a' + i) ++cng;
ans[i][cng] = max(ans[i][cng], dp[i][cng] = max(dp[i][cng], k - j + 1));
}
for (int k = 1; k <= 1500; ++k) ans[i][k] = max(ans[i][k], ans[i][k - 1]);
}
}
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> var >> c;
cout << ans[c - 'a'][var] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<vector<int>> a(26, vector<int>(n, 0));
vector<vector<int>> dp(26, vector<int>(n + 1, 0));
vector<vector<int>> ones(26);
string s;
cin >> s;
for (int i = 0; i < n; i++) {
a[s[i] - 'a'][i] = 1;
ones[s[i] - 'a'].push_back(i);
}
for (int i = 0; i < 26; i++) ones[i].push_back(n);
for (auto al = 0; al < 26; al++) {
for (int i = n - 1; i >= 0; i--) {
dp[al][n - i] = dp[al][n - i - 1] + (a[al][i] == 0);
}
dp[al].erase(dp[al].begin());
}
vector<vector<int>> ans(26, vector<int>(n + 1, 0));
for (int pt = 0; pt < 26; pt++) {
for (int k = 0; k <= n; k++) {
int mx = 0;
for (int i = 0; i < n; i++) {
int foo = dp[pt][n - 1 - i];
auto it = upper_bound((dp[pt]).begin(), (dp[pt]).end(), foo + k);
int bar;
if (it == dp[pt].end()) {
bar = (int)dp[pt].size() - 1;
} else {
bar = it - dp[pt].begin();
bar = max(0, bar - 1);
}
int rem = foo + k - dp[pt][bar] - !a[pt][i];
bar = n - 1 - bar;
auto ex = *upper_bound((ones[pt]).begin(), (ones[pt]).end(), i);
int cand = i - bar + 1 + min(rem, ex - i - 1);
mx = max(mx, cand);
}
ans[pt][k] = mx;
}
}
int q;
cin >> q;
while (q--) {
int m;
string c;
cin >> m >> c;
int pt = c[0] - 'a';
cout << ans[pt][m] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, qti;
string s;
char qc;
int ans[400][1510], pre[400][1510];
inline int Count(char c, int ti) {
if (pre[c][n] + ti >= n) return n;
int lb = 0, ub, mx = 0;
for (ub = 1; ub <= n; ub++) {
while (pre[c][ub] - pre[c][lb] + ti < ub - lb) lb++;
mx = max(mx, ub - lb);
}
return mx;
}
int main() {
cin >> n >> s >> q;
for (int i = 0; i < n; i++) {
for (char c = 'a'; c <= 'z'; c++) pre[c][i + 1] = pre[c][i] + (s[i] == c);
}
for (char c = 'a'; c <= 'z'; c++) {
for (int ti = 1; ti <= n; ti++) ans[c][ti] = Count(c, ti);
}
for (int i = 0; i < q; i++) {
scanf("%d", &qti);
cin >> qc;
printf("%d\n", ans[qc][qti]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int dp[30][2000];
int main() {
int n, l, r;
char ch;
cin >> n >> s;
for (int i = 0; i < 26; i++) {
ch = i + 'a';
for (int j = 0; j < n; j++) {
int num = 0;
for (int k = j; k < n; k++) {
if (s[k] != ch) num++;
dp[i][num] = max(dp[i][num], k - j + 1);
}
}
}
int q;
cin >> q;
while (q--) {
scanf("%d %c", &l, &ch);
printf("%d\n", dp[ch - 'a'][l] ? dp[ch - 'a'][l] : n);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int vec[28][2001];
int ans[28][1502];
int n;
string s;
int k;
int cnt, cnt_need;
int q;
char symbol;
int m;
int Ans[26][1502];
void up(int &a, int b) {
if (b > a) a = b;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
cin >> s;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 26; ++j) vec[j][i] = vec[j][i - 1];
++vec[s[i - 1] - 'a'][i];
}
for (int k = 0; k < 26; ++k) {
for (int i = 1; i <= n; ++i)
for (int j = i; j <= n; ++j) {
cnt = vec[k][j] - vec[k][i - 1];
cnt_need = (j - i + 1) - cnt;
up(ans[k][cnt_need], j - i + 1);
}
for (int i = 0; i < n; ++i) up(ans[k][i + 1], ans[k][i]);
}
cin >> q;
while (q-- > 0) {
cin >> m >> symbol;
cout << ans[symbol - 'a'][m] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int d[1503][1503][26], e[1503][26], z[1503][26];
int main() {
ios::sync_with_stdio(false);
int n, q, m;
char c;
string s;
cin >> n >> s >> q;
for (int i = 0; i < 26; i++)
for (int j = 1; j <= n; j++) e[j][i] = e[j - 1][i] + (s[j - 1] == 'a' + i);
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
for (int k = 0; k < 26; k++) d[i][j][k] = e[j][k] - e[i - 1][k];
for (int i = 1; i <= n; i++)
for (int j = 0; j < 26; j++) {
int l = 1;
for (int k = 1; k <= n; k++) {
while (d[l][k][j] + i < k - l + 1) l++;
z[i][j] = max(z[i][j], k - l + 1);
}
}
while (q--) cin >> m >> c, cout << z[m][c - 'a'] << '\n';
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
char s[2100];
int main() {
int n, q, ans, L, cnt, x;
scanf("%d", &n);
scanf("%s", s);
scanf("%d", &q);
while (q--) {
char c;
scanf("%d %c", &x, &c);
ans = 0;
cnt = 0;
L = 0;
for (int i = 0; i < n; i++) {
if (s[i] != c) {
cnt++;
}
while (cnt > x) {
if (s[L] != c) cnt--;
L++;
}
ans = max(ans, i - L + 1);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int c[1505][26];
long long int val[1505][26];
long long int ans[1505][26];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
string s;
cin >> s;
memset(c, 0, sizeof(c));
memset(val, 0, sizeof(val));
memset(ans, 0, sizeof(ans));
for (long long int i = 0; i < n; i++) c[i + 1][s[i] - 'a']++;
for (long long int k = 0; k < 26; k++)
for (long long int i = 1; i <= n; i++) c[i][k] += c[i - 1][k];
for (long long int i = 0; i < n; i++)
for (long long int j = i; j < n; j++)
for (long long int k = 0; k < 26; k++)
val[j - i + 1 - (c[j + 1][k] - c[i][k])][k] =
max(val[j - i + 1 - (c[j + 1][k] - c[i][k])][k], j - i + 1);
for (long long int k = 0; k < 26; k++) {
ans[0][k] = val[0][k];
for (long long int i = 1; i <= n; i++)
ans[i][k] = max(ans[i - 1][k], val[i][k]);
}
long long int q;
cin >> q;
while (q--) {
long long int m, col;
char ch;
cin >> m;
cin >> ch;
col = ch - 'a';
cout << ans[m][col] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
using ld = long double;
template <class T>
void read_v(T& x, std::istream& in) {
in >> (x);
}
template <class A>
void read_vec(vector<A>& x, std::istream& in) {
for (auto& a : x) read_v(a, in);
}
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char* x) { cerr << '\"' << x << '\"'; }
void __print(const string& x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V>& x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T& x) {
int f = 0;
cerr << '{';
for (const auto& i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
int iceildiv(const int a, const int b) {
if (a == 0) {
return 0;
}
return (1 + ((a - 1) / b));
}
bool sortpairbysec(const pair<int, int>& a, const pair<int, int>& b) {
return (a.second < b.second);
}
template <typename T>
int power(T a, T b) {
int ans = 1;
while (b > 0) {
if (b & 1) {
ans *= a;
}
a *= a;
b >>= 1;
}
return ans;
}
template <typename T>
void setmin(T& a, T b) {
if (b < a) a = b;
}
template <typename T>
void setmax(T& a, T b) {
if (b > a) a = b;
}
const int INF = 1e9;
void solve() {
int n;
cin >> n;
string st;
cin >> st;
vector<vector<int>> mp(26, vector<int>(n + 1, 0));
for (int ci = 0; ci < 26; ci++) {
for (int i = 0; i < n; i++) {
int curr = 0;
for (int j = i; j < n; j++) {
if (st[j] - 'a' != ci) {
curr++;
}
setmax(mp[ci][curr], j - i + 1);
}
}
}
for (int ci = 0; ci < 26; ci++) {
for (int i = 1; i <= n; i++) {
setmax(mp[ci][i], mp[ci][i - 1]);
}
}
int q;
cin >> q;
for (int qi = 0; qi < q; qi++) {
int m;
char c;
cin >> m >> c;
int ans = mp[c - 'a'][m];
cout << (ans) << '\n';
}
return;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int test_cases = 1;
while (test_cases--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1505;
const int maxq = 200005;
int n, q;
char str[maxn];
struct Query {
int r, c, i;
Query() {}
Query(int rr, int cc, int ii) : r(rr), c(cc), i(ii) {}
};
bool cmp(Query &q1, Query &q2) { return q1.r < q2.r; }
vector<Query> queryVec[26];
vector<int> vec[26];
int dp[26][maxn];
int ans[maxq];
void init() {
for (int i = 0; i < 26; ++i) {
queryVec[i].clear();
vec[i].clear();
}
int len = strlen(str);
for (int i = 0; i < len; ++i) {
int val = str[i] - 'a';
vec[val].push_back(i);
}
memset(dp, 0, sizeof(dp));
memset(ans, 0, sizeof(ans));
for (int i = 0; i < 26; ++i) {
if (vec[i].size() > 0) {
dp[i][0] = 1;
}
int maxInd = 0;
for (int j = 0; j < vec[i].size(); ++j) {
for (int k = j + 1; k < vec[i].size(); ++k) {
int s = vec[i][j], e = vec[i][k], count = k - j - 1;
int ind = e - s - 1 - count;
dp[i][ind] = max(dp[i][ind], e - s + 1);
maxInd = max(maxInd, ind);
}
}
}
}
void start(int ind) {
sort(queryVec[ind].begin(), queryVec[ind].end(), cmp);
int si = 0, preInd = -1, preMax = 0;
for (int i = 0; i < queryVec[ind].size(); ++i) {
for (int j = si; j < maxn; ++j) {
if (dp[ind][j] != 0) {
preInd = j;
preMax = max(preMax, dp[ind][preInd] - preInd);
}
if (queryVec[ind][i].r == j) {
int tans = 0;
tans = min(n, preMax + queryVec[ind][i].r);
ans[queryVec[ind][i].i] = tans;
si = j;
break;
}
}
}
}
int main() {
while (~scanf("%d", &n)) {
scanf("%s", str);
scanf("%d", &q);
int r;
char c;
init();
for (int i = 0; i < q; ++i) {
scanf("%d %c", &r, &c);
queryVec[c - 'a'].push_back(Query(r, c - 'a', i));
}
for (int i = 0; i < 26; ++i) {
start(i);
}
for (int i = 0; i < q; ++i) {
printf("%d\n", ans[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1505;
char s[maxn];
int n;
int res[30][maxn], dp[maxn][maxn];
void init() {
for (int co = 0; co < 26; co++) {
for (int left = 0; left < n; left++) {
int right = left;
for (int num = 1; num <= n; num++) {
while (right < n && s[right] == 'a' + co) right++;
if (right != n) right++;
while (right < n && s[right] == 'a' + co) right++;
dp[left][num] = right - left;
if (right == n) {
for (int temp = num + 1; temp <= n; temp++)
dp[left][temp] = dp[left][num];
break;
}
}
}
for (int num = 1; num <= n; num++) {
int Max = 0;
for (int left = 0; left < n; left++)
if (Max < dp[left][num]) Max = dp[left][num];
res[co][num] = Max;
}
}
}
int main() {
scanf("%d", &n);
scanf("%s", s);
init();
int q;
scanf("%d", &q);
while (q--) {
int num;
char ch[5];
scanf("%d%s", &num, ch);
printf("%d\n", res[ch[0] - 'a'][num]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m[500][2500];
set<char> se1;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, i, q;
string s;
cin >> n;
cin >> s;
for (i = 0; i < n; i++) se1.insert(s[i]);
for (auto x : se1)
for (i = 0; i < n; i++) {
int co = 0;
for (int j = i; j < n; j++) {
if (s[j] != x) co++;
m[x][co] = max(m[x][co], j - i + 1);
}
}
for (auto x : se1) {
for (i = 0; i < n; i++) {
m[x][i] = max(m[x][i - 1], m[x][i]);
}
}
cin >> q;
for (i = 0; i < q; i++) {
int m1;
char c;
cin >> m1 >> c;
cout << max(m1, m[c][m1]) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, x, y, z;
int f[26][1510];
char s[1510], ch;
int ans;
int Q[1510], l, r;
int main() {
cin >> n;
scanf("%s", s + 1);
for (i = 1; i <= n; i++) {
f[s[i] - 'a'][i] = f[s[i] - 'a'][i - 1] + 1;
for (j = 0; j < 26; j++)
if (j != s[i] - 'a') f[j][i] = f[j][i - 1];
}
scanf("%d", &k);
while (k--) {
scanf("%d", &m);
ch = getchar();
ans = 0;
while (ch < 'a' || ch > 'z') ch = getchar();
Q[l = r = 1] = 0;
for (i = 1; i <= n; i++) {
while (l <= r && i - f[ch - 'a'][i] - (Q[l] - f[ch - 'a'][Q[l]]) > m) l++;
ans = max(ans, i - Q[l]);
Q[++r] = i;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1502][26], DP[1502][26], tmp[1502][26], a[1502];
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
int n, i, j, k;
cin >> n;
string s;
cin >> s;
for (i = 1; i <= n; i++) {
a[i] = s[i - 1] - 'a';
}
for (i = 1; i <= n; i++) {
tmp[0][a[i]] = 1 + dp[0][a[i]];
for (j = 1; j <= i; j++) {
for (k = 0; k < 26; k++) {
if (a[i] == k) {
tmp[j][k] = dp[j][k] + 1;
} else {
tmp[j][k] = dp[j - 1][k] + 1;
}
DP[j][k] = max(DP[j][k], tmp[j][k]);
}
}
DP[0][a[i]] = max(DP[0][a[i]], tmp[0][a[i]]);
dp[0][a[i]] = tmp[0][a[i]];
tmp[0][a[i]] = 0;
for (k = 0; k < 26; k++) {
if (k != a[i]) dp[0][k] = 0;
}
for (j = 1; j <= i; j++) {
for (k = 0; k < 26; k++) {
dp[j][k] = tmp[j][k];
tmp[j][k] = 0;
}
}
}
for (j = 1; j <= n; j++) {
for (k = 0; k < 26; k++) {
DP[j][k] = max(DP[j - 1][k], DP[j][k]);
}
}
int q, m;
char ch;
cin >> q;
while (q--) {
cin >> m >> ch;
cout << DP[m][ch - 'a'] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 1e4 + 5e3;
char s[MAXN];
inline int max(int a, int b) { return a > b ? a : b; }
int main() {
int n, m, ans, q, cnt, l, r;
char c;
scanf("%d%s%d", &n, s + 1, &q);
for (int i = 0; i < q; ++i) {
scanf("%d %c", &m, &c);
l = r = 1;
cnt = 0;
ans = m;
while (r <= n) {
cnt += (s[r] != c);
if (cnt > m) {
cnt -= (s[l] != c);
cnt -= (s[r] != c);
++l;
} else if (cnt <= m) {
ans = max(ans, r - l + 1);
++r;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 27;
const int MAXN = 1502;
int dp[MAXM][MAXN][MAXN], n, q, saghf, ans[MAXM][MAXN];
char letters;
string s;
int main() {
cin >> n >> s >> q;
for (int i = n - 1; i >= 0; i--) {
dp[s[i] - 'a'][i][0] = 1 + dp[s[i] - 'a'][i + 1][0];
}
for (int i = 0; i < 26; i++) {
for (int m = 1; m <= n; m++) {
for (int j = n - 1; j >= 0; j--) {
if ((s[j] - 'a') == i)
dp[i][j][m] = dp[i][j + 1][m] + 1;
else
dp[i][j][m] = dp[i][j + 1][m - 1] + 1;
ans[i][m] = max(ans[i][m], dp[i][j][m]);
}
}
}
for (int i = 0; i < q; i++) {
cin >> saghf >> letters;
cout << ans[letters - 'a'][saghf] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1500 + 10;
const int INF = 1e9;
int ans[MAX_N][26];
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
string s;
cin >> s;
for (int it = 0; it < 26; ++it) {
char c = char(it + 'a');
for (int i = 0; i < n; ++i) {
int cnt = 0;
for (int j = i; j < n; ++j) {
if (s[j] != c) cnt++;
ans[cnt][it] = max(ans[cnt][it], j - i + 1);
}
}
for (int i = 1; i <= n; ++i) {
if (ans[i][it] == 0) {
ans[i][it] = ans[i - 1][it];
}
}
}
int q;
cin >> q;
while (q--) {
int k;
char c;
cin >> k >> c;
cout << ans[k][(int)(c - 'a')] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1800;
int num[26][maxn];
char str[maxn];
int n, k;
int ans[26][maxn];
void getnum(char *s) {
for (int i = 1; i <= n; i++) {
int kk = s[i] - 'a';
for (int j = 0; j < 26; j++) {
num[j][i] = num[j][i - 1];
if (kk != j) num[j][i]++;
}
}
}
void solve() {
for (int i = 0; i < 26; i++) {
for (int k = 1; k <= n; k++) {
int *temp = num[i];
int sum = 0;
int end = 1;
for (int j = 1; j <= n; j++) {
while (end + 1 <= n && temp[end + 1] - temp[j - 1] <= k) end++;
sum = max(sum, end - j + 1);
}
ans[i][k] = sum;
}
}
}
int main() {
cin >> n;
scanf("%s", str + 1);
getnum(str);
solve();
int q;
cin >> q;
while (q--) {
char l[5];
scanf("%d%s", &k, l);
int kk = l[0] - 'a';
printf("%d\n", ans[kk][k]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string str;
int cnt[26] = {
0,
};
int solve(int k, char c) {
int ans, i, temp, kk, l, r;
if (cnt[c - 'a'] + k >= str.size()) return str.size();
if (cnt[c - 'a'] < 2) {
return cnt[c - 'a'] + k;
}
kk = k;
l = 0;
r = str.size() - 1;
for (i = 0; i < str.size(); i++) {
if (str[i] != c) {
kk--;
if (kk == 0) {
r = i;
break;
}
}
}
while (r + 1 < str.size() && str[r + 1] == c) {
r++;
}
ans = r - l + 1;
while (l < str.size() - k + 1) {
if (str[l] != c) {
if (r < str.size() - 1) {
r++;
while (r < str.size() - 1 && str[r] == c) {
r++;
}
while (r + 1 < str.size() && str[r + 1] == c) {
r++;
}
}
}
l++;
temp = r - l + 1;
i = l - 1;
while (i >= 0 && str[i] == c) {
temp++;
i--;
}
if (ans < temp) ans = temp;
}
return ans;
}
int main(int argc, char* argv[]) {
int n, q, k;
char c;
cin >> n;
cin >> str;
for (n = 0; n < str.size(); n++) {
cnt[str[n] - 'a']++;
}
cin >> q;
while (q--) {
cin >> k >> c;
cout << solve(k, c) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
void solve() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
string str;
cin >> str;
vector<vector<int>> calcs(26, vector<int>(n + 1, 0));
for (int i = 0; i < 26; i++) {
char c = i + 'a';
for (int m = 1; m <= n; m++) {
int cur = 0;
int l = 0;
int r = 0;
int temp_m = m;
while (r < n) {
if (str[r] == c) {
cur++;
} else if (temp_m > 0) {
cur++;
temp_m--;
} else {
calcs[i][m] = max(calcs[i][m], cur);
while (str[l] == c) {
cur--;
l++;
}
l++;
}
r++;
}
calcs[i][m] = max(calcs[i][m], cur);
}
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int m;
cin >> m;
char c;
while ((c = cin.get()) == ' ')
;
cout << calcs[c - 'a'][m] << "\n";
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[26][1500];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q, x, y, len, z;
string str;
cin >> n;
cin >> str;
cin >> q;
for (int i = 0; i < 26; i++) {
for (int j = 1; j <= n; j++) {
x = j;
y = z = 0;
len = 0;
while (z < n) {
if ((str[z] - 'a') != i) x--;
if (x >= 0) {
len = max(len, z - y + 1);
z++;
} else {
while ((str[y] - 'a') == i) y++;
y++;
z++;
x = 0;
}
}
dp[i][j] = len;
}
}
while (q--) {
cin >> x >> str;
cout << dp[str[0] - 'a'][x] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, dp[26][1505];
string dat;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> dat;
for (int c = 0; c < 26; ++c) {
for (int i = 0; i < n; ++i) {
int gap = 0;
for (int j = i; j < n; ++j) {
if (dat[j] - 'a' != c) {
++gap;
}
dp[c][gap] = max(dp[c][gap], j - i + 1);
}
}
for (int i = 1; i <= n; ++i) {
dp[c][i] = max(dp[c][i], dp[c][i - 1]);
}
}
cin >> q;
for (int i = 1; i <= q; ++i) {
char c;
int cnt;
cin >> cnt >> c;
cout << dp[c - 'a'][cnt] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1501], c[1];
int main() {
int n, q;
scanf("%d%s%d", &n, s + 1, &q);
while (q--) {
int m, l = 0, ans = 0, cnt = 0;
scanf("%d %s", &m, c);
for (int r = 1; r <= n; r++) {
cnt += s[r] == c[0];
while (r - l - cnt > m) cnt -= s[++l] == c[0];
ans = max(ans, r - l);
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q, m;
string s;
char c;
cin >> n >> s;
int k[26][1501] = {}, dp[26][1501] = {};
for (int i = 0; i < 26; i++)
for (int j = 0; j < n; j++)
k[i][j] = (s[j] - 'a' == i ? 0 : 1) + (j == 0 ? 0 : k[i][j - 1]);
for (int i = 0; i < 26; i++)
for (int j1 = 0; j1 < n; j1++)
for (int j2 = j1; j2 < n; j2++) {
int t = k[i][j2] - (j1 == 0 ? 0 : k[i][j1 - 1]);
dp[i][t] = max(dp[i][t], j2 - j1 + 1);
}
for (int i = 0; i < 26; i++)
for (int j = 0; j <= n; j++)
dp[i][j] = max(dp[i][j], (j == 0 ? 0 : dp[i][j - 1]));
cin >> q;
while (q--) {
cin >> m >> c;
printf("%d\n", dp[c - 'a'][m]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[2000];
int n, q, sum[2000][30];
int p[30][2000];
void make(int x) {
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
int k = sum[j][x] - sum[i - 1][x], d = j - i + 1;
p[x][d - k] = max(p[x][d - k], d);
}
}
int main() {
while (~scanf("%d", &n)) {
scanf("%s", a);
memset(sum, 0, sizeof sum);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) sum[i][j] = sum[i - 1][j];
sum[i][a[i - 1] - 'a']++;
}
memset(p, 0, sizeof p);
for (int i = 0; i <= 25; i++) make(i);
scanf("%d", &q);
while (q--) {
int x, k;
char c[3];
scanf("%d%s", &x, c);
k = c[0] - 'a';
x = min(x, n - sum[n][k]);
printf("%d\n", p[k][x]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1501;
int n, q;
vector<vector<pair<int, int> > > mp;
int sols[30][N];
string s;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
mp.assign(30, vector<pair<int, int> >());
memset(sols, 0, sizeof sols);
cin >> n >> s;
int i = 0;
while (i < n) {
int start = i, end;
while (i < n - 1 && s[i] == s[i + 1]) {
i++;
}
end = i;
mp[s[i] - 'a'].push_back(pair<int, int>(start, end));
i++;
}
for (int i = 0; i < 26; ++i) {
for (int from = 0; from < mp[i].size(); ++from) {
int len = mp[i][from].second - mp[i][from].first + 1;
for (int to = from; to < mp[i].size(); ++to) {
if (from != to) len += mp[i][to].second - mp[i][to].first + 1;
int ans = mp[i][to].second - mp[i][from].first + 1;
sols[i][ans - len] = max(sols[i][ans - len], ans);
}
}
}
for (int i = 0; i < 26; ++i)
for (int j = 1; j < N; ++j)
sols[i][j] = max(sols[i][j], sols[i][j - 1] + 1);
cin >> q;
for (int i = 0; i < q; ++i) {
int m, x;
char c;
cin >> m >> c;
x = c - 'a';
cout << min(n, sols[x][m]) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[30][1505];
int can[30][1505];
int res[30][1505];
int n;
int solve(int ch, int len) {
int mn = 1501;
for (int i = len; i <= n; i++) {
mn = min(len - (dp[ch][i] - dp[ch][i - len]), mn);
}
return mn;
}
int main() {
cin >> n;
string s;
cin >> s;
s = '0' + s;
for (int j = 0; j < 26; j++)
for (int i = 1; i <= n; i++) dp[j][i] = dp[j][i - 1] + ((s[i] - 'a') == j);
for (int j = 0; j < 26; j++) {
for (int i = 1; i <= n; i++) {
res[j][i] = solve(j, i);
}
}
int q;
cin >> q;
while (q--) {
int m;
char c;
scanf("%d", &m);
cin >> c;
int L = 1, R = n, mid, ans;
while (L <= R) {
mid = (L + R) / 2;
if (res[c - 'a'][mid] <= m) {
ans = mid;
L = mid + 1;
} else
R = mid - 1;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1e5 + 2;
const long long mod = 1e9 + 7, inf = 1e18;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
string s;
cin >> s;
s = '#' + s;
int q;
cin >> q;
for (int i = 1; i <= q; i++) {
int m;
char ch;
cin >> m >> ch;
int l = 1, r = 1, cnt = 0, ans = m;
while (r <= n) {
cnt += (s[r] != ch);
if (cnt > m) {
cnt -= (s[l] != ch);
cnt -= (s[r] != ch);
l++;
} else if (cnt <= m) {
ans = max(ans, r - l + 1);
r++;
}
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
const int mod = 1e9 + 7;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
int n, q, ans[1510][26];
string s;
int go(int m, char le) {
if (ans[m][le - 'a'] != 0) return ans[m][le - 'a'];
int l = 0, cnt = 0, res = 0;
for (int r = 0; r < n; r++) {
cnt += (s[r] == le);
while (r - l + 1 - cnt > m) {
if (s[l] == le) cnt--;
l++;
}
res = max(res, r - l + 1);
}
return ans[m][le - 'a'] = res;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
cin >> n >> s;
cin >> q;
for (int i = 0; i < q; i++) {
int m;
char le;
cin >> m >> le;
cout << go(m, le) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n >> s;
int q;
cin >> q;
while (q--) {
int m;
char c;
cin >> m >> c;
int mx = 0, start = 0, ind = -1, l = 0, one = 0;
for (int i = 0; i < n; i++) {
one += (s[i] == c);
l += (s[i] != c);
while (l > m && start <= i) {
l -= (s[start] != c);
one -= (s[start] == c);
start++;
}
if (mx < l + one) mx = l + one, ind = start;
}
cout << mx << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long memo[1510][28];
long long B[28];
int main() {
ios::sync_with_stdio(0);
long long n;
cin >> n;
string second;
cin >> second;
for (long long i = 0; i < n; i++) {
B[second[i] - 'a']++;
}
for (long long i = 0; i <= 27; i++) {
char C = 'a' + i;
for (long long j = 0; j < n; j++) {
long long Counter = 0;
for (long long k = j; k < n; k++) {
if (second[k] != C) Counter++;
memo[Counter][i] = max(memo[Counter][i], k - j + 1);
}
}
}
long long q;
cin >> q;
long long m;
char X;
for (long long i = 0; i < (long long)q; i++) {
cin >> m >> X;
if (B[X - 'a'] + m >= n)
cout << n << endl;
else
cout << memo[m][X - 'a'] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = 1;
const int dx[] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
const int dy[] = {1, 0, -1, 0, -1, 1, 1, -1, 0};
template <typename X>
inline X square(const X& a) {
return a * a;
}
int scan_d() {
bool minus = false;
int result = 0;
char ch;
ch = getchar();
while (true) {
if (ch == '-') break;
if (ch >= '0' && ch <= '9') break;
ch = getchar();
}
if (ch == '-')
minus = true;
else
result = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
result = (result << 3) + (result << 1) + (ch - '0');
}
if (minus)
return -result;
else
return result;
}
long scan_ld() {
bool minus = false;
long result = 0;
char ch;
ch = getchar();
while (true) {
if (ch == '-') break;
if (ch >= '0' && ch <= '9') break;
ch = getchar();
}
if (ch == '-')
minus = true;
else
result = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
result = (result << 3) + (result << 1) + (ch - '0');
}
if (minus)
return -result;
else
return result;
}
long long scan_lld() {
bool minus = false;
long long result = 0;
char ch;
ch = getchar();
while (true) {
if (ch == '-') break;
if (ch >= '0' && ch <= '9') break;
ch = getchar();
}
if (ch == '-')
minus = true;
else
result = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
result = (result << 3) + (result << 1) + (ch - '0');
}
if (minus)
return -result;
else
return result;
}
long long unsigned scan_llu() {
long long unsigned result = 0;
char ch;
ch = getchar();
while (true) {
if (ch == '-') break;
if (ch >= '0' && ch <= '9') break;
ch = getchar();
}
result = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
result = (result << 3) + (result << 1) + (ch - '0');
}
return result;
}
void print_d(int n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 10;
char output_buffer[10];
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 10);
}
void print_ld(long n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 11;
char output_buffer[11];
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 11);
}
void print_lld(long long n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 21;
char output_buffer[21];
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 21);
}
void print_llu(long long unsigned n) {
int i = 21;
char output_buffer[21];
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 21);
}
void println_d(int n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 10;
char output_buffer[11];
output_buffer[10] = '\n';
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 11);
}
void println_ld(long n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 11;
char output_buffer[12];
output_buffer[11] = '\n';
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 12);
}
void println_lld(long long n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 21;
char output_buffer[22];
output_buffer[21] = '\n';
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 22);
}
void println_llu(long long unsigned n) {
int i = 21;
char output_buffer[22];
output_buffer[21] = '\n';
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 22);
}
char sp;
void printsp_d(int n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 10;
char output_buffer[11];
output_buffer[10] = sp;
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 11);
}
void printsp_ld(long n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 11;
char output_buffer[12];
output_buffer[11] = sp;
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 12);
}
void printsp_lld(long long n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 21;
char output_buffer[22];
output_buffer[21] = sp;
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 22);
}
void printsp_llu(long long unsigned n) {
int i = 21;
char output_buffer[22];
output_buffer[21] = sp;
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 22);
}
int pos[27][10000], n, m;
void findZeroes(int idx) {
int wL = 0, wR = 0;
int bestL = 0, bestWindow = 0;
int zeroCount = 0;
while (wR < n) {
if (zeroCount <= m) {
if (pos[idx][wR] == 0) zeroCount++;
wR++;
}
if (zeroCount > m) {
if (pos[idx][wL] == 0) zeroCount--;
wL++;
}
if (wR - wL > bestWindow) {
bestWindow = wR - wL;
bestL = wL;
}
}
cout << bestWindow << endl;
}
int main() {
memset(pos, 0, sizeof(pos));
int i, idx, q, ans;
char c;
string s;
n = scan_d();
cin >> s;
for (i = 0; i < n; i++) {
pos[s[i] - 'a'][i] = 1;
}
q = scan_d();
while (q--) {
m = scan_d();
cin >> c;
idx = c - 'a';
findZeroes(idx);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ans[26][2000];
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
char s[3000];
cin >> s;
for (int i = 'a'; i <= 'z'; i++) {
for (int ii = 0; ii <= n - 1; ii++) {
int mtemp = 0;
int anstemp = 0;
for (int j = ii; j <= n - 1; j++) {
if (s[j] == i) {
anstemp++;
} else if (s[j] != i) {
mtemp++;
anstemp++;
}
if (anstemp > ans[i - 'a'][mtemp]) {
ans[i - 'a'][mtemp] = anstemp;
}
}
}
for (int ii = 1; ii <= n; ii++) {
if (ans[i - 'a'][ii] == 0) {
ans[i - 'a'][ii] = ans[i - 'a'][ii - 1];
}
}
}
int q;
cin >> q;
for (int ii = 0; ii <= q - 1; ii++) {
int m;
char c;
cin >> m;
cin >> c;
cout << ans[c - 'a'][m] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[10010];
int main() {
int n, m, q;
scanf("%d", &n);
getchar();
gets(s);
scanf("%d", &q);
while (q--) {
char ch;
scanf("%d %c", &m, &ch);
int l = 0, r = 0;
for (int i = 0; i < n; i++) {
if (m <= 0 && s[i] != ch) break;
if (s[i] != ch) m--;
r++;
}
int ans = r - l;
for (int i = r; i < n; i++) {
if (s[i] != ch) {
ans = max(ans, i - l);
while (s[l] == ch) l++;
l++;
}
}
ans = max(ans, n - l);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932385;
const long double E = 2.71828182845904523536;
const double eps = 1e-9;
const long long mod = 1e9 + 7;
const long long inf = 1 << 30;
const int N = 2020;
int frq[555][N];
int ans[555][N];
int n;
bool ok(int x, int m, int c) {
for (int i = x - 1; i < n; i++) {
int z = frq[c][i] - frq[c][i - x];
if (x - z <= m) return true;
}
return false;
}
int main() {
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) frq[s[i]][i]++;
for (int c = (int)'a'; c <= (int)'z'; c++)
for (int i = 1; i < n; i++) frq[c][i] = frq[c][i - 1] + frq[c][i];
for (int c = (int)'a'; c <= (int)'z'; c++) {
for (int m = 1; m <= n; m++) {
int lo = 0, hi = n;
while (hi > lo) {
int mid = (lo + hi + 1) >> 1;
if (ok(mid, m, c))
lo = mid;
else
hi = mid - 1;
}
ans[c][m] = lo;
}
}
int q;
cin >> q;
while (q--) {
int m;
char c;
cin >> m >> c;
cout << ans[c][m] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1505, inf = 2000;
int t[26][maxn];
char s[maxn];
int n, q;
void Calt() {
vector<int> a;
for (int c = 0; c < 26; c++) {
a.clear();
t[c][n] = inf;
for (int i = 0; i < n; i++) {
t[c][i] = inf;
if (s[i] == c + 'a') a.push_back(i);
}
if (a.size() == 0) {
for (int i = 1; i <= n; i++) t[c][i] = i;
continue;
}
t[c][1] = 0;
for (int step = 1; step < a.size(); step++) {
for (int i = 0; i < a.size() - step; i++) {
t[c][a[i + step] - a[i] + 1] =
min(a[i + step] - a[i] - step, t[c][a[i + step] - a[i] + 1]);
}
}
for (int i = 1; i <= n; i++) {
t[c][i] = min(t[c][i], t[c][i - 1] + 1);
}
}
}
int dich(char c, int m) {
int l = 1, r = n, mid = (l + r) / 2;
if (t[c - 'a'][r] <= m) return n;
if (t[c - 'a'][l] >= m) return 1;
while (l < r && mid != l) {
if (t[c - 'a'][mid] > m) {
r = mid;
} else {
l = mid;
}
mid = (l + r) / 2;
}
return mid;
}
int main() {
cin >> n >> s >> q;
Calt();
char c;
int m;
for (int i = 0; i < q; i++) {
scanf("%d %c", &m, &c);
printf("%d\n", dich(c, m));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
const long long maxn = (long long)2e3 + 10;
const long long maxm = (long long)20;
const int LOGN = 20;
const long long INF = 1e15 + 10;
const long long MOD = 1e9 + 7;
const double PI = acos(-1.0);
const double EPS = 1e-12;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
string s;
cin >> n >> s;
vector<vector<int> > a(26, vector<int>());
for (int i = 0; i < n; ++i) {
auto c = s[i] - 'a';
a[c].push_back(i);
}
int ncase;
cin >> ncase;
for (int tt = (0); tt < ((ncase)); ++tt) {
int m;
char x;
cin >> m >> x;
x -= 'a';
int ans = min(n, m);
int p = 0;
int q = 0;
int s = 0;
while (q < a[x].size()) {
s += (p != q ? a[x][q] - a[x][q - 1] - 1 : 0);
while (s > m) {
int t = a[x][p + 1] - a[x][p] - 1;
s -= t;
++p;
}
assert(m >= s);
ans = max(ans, min(a[x][q] - a[x][p] + 1 + (m - s), n));
++q;
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, l, p, ans;
string s;
int main() {
cin >> n >> s >> q;
while (q--) {
int a;
char b;
cin >> a >> b;
ans = 0, l = 0, p = 0;
for (int i = 0; i < n; i++) {
if (s[i] != b) l++;
while (l > a) {
if (s[p] != b) l--;
p++;
}
ans = max(ans, i - p + 1);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int str[26][1505];
int ans[26][1505];
int main(int argc, char *argv[]) {
int n;
scanf("%d", &n);
getchar();
char c;
for (int i = 0; i < n; i++) {
c = getchar();
str[c - 'a'][i]++;
}
for (int i = 0; i < 26; i++) {
for (int j = 1; j < n; j++) {
str[i][j] = str[i][j - 1] + str[i][j];
}
}
int total, m;
for (int i = 0; i < 26; i++) {
for (int j = 0; j < n; j++) {
for (int k = j; k < n; k++) {
if (j == 0) {
total = str[i][k];
} else {
total = str[i][k] - str[i][j - 1];
}
m = k - j + 1 - total;
if (ans[i][m] < k - j + 1) {
ans[i][m] = k - j + 1;
}
}
}
}
for (int i = 0; i < 26; i++) {
for (int j = 1; j <= n; j++) {
ans[i][j] = ans[i][j] < ans[i][j - 1] ? ans[i][j - 1] : ans[i][j];
}
}
int q;
scanf("%d", &q);
int num;
while ((q--) > 0) {
scanf("%d %c", &num, &c);
printf("%d\n", ans[c - 'a'][num]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int readInt() {
int n = 0, ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) n = n * 10 + ch - '0', ch = getchar();
return n;
}
inline int readChar() {
int ch = getchar();
while (!isalpha(ch)) ch = getchar();
return ch;
}
const int MAX_N = 1500 + 3;
int n, q;
char str[MAX_N];
int ans[26][MAX_N];
void prepare() {
for (int ch = 'a'; ch <= 'z'; ++ch) {
static pair<int, int> ranges[MAX_N];
int cnt = 0, lst = -1, mx = 0;
for (int i = 0; i <= n; ++i)
if (str[i] != ch) {
if (lst != -1)
ranges[cnt++] = make_pair(lst, i), lst = -1, mx = max(mx, i - lst);
} else {
if (lst == -1) lst = i;
}
if (cnt == 0) {
for (int i = 0; i <= n; ++i) ans[ch - 'a'][i] = i;
continue;
}
ans[ch - 'a'][0] = lst;
for (int m = 1; m <= n; ++m) {
int s = 0, ans = 0;
for (int i = 0, j = 0; i < cnt; ++i) {
while (s > m) {
s -= ranges[j + 1].first - ranges[j].second;
++j;
}
ans = max(ans, ranges[i].second - ranges[j].first + (m - s));
if (i + 1 != cnt) s += ranges[i + 1].first - ranges[i].second;
}
::ans[ch - 'a'][m] = min(n, ans);
}
}
}
int main() {
scanf("%d%s%d", &n, str, &q);
prepare();
for (int i = 0; i < q; ++i) {
int m = readInt(), ch = readChar() - 'a';
printf("%d\n", ans[ch][m]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ii = pair<long long, long long>;
const long long mn = 2e3 + 11, mk = 1e7 + 11, inf = 0x3f3f3f3f3f3f3f3f;
template <typename t>
bool ckmax(t& target, const t& source) {
return target < source ? target = source, 1 : 0;
}
template <typename t>
bool ckmin(t& target, const t& source) {
return target > source ? target = source, 1 : 0;
}
vector<ii> v;
long long dp[mn][26];
long long n;
char a[mn];
int32_t main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n >> a + 1;
for (long long i = 0; i <= n; i++)
for (long long j = 0; j < 26; j++) dp[i][j] = i;
for (long long i = 1; i <= n; i++) {
long long acc = 1;
for (long long j = i + 1; j <= n; j++) {
acc += (a[j] == a[i]);
ckmax(dp[j - i + 1 - acc][a[i] - 'a'], j - i + 1);
}
}
for (long long j = 0; j < 26; j++)
for (long long i = 1; i <= n; i++)
ckmax(dp[i][j], min(n, dp[i - 1][j] + 1));
long long q;
cin >> q;
while (q--) {
long long m;
char c;
cin >> m >> c;
cout << dp[m][c - 'a'] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count() +
reinterpret_cast<unsigned long>(new int) + *(new unsigned long));
void eraseDups(vector<int>& a) { a.erase(unique(a.begin(), a.end()), a.end()); }
int strToInt(string& a) {
stringstream x(a);
int b;
x >> b;
return b;
}
int bitCnt(int a) {
bitset<64> b(a);
return b.count();
}
int bitCnt(string a) {
bitset<64> b(a);
return b.count();
}
vector<int> readVI(int n) {
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
return a;
}
vector<vector<int> > readVVI(int n, int m) {
vector<vector<int> > a(n, vector<int>(m));
for (int i = 0; i < n; i++) a[i] = readVI(m);
return a;
}
vector<long long> readVLL(long long n) {
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
return a;
}
vector<vector<long long> > readVVLL(long long n, long long m) {
vector<vector<long long> > a(n, vector<long long>(m));
for (int i = 0; i < n; i++) a[i] = readVLL(m);
return a;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void print(vector<int>& a) {
for (auto el : a) {
cout << el << ' ';
}
cout << '\n';
}
void print(vector<pair<int, int> >& a) {
for (auto el : a) {
cout << el.first << ',' << el.second << ' ';
}
cout << '\n';
}
void print(vector<int>& a, int n) {
int cnt = 0;
for (auto el : a) {
if (cnt++ == n) break;
cout << el << ' ';
}
cout << '\n';
}
void print(vector<vector<int> >& a) {
for (auto el : a) {
print(el);
}
}
const int MOD = 1e9 + 7;
const int MOD1 = 998244353;
const int INF = 2e9;
const long long INFF = INT64_MAX;
const double EPS = 1e-9;
const double PI = acos(-1.0);
const int moveX[] = {-1, 0, 1, 0};
const int moveY[] = {0, 1, 0, -1};
char c;
string s;
int n, q, k, idx;
vector<int> cnts(30);
vector<vector<pair<int, int> > > pos(30);
void init() {
int st = 0;
s += '.';
for (int i = 1; i <= n; i++) {
if (s[i] != s[st]) {
pos[s[st] - 'a'].push_back({st, i - 1});
st = i;
}
}
for (int i = 0; i < n; i++) {
cnts[s[i] - 'a']++;
}
for (int i = 0; i < 30; i++) {
if (cnts[i] == 0) continue;
}
}
void go() {
cin >> n >> s >> q;
init();
while (q--) {
cin >> k >> c;
idx = c - 'a';
if (cnts[idx] + k >= n) {
cout << n << '\n';
continue;
}
if (cnts[idx] == 0) {
cout << k << '\n';
continue;
}
int st = 0, end = 0, m = pos[idx].size(), change = 0;
while (end + 1 < m &&
change + (pos[idx][end + 1].first - pos[idx][end].second - 1) <= k) {
change += (pos[idx][end + 1].first - pos[idx][end].second - 1);
end++;
}
int curAns = pos[idx][end].second - pos[idx][st].first + 1 + k - change;
while (end + 1 < m) {
change += (pos[idx][end + 1].first - pos[idx][end].second - 1);
end++;
while (change > k) {
change -= (pos[idx][st + 1].first - pos[idx][st].second - 1);
st++;
}
int tmp = pos[idx][end].second - pos[idx][st].first + 1 + k - change;
curAns = max(tmp, curAns);
}
cout << curAns << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1;
while (T--) go();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NUM = 2e5 + 5;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << "\n";
err(++it, args...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int num_tests = 1;
while (num_tests-- > 0) {
int n;
cin >> n;
string s;
cin >> s;
int q;
cin >> q;
int ans[26][1505];
memset(ans, 0, sizeof(ans));
for (long long int i = 0; i < 26; i++) {
char y = i + 'a';
for (long long int j = 0; j < n; j++) {
int cnt = 0;
for (long long int k = j; k < n; k++) {
if (s[k] != y) cnt++;
ans[i][cnt] = max((long long int)ans[i][cnt], k - j + 1);
}
}
for (long long int j = 1; j < 1501; j++)
ans[i][j] = max(ans[i][j - 1], ans[i][j]);
}
while (q--) {
int m;
char x;
cin >> m >> x;
cout << ans[x - 'a'][m] << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1600;
int n, q, dp[30][2][N], ans[30][N];
int s[N];
signed main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
s[i] = c - 'a' + 1;
}
for (int c = 1; c <= 26; c++) {
for (int i = n; i > 0; i--) {
for (int j = 0; j <= n; j++) {
if (j == 0) {
if (c != s[i])
dp[c][i % 2][j] = 0;
else
dp[c][i % 2][j] = dp[c][(i + 1) % 2][j] + 1;
} else
dp[c][i % 2][j] = dp[c][(i + 1) % 2][(s[i] == c ? j : j - 1)] + 1;
ans[c][j] = max(ans[c][j], dp[c][i % 2][j]);
}
}
}
cin >> q;
for (int i = 1; i <= q; i++) {
int x;
char c;
cin >> x >> c;
cout << ans[c - 'a' + 1][x] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char s[1505];
int dp[26][1505];
int main() {
scanf("%d", &n);
scanf("%s", s);
int q;
scanf("%d", &q);
while (q--) {
int m;
char c, tmp[2];
scanf("%d", &m);
scanf("%s", tmp);
c = *tmp;
if (dp[c - 'a'][m])
printf("%d\n", dp[c - 'a'][m]);
else {
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = i; j < n; j++) {
cnt += s[j] != c;
dp[c - 'a'][cnt] = max(dp[c - 'a'][cnt], j - i + 1);
}
}
for (int i = 1; i <= n; i++)
dp[c - 'a'][i] = max(dp[c - 'a'][i], dp[c - 'a'][i - 1]);
printf("%d\n", dp[c - 'a'][m]);
}
}
}
|
#include <bits/stdc++.h>
const int MAXN = 1510;
char s[MAXN];
int n;
char get_next_char() {
char ans = getchar();
while (isspace(ans)) ans = getchar();
return ans;
}
int answer[26][MAXN];
int getans(char target, int m) {
int r = 0, wrong_cnt = 0, ans = 0;
for (int l = 1; l <= n; ++l) {
while (r < n && (s[r + 1] == target || wrong_cnt < m)) {
++r;
if (s[r] != target) ++wrong_cnt;
}
ans = std::max(ans, r - l + 1);
if (s[l] != target) --wrong_cnt;
}
return ans;
}
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 0; i < 26; ++i)
for (int j = 1; j <= n; ++j) answer[i][j] = getans('a' + i, j);
int q;
scanf("%d", &q);
while (q--) {
int m;
scanf("%d", &m);
char target = get_next_char();
printf("%d\n", answer[target - 'a'][m]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q;
string str;
cin >> n >> str >> q;
while (q--) {
int m;
char c;
cin >> m >> c;
int l = 0;
int changed = 0;
int ans = 0;
for (int r = 0; r < n; r++) {
if (str[r] != c) changed++;
while (changed > m) {
if (str[l++] != c) changed--;
}
if (changed <= m) {
ans = max(ans, r - l + 1);
}
}
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e3 + 6;
int n, q, mx[27][N];
char a[N];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int k = 0; k < 26; ++k) {
for (int i = 1; i <= n; ++i) {
int cnt = 0;
for (int j = i; j <= n; ++j) {
if (a[j] - 'a' != k) ++cnt;
mx[k][cnt] = max(mx[k][cnt], j - i + 1);
}
}
}
for (int j = 0; j < 26; ++j)
for (int i = 1; i <= n; ++i) mx[j][i] = max(mx[j][i], mx[j][i - 1]);
cin >> q;
for (int i = 1; i <= q; ++i) {
int x;
char c;
cin >> x >> c;
cout << max(x, mx[c - 'a'][x]) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q, l, r, m, t, answer, d[26][2000];
char str[2000], c;
scanf("%d%s%d", &n, str, &q);
for (int i = 0; i < 26; ++i) {
d[i][0] = (str[0] == i + 'a' ? 1 : 0);
for (int j = 1; j < n; ++j) {
d[i][j] = d[i][j - 1] + (str[j] == i + 'a' ? 1 : 0);
}
}
while (q--) {
scanf("%d %c", &m, &c);
c -= 'a';
l = 0;
r = m - 1;
t = 0;
while (d[c][r] - t) {
r += d[c][r] - t;
t = d[c][r];
}
if (r >= n) {
printf("%d\n", n);
continue;
}
while (r + 1 < n && d[c][r + 1] - d[c][r]) {
r += d[c][r + 1] - d[c][r];
}
if (r >= n) {
printf("%d\n", n);
continue;
}
answer = r - l + 1;
while (r + 1 < n) {
r += 1;
while (r + 1 < n && d[c][r + 1] - d[c][r]) {
r += d[c][r + 1] - d[c][r];
}
if (r >= n) {
r = n - 1;
}
t = d[c][r];
if (l) {
t -= d[c][l - 1];
}
while (r - l + 1 - t > m) {
l += 1;
if (str[l - 1] == c + 'a') {
t -= 1;
}
}
answer = max(answer, r - l + 1);
}
printf("%d\n", answer);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
vector<vector<int>> v(26, vector<int>(n + 1, 0));
for (int i = 0; i < 26; i++) {
for (int y = 0; y < n; y++) {
int j = y, k1 = n;
string s1 = s;
while (j < n) {
if (s1[j] != char(i + 97)) s1[j] = '.';
j++;
}
j = 0;
int cn = 0, k = 0;
while (j < n) {
if (s1[j] == '.')
cn++, k++;
else if (s[j] == char(i + 97))
cn++;
else
cn = 0, k = 0;
v[i][k] = max(v[i][k], cn);
j++;
}
}
for (int y = 1; y <= n; y++) {
v[i][y] = max(v[i][y], v[i][y - 1]);
}
}
int q;
cin >> q;
while (q--) {
int a;
char b;
cin >> a >> b;
cout << v[b - 97][a] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
char c[5];
string s;
int dp[26][1505];
int n, q;
vector<int> ans;
int main() {
cin >> n;
cin >> s;
for (int i = 0; i < 26; i++) {
for (int j = 0; j < n; j++) {
int c = 0;
for (int k = j; k < n; k++) {
if (s[k] != i + 'a') c++;
dp[i][c] = max(dp[i][c], k - j + 1);
}
}
for (int j = 1; j <= n; j++) dp[i][j] = max(dp[i][j - 1], dp[i][j]);
}
cin >> q;
for (int i = 0; i < q; i++) {
int a;
char b;
cin >> a;
cin >> b;
ans.push_back(dp[b - 'a'][a]);
}
for (int i = 0; i < q; i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1505;
char s[N];
int v[26][N];
int main() {
int n;
scanf("%d%s", &n, s);
memset(v, 0x3f, sizeof v);
for (int k = (0), k_end = (26); k < k_end; ++k) {
for (int i = (0), i_end = (n); i < i_end; ++i) {
int cnt = 0;
for (int j = (i), j_end = (n); j < j_end; ++j) {
cnt += s[j] - 'a' == k;
v[k][j - i] = min(v[k][j - i], j - i + 1 - cnt);
}
}
}
int q;
scanf("%d", &q);
while (q--) {
int m;
char t;
scanf("%d %c", &m, &t);
int c = t - 'a';
printf("%ld\n", upper_bound(v[c], v[c] + n, m) - v[c]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[28][1505];
int sm[1505];
int main() {
int n;
fill(sm, sm + 1505, 0);
cin >> n;
string s1;
cin >> s1;
int lw = 0, hi = 0;
int i, j;
for (i = 0; i < 26; i++) {
for (j = 1; j <= n; j++) {
if (s1[j - 1] != (97 + i))
sm[j] = sm[j - 1] + 1;
else
sm[j] = sm[j - 1];
}
for (j = 1; j <= n; j++) {
lw = 1, hi = 1;
int mx = -1;
while (lw <= n) {
if (sm[hi] - sm[lw - 1] <= j && hi <= n) {
if (mx < hi - lw + 1) mx = hi - lw + 1;
hi++;
} else {
lw++;
if (lw == hi) {
hi++;
}
}
}
dp[i][j] = mx;
}
}
int q;
cin >> q;
while (q--) {
int k;
cin >> k;
char c;
cin >> c;
cout << dp[c - 97][k] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char s[1505];
int k;
int main() {
int l, r, num, ans;
scanf("%d", &n);
scanf("%s", s);
scanf("%d", &k);
int m;
char p;
while (k--) {
scanf("%d %c", &m, &p);
l = 0, r = 0, num = m;
ans = 0;
int res = 0;
while (r < n) {
if (s[r] != p) {
num--;
}
r++;
ans++;
while (num < 0) {
if (s[l] != p) num++;
ans--;
l++;
}
res = max(res, ans);
}
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
string s;
cin >> s;
map<char, long long> m;
for (long long i = 0; i < n; i++) m[s[i]]++;
vector<vector<long long>> v(26, vector<long long>(n + 1));
for (long long i = 0; i < n; i++) {
long long t = i + 1;
long long smallans = 0;
for (long long j = 1; j <= n; j++) {
while (t < n && s[t] == s[i]) {
t++;
}
if (t != n) {
t++;
smallans++;
}
while (t < n && s[t] == s[i]) {
t++;
}
if (t >= n) {
v[s[i] - 'a'][j] = max(n - i + j - smallans, v[s[i] - 'a'][j]);
} else {
v[s[i] - 'a'][j] = max(v[s[i] - 'a'][j], t - i);
}
}
}
long long tc;
cin >> tc;
while (tc--) {
long long a;
char c;
cin >> a >> c;
if (v[(long long)c - 'a'][a] == 0) {
cout << a << "\n";
} else if (v[(long long)c - 'a'][a] >= n) {
cout << n << "\n";
} else {
cout << v[(long long)c - 'a'][a] << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[2010];
int dp[2010];
map<char, vector<int> > ans;
bool check(int x, char c, int q) {
for (int i = 0; i < n - x + 1; ++i) {
int l = i;
int r = i + x - 1;
int cnt = (l == 0 ? dp[r] : dp[r] - dp[l - 1]);
if (cnt <= q) return true;
}
return false;
}
int getAns(int x, char c) {
int l = 1, r = n + 1;
memset(dp, 0, sizeof(dp));
dp[0] = (s[0] != c);
for (int i = 1; i < n; ++i) {
dp[i] = dp[i - 1] + (s[i] != c);
}
while (r - l > 1) {
int m = (l + r) / 2;
if (check(m, c, x))
l = m;
else
r = m;
}
return l;
}
int query(int x, int c) { return ans[c][x]; }
void preProcess() {
for (int i = 0; i < 26; ++i) {
char c = 'a' + i;
vector<int> mp;
for (int j = 0; j <= n; ++j) {
int maxLen = getAns(j, c);
mp.push_back(maxLen);
}
ans[c] = mp;
}
}
int main() {
ios::sync_with_stdio(false);
while (cin >> n) {
for (int i = 0; i < n; ++i) cin >> s[i];
cin >> m;
ans.clear();
preProcess();
for (int i = 0; i < m; ++i) {
int x;
char c;
cin >> x >> c;
cout << query(x, c) << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long bigmod(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
inline void sc(int &n) {
n = 0;
int c = getchar();
int f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
n = (n << 3) + (n << 1) + c - '0', c = getchar();
}
n = n * f;
}
string s;
int n;
void calc(int x, int c) {
int l = 1, co = 0, res = 0;
for (int i = 1; i <= n; i++) {
if (s[i] != c) co++;
while (co > x) {
if (s[l] != c) co--;
l++;
}
res = max(res, i - l + 1);
}
cout << res << endl;
}
using namespace std;
int main() {
cin >> n >> s;
s.insert(0, "#");
int q;
cin >> q;
while (q--) {
char c;
int x;
cin >> x >> c;
calc(x, c);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const int N = 1510;
int DP[27][N][N];
int ans[27][N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
memset(DP, 0, sizeof(DP));
memset(ans, 0, sizeof(ans));
DP[s[0] - 'a'][0][0] = 1;
for (int i = (int)1; i < (int)N; i++) DP[s[0] - 'a'][0][i] = 1;
for (char ch = 'a'; ch <= 'z'; ch++) {
if (s[0] == ch) continue;
for (int i = (int)1; i < (int)N; i++) DP[ch - 'a'][0][i] = 1;
}
for (int i = (int)1; i < (int)(int)(s.size()); i++) {
for (char ch = 'a'; ch <= 'z'; ch++) {
if (s[i] == ch) {
int len = 0;
for (int k = i; k >= 0; k--) {
if (s[k] != ch) break;
len++;
}
DP[ch - 'a'][i][0] = len;
}
for (int j = (int)1; j < (int)N; j++) {
if (ch == s[i])
DP[ch - 'a'][i][j] = 1 + DP[ch - 'a'][i - 1][j];
else
DP[ch - 'a'][i][j] = 1 + DP[ch - 'a'][i - 1][j - 1];
}
}
}
for (char ch = 'a'; ch <= 'z'; ch++) {
for (int j = 0; j < N; j++) {
for (int i = (int)0; i < (int)(int)(s.size()); i++)
ans[ch - 'a'][j] = max(ans[ch - 'a'][j], DP[ch - 'a'][i][j]);
}
}
int q;
cin >> q;
for (int i = (int)0; i < (int)q; i++) {
int m;
char ch;
cin >> m >> ch;
cout << ans[ch - 'a'][m] << endl;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.