text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const long long LLINF = LLONG_MAX;
const int INF = INT_MAX;
const int MAXN = 1510;
int n, q;
string s;
int dp[26][MAXN];
int main() {
scanf("%d", &n);
cin >> s;
for (char c = 0; c < 26; c++) {
for (int i = 0; i < n; i++) {
int r = 0;
for (int j = i; j < n; j++) {
if (s[j] - 'a' != c) r++;
dp[c][r] = max(dp[c][r], j - i + 1);
}
}
for (int i = 1; i < MAXN; i++) dp[c][i] = max(dp[c][i], dp[c][i - 1]);
}
scanf("%d", &q);
while (q--) {
int a;
char b;
scanf("%d %c", &a, &b);
printf("%d\n", dp[b - 'a'][a]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMax = 1502;
const int sigma = 27;
struct statuss {
int first, last;
};
int n, m, a;
char c;
char x[NMax];
int add[sigma][NMax];
int ans[sigma][NMax];
int main() {
cin >> n;
cin.get();
cin.getline(x, NMax);
cin >> m;
for (int i = 'a' - 'a'; i <= 'z' - 'a'; ++i) {
for (int j = 0; j < n; ++j) {
if (x[j] == i + 'a') {
add[i][j] = add[i][j - 1];
} else
add[i][j] = add[i][j - 1] + 1;
}
}
for (int i = 'a' - 'a'; i <= 'z' - 'a'; ++i) {
for (int j = 0; j < n; ++j) {
for (int k = j; k < n; ++k) {
int e = add[i][k] - add[i][j - 1];
ans[i][e] = max(ans[i][e], k - j + 1);
}
}
}
for (int i = 'a' - 'a'; i <= 'z' - 'a'; ++i) {
for (int j = 0; j < n; ++j) {
ans[i][n] = n;
ans[i][j] = max(ans[i][j], ans[i][j - 1]);
}
}
for (int i = 1; i <= m; ++i) {
cin >> a >> c;
cout << ans[c - 'a'][a] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void pi(int x) {
if (x == 0) {
putchar('0');
return;
}
char c[10];
int k = 0;
if (x < 0) {
putchar('-');
x = -x;
}
while (x) {
int nx = x / 10;
c[k++] = x - nx * 10;
x = nx;
}
while (k--) {
putchar(c[k] + '0');
}
}
inline void pin(const int& x) {
pi(x);
putchar('\n');
};
inline void pl(long long x) {
if (x == 0) {
putchar('0');
return;
}
char c[19];
int k = 0;
if (x < 0) {
putchar('-');
x = -x;
}
while (x) {
long long nx = x / 10;
c[k++] = x - nx * 10;
x = nx;
}
while (k--) {
putchar(c[k] + '0');
}
}
inline void pln(const long long& x) {
pl(x);
putchar('\n');
};
inline void gi(int& val) {
val = 1;
char c;
do {
c = getchar();
} while (c != '-' && (c < '0' || c > '9'));
int zn = 1;
if (c == '-') {
zn = -1;
c = getchar();
}
val = c - '0';
c = getchar();
while (c >= '0' && c <= '9') {
val *= 10;
val += c - '0';
c = getchar();
}
val *= zn;
}
inline void gl(long long& val) {
val = 1;
char c;
do {
c = getchar();
} while (c != '-' && (c < '0' || c > '9'));
int zn = 1;
if (c == '-') {
zn = -1;
c = getchar();
}
val = c - '0';
c = getchar();
while (c >= '0' && c <= '9') {
val *= 10;
val += c - '0';
c = getchar();
}
val *= zn;
}
inline void gl(long long& val1, long long& val2) {
gl(val1);
gl(val2);
}
inline void gi(int& val1, int& val2) {
gi(val1);
gi(val2);
}
inline void gl(long long& val1, long long& val2, long long& val3) {
gl(val1);
gl(val2);
gl(val3);
}
inline void gi(int& val1, int& val2, int& val3) {
gi(val1);
gi(val2);
gi(val3);
}
inline void gai(int* a, int n) {
for (int i = 0; i < n; i++) {
gi(a[i]);
}
}
inline void gal(long long* a, int n) {
for (int i = 0; i < n; i++) {
gl(a[i]);
}
}
inline void pai(int* a, int n) {
for (int i = 0; i < n; i++) {
if (i) {
putchar(' ');
}
pi(a[i]);
}
}
inline void pain(int* a, int n) {
for (int i = 0; i < n; i++) {
if (i) {
putchar(' ');
}
pi(a[i]);
}
putchar('\n');
}
inline void mygets(char* b, const bool flag = false) {
int n = 0;
char c;
do {
c = getchar();
} while ((!flag && c == ' ') || c == '\n' || c == '\t');
if (c == EOF) {
b[n] = '\0';
return;
}
do {
b[n++] = c;
c = getchar();
} while (c != '\n' && (flag || c != ' ') && c != EOF && c != '\t');
}
inline void mygets(string& b, const bool flag = false) {
b.clear();
char c;
do {
c = getchar();
} while ((!flag && c == ' ') || c == '\n' || c == '\t');
if (c == EOF) {
return;
}
do {
b.push_back(c);
c = getchar();
} while (c != '\n' && (flag || c != ' ') && c != EOF && c != '\t');
}
inline void getc(char& b) {
b = getchar();
while (b == ' ' || b == '\n') {
b = getchar();
}
}
inline void myputs(const string b) {
for (int i = 0; i < b.size(); ++i) {
putchar(b[i]);
}
}
inline void putsn(const string b) {
myputs(b);
putchar('\n');
}
inline void putc(const char b) { putchar(b); }
inline void putcn(const char b) {
putchar(b);
putchar('\n');
}
int magical(const string s) {
int p = 1;
const int base = 777;
int _hash = 0;
for (int i = 0; i < s.size(); i++) {
_hash += s[i] * p;
p *= base;
}
return _hash;
}
const int N = 1e6 + 7, M = 150000, mod = 1000000007, inf = 1000000007;
const long long lmod = 1000000007, linf = 1e18 + 77;
const long double eps = 1e-9;
vector<int> sum;
int getsum(int l, int r) {
if (l == 0) {
return sum[r];
} else {
return sum[r] - sum[l - 1];
}
}
int res[1533][1533];
int main() {
srand(magical("magic <3"));
ios_base::sync_with_stdio(false);
int n;
gi(n);
string s;
mygets(s);
for (char col = 'a'; col <= 'z'; col++) {
for (int m = 1; m <= n; m++) {
sum = vector<int>(n, 0);
for (int i = 0; i < n; i++) {
if (s[i] == col) {
sum[i]++;
}
if (i != 0) {
sum[i] += sum[i - 1];
}
}
int l = 0;
int r = 0;
int ans = 0;
while (r < n) {
if (r - l + 1 - getsum(l, r) <= m) {
ans = max(ans, (r - l + 1));
r++;
} else {
l++;
}
}
res[col][m] = ans;
}
}
int q;
gi(q);
for (int i = 0; i < q; i++) {
int m;
gi(m);
char c;
getc(c);
pin(res[c][m]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N, Q;
char st[2000];
int s[2000];
int f[28][1505];
int main() {
scanf("%d", &N);
scanf("%s", st + 1);
for (int ch = 'a'; ch <= 'z'; ch++) {
memset(s, 0, sizeof s);
for (int i = 1; i <= N; i++) {
if (st[i] == ch)
s[i] = 1;
else
s[i] = 0;
}
int left;
f[ch - 'a'][0] = 0;
for (int i = 1; i <= N; i++) {
if (s[i] && !s[i - 1]) left = i;
if (s[i]) f[ch - 'a'][0] = max(f[ch - 'a'][0], i - left + 1);
}
for (int maxlen = 1; maxlen <= N; maxlen++) {
int head = 1, tail = 1;
for (int has = 0; tail <= N; tail++) {
if (!s[tail]) has++;
if (has == maxlen) break;
}
tail = min(tail, N);
int cntans = tail - head + 1;
for (; tail < N;) {
tail++;
if (!s[tail]) {
while (s[head]) head++;
head++;
}
cntans = max(cntans, tail - head + 1);
}
f[ch - 'a'][maxlen] = cntans;
}
}
scanf("%d", &Q);
while (Q--) {
int m;
char ch;
scanf("%d %c", &m, &ch);
m = min(m, N);
printf("%d\n", f[ch - 'a'][m]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q;
char str[1505];
scanf("%d%s%d", &n, str, &q);
while (q--) {
int m;
char op[10];
scanf("%d%s", &m, op);
char c = op[0];
int l = 0, r = 0, k = 0;
int ans = 0;
while (r < n) {
if (str[r] == c)
r++;
else
r++, k++;
if (k > m) {
while (str[l++] == c) {
}
k--;
ans = max(r - l, ans);
} else
ans = max(r - l, ans);
}
printf("%d\n", max(ans, r - l));
}
}
|
#include <bits/stdc++.h>
using namespace std;
int cond = 0, multi = 0, gcj = 0;
string A;
int Q;
int res[256][1600];
struct solver {
void solve() {
int N;
cin >> N;
cin >> A;
cin >> Q;
{
if (cond > 0) {
cerr << 40 << " "
<< "N"
<< " " << N << endl;
cerr.flush();
}
};
{
if (cond > 0) {
cerr << 41 << " "
<< "A"
<< " " << A << endl;
cerr.flush();
}
};
for (auto ch = ('a'); ch <= ('z'); ++ch) {
for (auto i = (0); i < (N); ++i) {
int sofar = 0;
int repaint = 0;
for (int j = i; j < N; j++) {
if (A[j] != ch) {
repaint++;
}
sofar++;
{
if (cond > 0) {
cerr << 51 << " "
<< "i << \" \" << j << \" \" << ch << \" \" << repaint << "
"\" \" << sofar"
<< " " << i << " " << j << " " << ch << " " << repaint << " "
<< sofar << endl;
cerr.flush();
}
};
{ res[(int)ch][repaint] = max(res[(int)ch][repaint], sofar); };
}
}
for (auto i = (0); i <= (N - 1); ++i) {
res[(int)ch][i + 1] = max(res[(int)ch][i + 1], res[(int)ch][i]);
};
}
for (auto i = (0); i < (Q); ++i) {
int M;
char C;
cin >> M >> C;
{
if (cond > 0) {
cerr << 61 << " "
<< "M << \" \" << C"
<< " " << M << " " << C << endl;
cerr.flush();
}
};
cout << res[(int)C][M] << endl;
}
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cond = argc >= 2 && argv[1][0] == 'q' ? 1 << 30 : 0;
cout.setf(ios::fixed);
cout.precision(10);
int t;
if (multi || gcj)
cin >> t;
else
t = 1;
for (auto i = (1); i <= (t); ++i) {
if (cond) cerr << 77 << " " << i << endl;
if (gcj) cout << "Case #" << i << ": ";
solver s;
s.solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:667177216")
using namespace std;
const long long MOD = 1000000000 + 7;
int main() {
int n;
scanf("%d\n", &n);
string s;
getline(cin, s);
int q;
scanf("%d\n", &q);
for (int(i) = 0; (i) < q; (i)++) {
int ans = 0;
int m;
char c;
scanf("%d %c\n", &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++;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
scanf("%i", &n);
char s[n + 2];
scanf("%s", s + 1);
vector<int> answers[26];
for (int j = 0; j < 26; j++) {
char ch = j + 'a';
vector<int> p(n + 1);
for (int i = 1; i <= n; i++) {
p[i] = p[i - 1];
if (s[i] == ch) p[i]++;
}
vector<int> ans(n + 1);
for (int m = 1; m <= n; m++) {
int r = 1;
for (int i = 1; i <= n; i++) {
while (i - r + 1 - (p[i] - p[r - 1]) > m) {
r++;
}
ans[m] = max(ans[m], i - r + 1);
}
}
answers[j] = ans;
}
int q;
scanf("%i", &q);
while (q--) {
int m;
char ch;
scanf("%i %c", &m, &ch);
printf("%i\n", answers[ch - 'a'][m]);
}
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];
int ans[30][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]++;
}
}
}
void solve() {
memset((ans), (0), sizeof(ans));
for (int i = 0; i < 26; i++)
for (int k = 1; k <= n; k++) {
int *tmp = num[i];
int end = 1;
int tot = 0;
for (int j = 1; j <= n; j++) {
while (end + 1 <= n && tmp[end + 1] - tmp[j - 1] <= k) end++;
int len = end - j + 1;
tot = max(tot, len);
}
ans[i][k] = tot;
}
}
int main() {
char c[5];
int k;
while (~scanf("%d", &n)) {
scanf("%s", str + 1);
Get_Count();
solve();
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d%s", &k, c);
int id = c[0] - 'a';
printf("%d\n", ans[id][k]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int MX = 1507;
int main() {
int n, Q, m;
cin >> n;
string s;
cin >> s >> Q;
vector<vector<int> > alph(26);
for (int i = 0; i < s.size(); i++) alph[s[i] - 'a'].push_back(i);
vector<vector<int> > r(26, vector<int>(MX, 0)), v(26, vector<int>(MX, 0));
for (int i = 0; i < 26; i++) {
for (int j = 0; j < alph[i].size(); j++) {
v[i][0] = max(v[i][0], 1);
for (int k = j + 1; k < alph[i].size(); k++) {
int l = alph[i][k] - alph[i][j] + 1;
v[i][l - (k - j + 1)] = max(v[i][l - (k - j + 1)], l);
}
}
int curr = 0;
for (int j = 0; j < MX; j++) {
if (v[i][j] == 0)
r[i][j] = curr;
else {
if (v[i][j] < v[i][curr] + j - curr) {
r[i][j] = curr;
} else {
curr = j;
r[i][j] = j;
}
}
}
}
for (int q = 0; q < Q; q++) {
char c;
cin >> m >> c;
int x = c - 'a';
cout << min(n, v[x][r[x][m]] + (m - r[x][m])) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, ans, m, b, e, cnt;
string s;
char letter;
int main() {
cin >> n >> s >> q;
for (int i = 0; i < q; i++) {
scanf("%i %c", &m, &letter);
b = e = cnt = ans = 0;
for (int j = 0; j < s.size(); j++) {
e = j;
if (s[j] != letter) cnt++;
while (cnt > m) {
if (s[b] != letter) cnt--;
b++;
}
ans = max(ans, e - b + 1);
}
printf("%i\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char garland[1500];
int n, q;
int sum[1600][30];
int DP[1600][30];
int _max(int a, int b) { return a > b ? a : b; }
int _min(int a, int b) { return a > b ? b : a; }
int main() {
cin >> n;
memset(sum, 0, sizeof(sum));
memset(DP, 0, sizeof(DP));
for (int i = 1; i <= n; i++) {
cin >> garland[i];
for (int j = 0; j < 26; j++) sum[i][j] = sum[i - 1][j];
sum[i][garland[i] - 'a']++;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
for (int k = 0; k < 26; k++) {
int num = sum[j][k] - sum[i - 1][k];
DP[j - i + 1 - num][k] = _max(DP[j - i + 1 - num][k], j - i + 1);
}
}
}
for (int i = 1; i <= n; i++) {
for (int k = 0; k < 26; k++) {
DP[i][k] = _min(n, _max(DP[i][k], DP[i - 1][k] + 1));
}
}
cin >> q;
int num1;
char ch;
for (int i = 0; i < q; i++) {
cin >> num1 >> ch;
cout << DP[num1][ch - 'a'] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
string s;
int a[2000];
int dp[30][2000];
int cnt[30];
char c;
void init(int x, int y) {
memset(cnt, 0, sizeof cnt);
for (int i = (x), _i = (y + 1); i < _i; ++i) {
cnt[a[i]]++;
}
int sz = y - x + 1;
for (int i = 0, _i = (26); i < _i; ++i) {
int need = sz - cnt[i];
dp[i][need] = max(dp[i][need], sz);
}
}
int main() {
scanf("%d\n", &n);
getline(cin, s);
for (int i = 0, _i = (n); i < _i; ++i) a[i] = s[i] - 'a';
for (int i = 0, _i = (n); i < _i; ++i) {
for (int j = (i), _j = (n); j < _j; ++j) {
init(i, j);
}
}
for (int i = 0, _i = (26); i < _i; ++i) {
for (int j = (1), _j = (n + 1); j < _j; ++j) {
dp[i][j] = max(dp[i][j], dp[i][j - 1]);
}
}
scanf("%d", &q);
for (int i = 0, _i = (q); i < _i; ++i) {
scanf("%d %c", &m, &c);
int cc = c - 'a';
cout << dp[cc][m] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
long long N;
cin >> N;
vector<char> color(N);
string s;
cin >> s;
for (long long i = 0; i < N; i++) {
color[i] = s[i];
}
color.push_back('\t');
long long Q;
cin >> Q;
map<pair<long long, char>, long long> sol;
for (long long plan = 0; plan < Q; plan++) {
long long m;
char like;
cin >> m >> like;
if (sol.find({m, like}) == sol.end()) {
long long koyomiti = 0;
long long j = 0;
long long countLike = 0;
for (long long i = 0; i < N && j < N; i++) {
while (j < N && (j - i - countLike + 1 <= m || color[j] == like)) {
if (color[j] == like) {
countLike++;
}
j++;
}
koyomiti = max(koyomiti, j - i);
if (color[i] == like) {
countLike--;
}
}
sol[{m, like}] = koyomiti;
}
cout << sol[{m, like}] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, o, i, mx, dl, kol, q;
string s;
char c;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
cin >> s;
cin >> q;
for (o = 0; o < q; o++) {
cin >> kol >> c;
mx = 0;
dl = 0;
for (i = 0; i < n; i++) {
if (s[i] == c)
dl++;
else {
if (kol == 0) {
if (s[i - dl] != c) kol++;
dl--;
i--;
} else {
dl++;
kol--;
}
}
if (dl > mx) mx = dl;
}
cout << mx << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int main() {
int n, a, q, ss[28][1505];
char str[1505], b;
while (~scanf("%d", &n)) {
scanf("%s", str);
scanf("%d", &q);
for (int i = 0; i <= 25; i++) {
char cc = i + 'a';
ss[i][0] = 0;
for (int j = 0; j < n; j++) {
if (str[j] == cc)
ss[i][j + 1] = ss[i][j];
else
ss[i][j + 1] = ss[i][j] + 1;
}
}
while (q--) {
scanf("%d %c", &a, &b);
int maxx = a;
for (int i = 1; i <= n - maxx; i++) {
for (int j = i + maxx; j <= n; j++) {
int sum = ss[b - 'a'][j] - ss[b - 'a'][i - 1];
if (sum > a)
break;
else
maxx = max(maxx, j - i + 1);
}
}
printf("%d\n", maxx);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int64_t n;
int64_t two_pointer(int64_t c, int64_t nbChanges) {
char character = char('a' + c);
int64_t ans = 0, crtChanges = 0, beg = 0, end = 0;
while (end < n) {
if (crtChanges >= nbChanges) {
if (s[beg] != character) crtChanges--;
beg++;
} else {
if (s[end] != character) crtChanges++;
end++;
while (end < n and s[end] == character) {
end++;
}
}
ans = max(ans, end - beg);
}
return ans;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> s;
vector<vector<int64_t>> v(26, vector<int64_t>(n + 1));
for (int64_t i = 0; i < 26; ++i) {
for (int64_t j = 1; j <= n; ++j) {
v[i][j] = two_pointer(i, j);
}
}
int64_t q;
cin >> q;
while (q--) {
int64_t a;
char c;
cin >> a >> c;
cout << v[c - 'a'][a] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int mod = 1e7 + 9;
int i, j, n, m, k, mx, x, y, l, r, b;
char c, s[2000];
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%d %c", &b, &c);
mx = 0;
l = 1;
k = 0;
for (r = 1; r <= n; r++) {
if (s[r] != c) k++;
while (k > b) {
if (s[l] != c) k--;
l++;
}
mx = max(mx, r - l + 1);
}
cout << mx << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
char s[1505];
int f[1505][26];
signed main() {
ios::sync_with_stdio(false);
int n;
cin >> n >> (s + 1);
for (int j = 0; j < 26; ++j) {
char ch = j + 'a';
int lst = 0;
vector<pair<int, int>> vec;
for (int i = 1; i <= n; ++i)
if (s[i] == ch) {
int pos = i;
if (lst == 0) lst = i - 1;
while (pos + 1 <= n && s[pos + 1] == s[pos]) ++pos;
vec.push_back({pos - i + 1, i - lst - 1});
lst = i = pos;
}
for (int k = 1; k <= n; ++k) {
f[k][j] = k;
for (int i = 0; i < vec.size(); ++i) {
int pos = i, x = k, sum = vec[i].first;
while (pos + 1 < vec.size() && x - vec[pos + 1].second >= 0)
x -= vec[pos + 1].second, sum += vec[pos + 1].first, ++pos;
f[k][j] = max(f[k][j], sum + k);
}
f[k][j] = min(f[k][j], n);
}
}
int q;
cin >> q;
while (q--) {
int x;
char y;
cin >> x >> y;
cout << f[x][y - 'a'] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
for (int i(0); i < N; i++) scanf("%d", A + i);
}
char s[(1505)], c;
int N, D[26][(1505)], I;
int main(void) {
scanf("%d", &N), scanf("%s", s);
for (int i(0); i < 26; i++)
for (int k(0); k < N; k++) {
I = k;
for (int j(0); j < N + 1; j++) {
while (I < N && s[I] == i + 97) ++I;
D[i][j] = max(D[i][j], I - k), I += I < N;
}
}
int _;
scanf("%d", &_);
for (int i(0); i < _; i++)
scanf("%d %c", &I, &c), printf("%d\n", D[c - 97][I]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const long long mod = 1e9 + 7;
const int alphabet = 26;
const int inf = INT_MAX;
long long dp[30][maxn];
string s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i, j, k, m, n;
cin >> s >> s;
n = s.length();
for (i = 0; i < n; i++) s[i] = s[i] - 'a';
for (char c = 0; c < alphabet; c++) {
for (i = 0; i < n; i++) {
long long cnt = 0;
for (j = i; j < n; j++) {
if (s[j] != c) cnt++;
dp[c][cnt] = max(dp[c][cnt], j - i + 1);
}
}
for (i = 1; i < maxn; i++) dp[c][i] = max(dp[c][i], dp[c][i - 1]);
}
cin >> k;
while (k--) {
int mi;
char ci;
cin >> mi >> ci;
cout << dp[ci - 'a'][mi] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
long long MOD = 1000000007;
double eps = 1e-12;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, q;
cin >> n;
string str;
cin >> str;
cin >> q;
vector<vector<int>> dp(n + 1, vector<int>(26, 0));
for (int k = 0; k < 26; k++) {
for (int i = 0; i < n; i++) {
int x = 0;
for (int j = i; j < n; j++) {
if ((str[j] - 'a') != k) x++;
dp[x][k] = max(dp[x][k], j - i + 1);
}
}
for (int i = 1; i <= n; i++) dp[i][k] = max(dp[i - 1][k], dp[i][k]);
}
for (int i = 0; i < q; i++) {
int x;
char ch;
cin >> x;
cin >> ch;
cout << dp[x][ch - 'a'] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[12345];
int dp[2345][2345];
int d[2345][2345];
int s[2345][2345];
int main() {
int n;
scanf("%d", &n);
scanf("%s", str);
dp[0][str[0]] = 1;
for (int i = 1; i < n; i++) {
for (char ch = 'a'; ch <= 'z'; ch++) {
if (str[i] == ch) {
dp[i][ch] = dp[i - 1][ch] + 1;
} else {
dp[i][ch] = dp[i - 1][ch];
}
}
}
for (char ch = 'a'; ch <= 'z'; ch++) {
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
int cnt = dp[j][ch] - (i == 0 ? 0 : dp[i - 1][ch]);
d[ch][j - i + 1] = max(d[ch][j - i + 1], cnt);
}
}
}
for (int ch = 'a'; ch <= 'z'; ch++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (d[ch][j] + i >= j) {
s[ch][i] = max(s[ch][i], j);
}
}
}
}
int m;
scanf("%d", &m);
while (m--) {
int t;
char ch[123];
scanf("%d %s", &t, ch);
printf("%d\n", s[ch[0]][t]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[1504], ch;
int N, T, num, ans[30][1504], pre[1504];
int slove(int n, int m) {
if (ans[m][0]++) return ans[m][n];
memset(pre, 0, sizeof(pre));
for (int i = 0; i < N; i++) {
pre[i + 1] = pre[i] + (str[i] - m == 'a');
}
for (int len = 1, j = 1; len <= N; len++) {
int a = 100000;
for (int st = 1; st + len - 1 <= N; st++) {
a = min(a, len - pre[st + len - 1] + pre[st - 1]);
}
ans[m][a] = max(ans[m][a], len);
}
for (int i = 1; i <= N; i++) ans[m][i] = max(ans[m][i], ans[m][i - 1]);
return ans[m][n];
}
int main() {
scanf("%d%s%d", &N, str, &T);
for (int i = 1; i <= T; i++) {
char ch;
scanf("%d %c", &num, &ch);
printf("%d\n", slove(num, ch - 'a'));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
istream& in = cin;
int n, m;
string s;
int h[1510][30];
void input() { in >> n >> s; }
int cale(int num, char c) {
int& ref = h[num][c - 'a'];
if (ref != 0) return ref;
int now = 0;
int rest = num;
int L = -1;
for (int i = 0; i < n; ++i) {
if (s[i] == c) {
now++;
} else {
while (rest == 0) {
if (s[L + 1] != c) rest++;
L++;
}
rest--;
}
ref = max(ref, i - L);
}
return ref;
}
int main() {
input();
in >> m;
while (m-- > 0) {
int num;
char c;
in >> num >> c;
printf("%d\n", cale(num, c));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, dp[26][1501];
string s;
int main() {
cin >> n >> s >> q;
for (int c = 0; c < 26; ++c) {
for (int i = 0; i < n; ++i) {
int rep = 0;
for (int j = i; j < n; ++j) {
if (s[j] != c + 'a') ++rep;
dp[c][rep] = max(dp[c][rep], j - i + 1);
}
}
for (int i = 1; i <= n; ++i) dp[c][i] = max(dp[c][i], dp[c][i - 1]);
}
int mi;
char ci;
while (q--) {
cin >> mi >> ci;
cout << dp[ci - 'a'][mi] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
int n, m;
int arr[1505];
int solve() {
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;
}
}
int i;
for (i = 0; i < bestWindow; i++) {
if (arr[bestL + i] == 0) arr[bestL + i] = 1;
}
int ans = 0, z;
if (arr[0] == 1)
z = 1;
else
z = 0;
for (i = (1); i < (n); ++i) {
if (arr[i] == 0) {
ans = max(ans, z);
z = 0;
continue;
}
z++;
}
ans = max(ans, z);
return ans;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int i, j, k, x, y, z;
cin >> n;
int q;
string s;
cin >> s;
cin >> q;
while (q--) {
char c;
cin >> m >> c;
for (i = (0); i < (n); ++i) {
if (s[i] == c)
arr[i] = 1;
else
arr[i] = 0;
}
cout << solve();
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q, m, t;
cin >> n;
string s;
cin >> s;
vector<vector<int> > ps(26, vector<int>(n + 1, 0)),
ans(26, vector<int>(n + 1, 0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < 26; j++) {
ps[j][i + 1] = ps[j][i];
}
ps[s[i] - 'a'][i + 1]++;
}
for (int i = 0; i < 26; i++) {
for (int j = 0; j < n; j++) {
for (int k = j + 1; k <= n; k++) {
t = k - j - (ps[i][k] - ps[i][j]);
ans[i][t] = max(ans[i][t], k - j);
}
}
for (int j = 0; j < n; j++) {
ans[i][j + 1] = max(ans[i][j + 1], ans[i][j]);
}
}
cin >> q;
char c;
for (int i = 0; i < q; i++) {
cin >> m >> c;
cout << ans[c - 'a'][m] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e4 + 7, oo = 1e9 + 7, OO = 1e18 + 7;
int n, q, dp[26][N], ps[26][N];
string s;
char c;
int main() {
cin >> n >> s >> q;
s = '!' + s;
for (int k = 0; k < 26; k++) {
for (int i = 1; i <= n; i++) {
ps[k][i] = ps[k][i - 1] + !(s[i] - 'a' - k);
}
}
for (int k = 0; k < 26; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int tmp = j - i + 1 - (ps[k][j] - ps[k][i - 1]);
dp[k][tmp] = max(dp[k][tmp], j - i + 1);
}
}
}
for (int k = 0; k < 26; k++) {
for (int i = 1; i <= n; i++) {
dp[k][i] = max(dp[k][i], dp[k][i - 1]);
}
}
for (int i = 0, x; i < q; i++) {
cin >> x >> c;
cout << dp[c - 'a'][x] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long MAXN = 1501, MOD = 1000000007;
long long ans[MAXN][26];
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
long long n, q;
string s;
cin >> n >> s >> q;
for (long long i = 0; i < 26; i++) {
vector<long long> c(n);
c[0] = 0;
if (s[0] - 'a' != i) {
c[0]++;
}
for (long long j = 1; j < n; j++) {
c[j] = c[j - 1];
if (s[j] - 'a' != i) {
c[j]++;
}
}
for (long long j = 1; j <= n; j++) {
long long r = 0;
while (r < n - 1) {
if (c[r + 1] <= j) {
r++;
} else {
break;
}
}
long long kek = r + 1;
for (long long k = 1; k < n; k++) {
while (r < n - 1) {
if (c[r + 1] - c[k - 1] <= j) {
r++;
} else {
break;
}
}
kek = max(kek, r - k + 1);
}
ans[j][i] = kek;
}
}
while (q--) {
long long m;
char c;
cin >> m >> c;
cout << ans[m][c - 'a'] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1501;
using namespace std;
int n, lim, x, q, sum[N][26];
char opt, S[N];
int read() {
int k = 0, f = 0;
char c = getchar();
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = 1;
for (; c <= '9' && c >= '0'; c = getchar()) k = (k << 3) + (k << 1) + c - '0';
return f ? -k : k;
}
int work() {
int maxn = 0, l = 1, r = 1;
while (l <= n) {
while (r <= n && sum[r][x] - sum[l - 1][x] + lim >= r - l + 1)
maxn = max(maxn, r - l + 1), r++;
l++;
}
return maxn;
}
int main() {
n = read();
scanf("%s", S + 1);
for (int i = 1; i <= n; i++)
for (int j = 0; j < 26; j++) sum[i][j] = sum[i - 1][j] + (S[i] - 'a' == j);
q = read();
while (q--) {
lim = read();
cin >> opt;
x = opt - 'a';
printf("%d\n", work());
}
return 0;
}
|
#include <bits/stdc++.h>
int n, q, ans[26][1505];
char s[1505], c[5];
void cal(char c, int m) {
int f = 0;
for (int i = 0, j = -1, l = 0; i < n; f = std::max(f, i - j), ++i) {
if (c == s[i]) continue;
++l;
if (l > m) {
do {
++j;
} while (s[j] == c);
--l;
}
}
ans[c - 'a'][m] = f;
}
int main() {
scanf("%d%s%d", &n, s, &q);
for (int m; q--;) {
scanf("%d%s", &m, c);
if (!ans[c[0] - 'a'][m]) cal(c[0], m);
printf("%d\n", ans[c[0] - 'a'][m]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[1600];
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x;
char y;
scanf("%d %c", &x, &y);
int ans = 1, tail = 1, last = x;
if (s[1] != y) last--;
for (int j = 1; j < n; j++) {
while ((last || s[tail + 1] == y) && tail < n) {
tail++;
if (s[tail] == y) continue;
last--;
}
ans = max(ans, tail - j + 1);
if (s[j] != y) last++;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1600];
int d[30][1600];
int t[10000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
for (char c = 'a'; c <= 'z'; ++c) {
for (int i = 0; i < n; ++i) {
a[i] = a[i - 1] + (s[i] == c);
}
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
int cnt = a[j] - a[i - 1];
int len = j - i + 1;
d[c - 'a'][len - cnt] = max(d[c - 'a'][len - cnt], len);
}
}
int mx = d[c - 'a'][0];
for (int i = 1; i <= n; ++i) {
d[c - 'a'][i] = max(d[c - 'a'][i], mx);
mx = max(d[c - 'a'][i], mx);
}
}
int q;
cin >> q;
while (q--) {
int m;
char c;
cin >> m >> c;
cout << d[c - 'a'][m] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
void io() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(15);
}
const int MAXN = 1502;
int dp[MAXN][MAXN][28];
string s;
int ans[MAXN][26];
int main(int argc, char* argv[]) {
io();
int n, q;
cin >> n;
cin >> s;
s = " " + s;
for (int col = 0; col < 26; col++) {
for (int i = 1; i <= n; i++) {
if (col == (s[i] - 'a')) {
if (i == 1) {
dp[i][0][col] = 1;
} else {
dp[i][0][col] = 1 + dp[i - 1][0][col];
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j][col] = 1 + dp[i - 1][j - (col != (s[i] - 'a'))][col];
}
}
}
for (int col = 0; col < 26; col++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
ans[i][col] = max(ans[i][col], dp[j][i][col]);
}
}
}
cin >> q;
while (q--) {
int m;
char ch;
cin >> m >> ch;
cout << ans[m][ch - 'a'] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, ans, m, b, e, cnt;
string s;
char letter;
int main() {
cin >> n >> s >> q;
for (int i = 0; i < q; i++) {
cin >> m >> letter;
b = e = cnt = ans = 0;
for (int j = 0; j < s.size(); j++) {
e = j;
if (s[j] != letter) cnt++;
while (cnt > m) {
if (s[b] != letter) cnt--;
b++;
}
ans = max(ans, e - b + 1);
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int l, u, v, w, x, y, z, a, b, c, d, e, f, t = 1, tc;
int flg, sz, cnt, gt, ans, mx, mn;
int m, k, i, j;
int low, hi, md, sm, ff;
int n, inp[2007], ase[2007][27];
char ch;
string st;
scanf("%d", &n);
cin >> st;
sz = st.size();
memset(ase, 0, sizeof ase);
for (int i = 0; i < 26; i++) {
for (int j = 0; j < sz; j++) {
cnt = 0;
for (int k = j; k < sz; k++) {
if (st[k] != i + 'a') cnt++;
ase[cnt][i] = max(ase[cnt][i], k - j + 1);
}
}
}
scanf("%lld", &tc);
while (tc--) {
scanf("%d", &m);
getchar();
m = min(m, sz);
ch = getchar();
x = ch - 'a';
ans = 0;
for (int i = 0; i < m + 1; i++) ans = max(ans, ase[i][x]);
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
string s;
cin >> s;
int q;
cin >> q;
int k;
char c;
while (q--) {
cin >> k >> c;
int st = 0, end = 0;
int temp = 0;
int ans = 0;
while (end < n) {
while (end < n) {
if (s[end] != c) {
if (temp + 1 > k) break;
temp++;
}
ans = max(ans, end - st + 1);
end++;
}
while (st < n and temp >= k) {
if (s[st] != c) temp--;
st++;
}
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0);
long long n, q;
string s;
cin >> n >> s >> q;
long long dp[n + 1][26];
memset(dp, 0, sizeof(dp));
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j < 26; j++) {
char c = j + 97;
long long ans = 0, cap = 0, prev = 0;
long long& cache = dp[i][j];
for (long long k = 0; k < n; k++) {
if (s[k] == c) {
ans++;
} else {
if (cap == i) {
while (prev < k && s[prev] == c) prev++, ans--;
prev++;
} else {
cap++;
ans++;
}
}
cache = max(cache, ans);
}
}
}
while (q--) {
long long m;
char c;
cin >> m >> c;
cout << dp[m][c - 'a'] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n, q;
string s;
cin >> n >> s >> q;
long long dp[1501][150];
for (char c = 'a'; c <= 'z'; ++c) {
for (long long i = 0; i < n; ++i) {
char ch = s[i];
if (!i) {
if (ch == c) {
dp[0][c] = 1;
} else {
dp[0][c] = 0;
}
continue;
}
dp[i][c] = dp[i - 1][c];
if (ch == c) {
dp[i][c]++;
}
}
}
vector<vector<long long> > need(1501, vector<long long>(150, 0));
for (long long c = 'a'; c <= 'z'; ++c) {
for (long long j = 0; j < n - 1; ++j) {
for (long long k = j + 1; k < n; ++k) {
long long count{};
count = dp[k][c] - dp[j][c];
if (s[j] == c) {
count++;
}
count = k - j + 1 - count;
need[count][c] = max(need[count][c], k - j + 1);
}
}
}
for (long long i = 0; i < q; ++i) {
long long m;
char c;
cin >> m >> c;
long long ans{};
for (long long j = 0; j <= m; ++j) {
ans = max(need[j][c], ans);
}
cout << (!ans ? 1 : ans) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!(ch >= '0' && ch <= '9')) {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * f;
}
const int N = 1505;
const int M = 27;
int n, q;
char s[N];
vector<pair<int, int> > color[M];
int ans[M][N];
int tmp[N];
int ptr[N];
inline void Calc() {
for (int i = 1; i <= 26; i++) {
int tot = color[i].size();
for (int j = 0; j <= tot - 1; j++)
tmp[j] = color[i][j].second, ptr[j] = j + 1;
tmp[tot] = n + 1;
ptr[tot] = tot;
for (int j = 1; j <= n; j++) {
for (int k = 0; k <= tot; k++) tmp[k]++;
for (int k = 0; k <= tot; k++) {
if (ptr[k] < tot && tmp[k] == color[i][ptr[k]].first - 1) {
tmp[k] = color[i][ptr[k]].second;
ptr[k]++;
}
}
for (int k = 0; k <= tot - 1; k++)
ans[i][j] = max(ans[i][j], tmp[k] - color[i][k].first + 1);
ans[i][j] = max(ans[i][j], tmp[tot] - n - 1);
}
}
}
int main() {
n = read();
scanf("%s", s + 1);
int last = 1;
for (int i = 2; i <= n; i++)
if (s[i] != s[i - 1]) {
color[s[i - 1] - 'a' + 1].push_back(make_pair(last, i - 1));
last = i;
}
color[s[n] - 'a' + 1].push_back(make_pair(last, n));
Calc();
q = read();
while (q--) {
int m = read();
char c[10];
scanf("%s", c);
printf("%d\n", min(ans[c[0] - 'a' + 1][m], n));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string input;
const int LETTER_COUNT = 26;
int symCount[LETTER_COUNT][2000];
int maxChangedString[LETTER_COUNT][2000];
int Num(char sym) { return sym - 'a'; }
char Sym(int num) { return num + 'a'; }
int IntervalLen(int begin, int end) { return end - begin + 1; }
int SymCountOnInterval(int begin, int end, int symNum) {
return (begin == 0 ? symCount[symNum][end]
: symCount[symNum][end] - symCount[symNum][begin - 1]);
}
int main() {
int n;
scanf("%d", &n);
cin >> input;
for (int i = 0; i < n; i++)
for (int j = 0; j < LETTER_COUNT; j++) {
symCount[j][i] = (i == 0 ? 0 : symCount[j][i - 1]);
if (Num(input[i]) == j) symCount[j][i]++;
}
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++)
for (int k = 0; k < LETTER_COUNT; k++) {
int intervalLen = IntervalLen(i, j);
int changedSymbols = intervalLen - SymCountOnInterval(i, j, k);
maxChangedString[k][changedSymbols] =
max(maxChangedString[k][changedSymbols], intervalLen);
}
for (int i = 1; i <= n; i++) {
for (int k = 0; k < LETTER_COUNT; k++)
maxChangedString[k][i] =
max(maxChangedString[k][i - 1], maxChangedString[k][i]);
}
int m = 0;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int a;
char c;
cin >> a >> c;
printf("%d\n", maxChangedString[Num(c)][a]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
void tp(string s, int n, int u, char v) {
int i = 0, dem = 0, maxx = 0, j = 0;
while (j < n) {
for (; j < n; j++) {
if (s[j] != v) {
if (u == 0) {
break;
}
u--;
dem++;
maxx = max(maxx, dem);
} else {
dem++;
maxx = max(maxx, dem);
}
}
for (; i < n; i++) {
if (s[i] != v) {
u++;
dem--;
if (u != 0) {
i++;
break;
}
} else {
dem--;
}
}
}
cout << maxx << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
cin >> s;
int q, m;
cin >> q;
char c;
for (int i = 0; i < q; i++) {
cin >> m >> c;
tp(s, n, m, c);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1501, MOD = 1000000007;
long long ans[MAXN][26];
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
long long n, q;
string s;
cin >> n >> s >> q;
for (long long i = 0; i < 26; i++) {
vector<long long> c(n);
c[0] = 0;
if (s[0] - 'a' != i) {
c[0]++;
}
for (long long j = 1; j < n; j++) {
c[j] = c[j - 1];
if (s[j] - 'a' != i) {
c[j]++;
}
}
for (long long j = 1; j <= n; j++) {
long long r = 0;
while (r < n - 1) {
if (c[r + 1] <= j) {
r++;
} else {
break;
}
}
long long kek = r + 1;
for (long long k = 1; k < n; k++) {
while (r < n - 1) {
if (c[r + 1] - c[k - 1] <= j) {
r++;
} else {
break;
}
}
kek = max(kek, r - k + 1);
}
ans[j][i] = kek;
}
}
while (q--) {
long long m;
char c;
cin >> m >> c;
cout << ans[m][c - 'a'] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q, maxn, l;
char s[2000];
int main() {
int m;
char c;
scanf("%d", &n);
scanf("%s", s);
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d %c", &m, &c);
int res = 0, len = 0, l = 0;
for (int t = 0; t < n; t++) {
if (s[t] != c) len++;
while (len > m) {
if (s[l++] != c) len--;
}
res = max(res, t - l + 1);
}
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<char> S(n);
for (int i = 0; i < n; ++i) cin >> S[i];
vector<vector<int>> ST(26, vector<int>(n + 1, 0));
for (int i = 0; i < 26; ++i) {
int k = 0;
for (int j = 0; j < n; ++j) {
if (S[j] != i + 'a') {
++k;
}
ST[i][j + 1] = k;
}
}
int q, m;
char c;
cin >> q;
for (int i = 0; i < q; ++i) {
cin >> m >> c;
int a = 0, s = 1, f = s;
while (f <= n) {
if (ST[c - 'a'][f] - ST[c - 'a'][s - 1] <= m)
++f;
else {
a = max(a, f - s);
++s;
++f;
}
}
a = max(a, f - s);
cout << a << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> v(26);
int bun(string s, char c, int m) {
int i, n = s.size(), j, k = 0, t = 0;
i = 0;
j = 0;
for (i = 0; i < n; i++) {
if (s[i] != c) k++;
if (k > m) {
while (j < i && k > m) {
if (s[j] != c) k--;
j++;
}
}
t = max(t, i - j + 1);
}
return t;
}
void fun(string s) {
int i, n = s.size(), j, k;
int b[26];
for (i = 0; i < 26; i++) b[i] = 0;
for (i = 0; i < n; i++) b[s[i] - 'a'] = 1;
for (i = 0; i < 26; i++) {
for (j = 1; j <= n; j++) {
if (b[i] == 0) {
v[i].push_back(j);
continue;
;
}
if (j == n) {
v[i].push_back(n);
break;
}
v[i].push_back(bun(s, i + 'a', j));
}
}
}
int main() {
int n, i, q, m;
cin >> n;
string s;
cin >> s;
fun(s);
cin >> q;
char c;
for (i = 0; i < q; i++) {
cin >> m >> c;
cout << v[c - 'a'][m - 1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1505;
const int INF = 1 << 31 - 1;
array<int, 26> num;
array<vector<int>, 26> vecs;
int main() {
int n;
cin >> n;
for (int i = 0; i < 26; i++) num[i] = -1;
string s;
cin >> s;
for (int i = 0; i < s.size(); i++) {
auto c = s[i];
int temp = i - num[c - 'a'] - 1;
vecs[c - 'a'].push_back(temp);
num[c - 'a'] = i;
}
for (int i = 0; i < 26; i++) vecs[i].push_back(s.size() - num[i] - 1);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int num;
char c;
cin >> num >> c;
int sum = 0;
int res = 0;
int k = 0;
for (int j = 0; j < vecs[c - 'a'].size();) {
sum += vecs[c - 'a'][j++];
while (k < vecs[c - 'a'].size() && sum > num) sum -= vecs[c - 'a'][k++];
if (k >= vecs[c - 'a'].size()) break;
if (k == 0)
res = max(res, j - k);
else if (j == vecs[c - 'a'].size())
res = max(res, j - k);
else
res = max(res, j - k + 1);
}
int ans = min(res + num, n);
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long linf = 1e18;
const double pi = acos(-1.0);
const int MAXN = 1e6 + 10;
const int MAXM = 1e5 + 10;
const double eps = 1e-8;
char s[MAXN];
int m;
deque<char> q;
int main() {
int n;
scanf("%d", &n);
scanf("%s", s);
scanf("%d", &m);
while (m--) {
int x;
char ch;
scanf("%d %c", &x, &ch);
int y = x;
int sum = 0;
int maxn = 0;
while (!q.empty()) q.pop_front();
if (x >= n) {
printf("%d\n", n);
continue;
}
for (int i = 0; i < n; ++i) {
if (s[i] == ch) {
q.push_back(s[i]);
++sum;
} else {
if (!x) {
while (q.size() && q.front() == ch) q.pop_front(), --sum;
q.pop_front();
--sum;
++x;
}
--x;
q.push_back(s[i]);
++sum;
}
maxn = max(maxn, sum);
}
printf("%d\n", maxn);
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1505;
const int INF = 0x3f3f3f3f;
using namespace std;
char s[maxn];
int main() {
char ch;
char sh[2];
int n, k, q;
scanf("%d", &n);
scanf("%s", s);
scanf("%d", &q);
while (q--) {
scanf("%d%s", &k, sh);
ch = sh[0];
int l = 0, r, ans = 0;
for (r = 0; r < n && k > 0; r++) {
if (s[r] != ch) k--;
}
ans = r - l;
while (r < n) {
while (r < n && s[r] == ch) {
r++;
}
ans = max(ans, r - l);
r++;
while (l < r && s[l] == ch) {
l++;
}
l++;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[26][1510][1510];
int ans[26][1510];
int main() {
int n, i, j, k;
cin >> n;
char arr[1510];
cin >> arr;
for (i = 'a'; i <= 'z'; i++) {
for (j = 0; j <= n; j++) {
for (k = 1; k <= n; k++) {
if (arr[k - 1] == i) {
dp[i - 'a'][j][k] = dp[i - 'a'][j][k - 1] + 1;
} else {
if (j)
dp[i - 'a'][j][k] = dp[i - 'a'][j - 1][k - 1] + 1;
else
dp[i - 'a'][j][k] = 0;
}
ans[i - 'a'][j] = max(ans[i - 'a'][j], dp[i - 'a'][j][k]);
}
}
}
int m;
cin >> m;
int q1;
char q2;
for (i = 0; i < m; i++) {
cin >> q1 >> q2;
cout << ans[q2 - 'a'][q1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, q;
string s;
long long acc[1510][26];
long long ans[1510][26];
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> s;
for (long long i = 0; i < n; i++)
for (long long j = 0; j < 26; j++)
acc[i + 1][j] = acc[i][j] + (s[i] - 'a' == j ? 1 : 0);
for (long long i = 0; i < 26; i++) {
long long now = 0;
for (long long j = 0; j < n + 1; j++) {
while (true) {
bool clear = false;
for (long long k = 0; k < n; k++)
if (k + 1 - now >= 0 &&
acc[k + 1][i] - acc[k + 1 - now][i] + j >= now)
clear = true;
if (clear) {
ans[j][i] = now;
now++;
} else {
now--;
break;
}
}
}
}
cin >> q;
while (q--) {
long long m;
cin >> m;
char c;
cin >> c;
cout << ans[m][c - 'a'] << endl;
}
}
|
#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() {
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;
template <typename T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename T>
T LCM(T a, T b) {
return a * (b / gcd(a, b));
}
template <typename T>
T expo(T base, T e, T mod) {
T res = 1;
while (e > 0) {
if (e & 1) res = res * base % mod;
base = base * base % mod;
e >>= 1;
}
return res;
}
template <typename T, typename second>
T expo(T b, second e) {
if (e <= 1) return e == 0 ? 1 : b;
return (e & 1) == 0 ? expo((b * b), e >> 1) : (b * expo((b * b), e >> 1));
}
template <typename T, typename second>
T modinv(T a, second mod) {
return expo(a, mod - 2, mod);
}
template <typename T>
void in(T &x) {
T c = getchar();
while (((c < 48)(c > 57)) && (c != '-')) c = getchar();
bool neg = false;
if (c == '-') neg = true;
x = 0;
for (; c < 48 || c > 57; c = getchar())
;
for (; c > 47 && c < 58; c = getchar()) x = (x * 10) + (c - 48);
if (neg) x = -x;
}
int main() {
int n, q, no;
char c;
string str;
cin >> n >> str >> q;
int s[n];
for (__typeof(n) i = 0; i < n; i++) s[i] = str[i] - 'a';
int sol[26][n];
for (__typeof(26) i = 0; i < 26; i++) {
for (__typeof(n) j = 1; j <= n; j++) {
int k = 0, cnt = j, ans = j, len = 0;
while (k < n) {
if (s[k] == i)
k++, len++;
else {
if (cnt)
cnt--, k++, len++;
else {
if (s[k - len] == i)
while (s[k - len] == i) len--;
k++;
}
}
ans = max(ans, len);
}
sol[i][j - 1] = ans;
}
}
for (__typeof(q) i = 0; i < q; i++) {
cin >> no >> c;
cout << sol[int(c - 'a')][no - 1] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int res[26][1505];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
string s;
cin >> s;
for (int c = 0; c < 26; c++) {
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = i; j < n; j++) {
if (s[j] - 'a' != c) cnt++;
res[c][cnt] = max(res[c][cnt], j - i + 1);
}
}
for (int i = 1; i <= n; i++) res[c][i] = max(res[c][i], res[c][i - 1]);
}
int q;
cin >> q;
while (q--) {
int m;
char ch;
cin >> m >> ch;
cout << res[ch - 'a'][m] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
string str;
int arr[26][2000];
int main() {
int n;
scanf("%d", &n);
cin >> str;
for (int i = 0; i < 26; i++) {
for (int mm = 1; mm <= n; mm++) {
int start = 0, end = 0;
int av = mm, ans = 0, cnt = 0;
while (end < n) {
if (av == 0) {
while (end < n && str[end] == 'a' + i) {
end++;
cnt++;
}
ans = max(ans, cnt);
while (str[start] == 'a' + i) {
start++;
cnt--;
}
start++;
cnt--;
av++;
}
if (end >= n) break;
if (str[end] == 'a' + i) {
cnt++;
end++;
} else {
end++;
cnt++;
av--;
}
ans = max(ans, cnt);
}
arr[i][mm] = ans;
}
}
int q;
scanf("%d", &q);
char c;
int m;
while (q--) {
scanf("%d %c", &m, &c);
printf("%d\n", arr[c - 'a'][m]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
string g;
cin >> g;
int q;
scanf("%d", &q);
map<pair<int, char>, int> ans;
for (char c = 'a'; c <= 'z'; c++) {
for (int m = 0; m <= n; m++) {
long long i = 0, j = 0;
long long b = 0;
int ma = 0;
queue<long long> last;
for (; i < n; i++) {
if (g[i] != c) {
b++;
last.push(i);
if (b > m) {
j = last.front() + 1;
last.pop();
b--;
}
}
ma = max((long long)ma, i - j + 1);
}
ans[make_pair(m, c)] = ma;
}
}
for (; q > 0; q--) {
int m;
char c;
scanf("%d %c", &m, &c);
printf("%d\n", ans[make_pair(m, c)]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, n, q, k, mx, l, r, b;
char c, s[1509];
int main() {
cin >> n >> s >> q;
for (i = 1; i <= q; i++) {
cin >> b >> c;
mx = 0;
l = 0;
k = 0;
for (r = 0; r < n; r++) {
if (s[r] != c) k++;
if (k > b) {
l++;
if (s[l - 1] != c) k--;
}
mx = max(mx, r - l + 1);
}
cout << mx << endl;
}
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';
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 Q = 200009;
const int N = 2000;
const int M = 30;
char s[N];
int n, m, ans[Q], hc[N];
struct Query {
int id, v;
};
vector<Query> q[M];
inline int read() {
char c = getchar();
int ret = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c <= '9' && c >= '0') {
ret = ret * 10 + c - '0';
c = getchar();
}
return ret * f;
}
inline void solve(int ty) {
memset(hc, 0, sizeof(hc));
for (int l = 1; l <= n; l++) {
for (int r = l, cnt = 0; r <= n; r++) {
cnt += (s[r] != 'a' + ty);
hc[cnt] = max(hc[cnt], r - l + 1);
}
}
for (int i = 1; i <= n; i++) {
hc[i] = max(hc[i], hc[i - 1]);
}
for (int i = 0; i < (int)q[ty].size(); i++) {
ans[q[ty][i].id] = hc[q[ty][i].v];
}
}
int main() {
n = read();
scanf("%s", s + 1);
m = read();
for (int i = 1; i <= m; i++) {
Query tmp;
tmp.v = read();
tmp.id = i;
char c[3];
scanf("%s", c + 1);
q[c[1] - 'a'].push_back(tmp);
}
for (int i = 0; i < 26; i++) {
solve(i);
}
for (int i = 1; i <= m; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
string s;
cin >> s;
vector<vector<int> > pref(n, vector<int>(26));
for (int i = 0; i < n; i++) {
pref[i][s[i] - 'a'] = 1;
}
int q;
cin >> q;
while (q--) {
int m;
char ch;
cin >> m >> ch;
int c = ch - 'a';
int lo = 0, hi = 0;
int max_len = 0;
int cur_sum = 0;
for (; hi < n; hi++) {
cur_sum += pref[hi][c];
int rem = (hi - lo + 1) - cur_sum;
if (rem <= m) max_len = max(max_len, hi - lo + 1);
if (rem > m) {
while (lo <= hi && rem > m) {
cur_sum -= pref[lo++][c];
rem = (hi - lo + 1) - cur_sum;
}
if (lo <= hi) max_len = max(max_len, hi - lo + 1);
}
}
cout << max_len << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, mn[30][2200], sum[30][2200];
char c;
string s;
int main() {
cin >> n >> s;
s = "#" + s;
for (int i = 1; i <= n; i++) sum[s[i] - 'a'][i] = 1;
for (int i = 0; i < 26; i++) {
for (int j = 2; j <= n; j++) sum[i][j] += sum[i][j - 1];
}
for (int i = 0; i < 26; i++) {
for (int l = 1; l <= n; l++)
for (int r = l; r <= n; r++) {
mn[i][r - l + 1 - sum[i][r] + sum[i][l - 1]] =
max(mn[i][r - l + 1 - sum[i][r] + sum[i][l - 1]], r - l + 1);
}
}
for (int i = 0; i < 26; i++) {
for (int j = 1; j <= n; j++) mn[i][j] = max(mn[i][j], mn[i][j - 1]);
}
int q, m;
cin >> q;
for (int i = 0; i < q; i++) {
scanf("%d %c", &m, &c);
printf("%d\n", mn[c - 'a'][m]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i, j, k, f[30][2000], dem, x, d[2000], t;
char s[2000], m;
int main() {
scanf("%d", &n);
scanf("%s", s);
for (i = 1; i <= n; i++) d[i] = s[i - 1] - 'a';
for (i = 1; i <= n; i++)
for (j = 0; j < 26; j++) {
dem = 0;
f[j][0] = 0;
k = i;
t = 0;
while (k > 0) {
t++;
if (d[k] != j) dem++;
f[j][dem] = max(f[j][dem], t);
k--;
}
while (dem <= n) {
dem++;
f[j][dem] = max(f[j][dem], t);
}
}
scanf("%d", &k);
for (i = 0; i < k; i++) {
cin >> x >> m;
printf("%d\n", f[m - 'a'][x]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1600;
char ch[N], str;
int x[N][30], y[N][30], n;
bool f(int k, int m, int w) {
for (int i = 0, j = k; j <= n; i++, j++)
if (k - (x[j][w] - x[i][w]) <= m) return true;
return false;
}
int main() {
int i, j, m, a, b, l, r, mid;
scanf("%d", &n);
scanf("%s", ch + 1);
for (i = 1; i <= n; i++)
for (j = 0; j < 26; j++)
x[i][j] = x[i - 1][j] + (ch[i] - 'a' == j), y[i][j] = -1;
scanf("%d", &m);
while (m--) {
scanf("%d %c", &a, &str);
b = str - 'a';
if (y[a][b] == -1) {
l = 1;
r = n + 1;
while (l + 1 < r) {
mid = (l + r) / 2;
if (f(mid, a, b))
l = mid;
else
r = mid;
}
y[a][b] = l;
}
printf("%d\n", y[a][b]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int badCount[26][n + 1];
for (int i = 0; i < 26; i++) {
badCount[i][0] = 0;
}
char in;
map<char, int> letterCount;
auto it = letterCount.begin();
in = getchar();
for (int i = 1; i < n + 1; i++) {
in = getchar();
for (int j = 0; j < 26; j++) {
badCount[j][i] = badCount[j][i - 1];
}
badCount[(int)(in - 'a')][i]++;
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int m;
char c;
cin >> m >> c;
int index = c - 'a';
int right = 1;
int maxLength = 0;
for (int left = 0; left < n; left++) {
while (right - left - (badCount[index][right] - badCount[index][left]) <=
m &&
right < n + 1) {
right++;
}
maxLength = max(maxLength, right - left - 1);
}
cout << maxLength << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1550;
int dp[27][MAX_N][MAX_N];
int y[27][MAX_N];
int x[MAX_N];
int main() {
int n, m, a, b, ans;
cin >> n;
char c;
for (int i = 0; i < n; i++) {
cin >> c;
x[i] = c - 'a';
}
for (int k = 0; k < 26; k++) {
if (x[0] == k) dp[k][0][0] = 1;
dp[k][0][1] = 1;
for (int i = 1; i < n; i++) {
if (x[i] == k) dp[k][i][0] = max(dp[k][i - 1][0] + 1, dp[k][i][0]);
for (int j = 1; j <= n; j++) {
if (x[i] == k) dp[k][i][j] = max(dp[k][i - 1][j] + 1, dp[k][i][j]);
dp[k][i][j] = max(dp[k][i - 1][j - 1] + 1, dp[k][i][j]);
}
}
}
for (int k = 0; k < 26; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j <= n; j++) y[k][j] = max(y[k][j], dp[k][i][j]);
}
}
cin >> m;
for (int i = 0; i < m; i++) {
ans = 0;
cin >> a >> c;
b = c - 'a';
for (int i = 0; i <= a; i++) ans = max(ans, y[b][i]);
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, q;
cin >> n;
string s;
cin >> s;
map<char, vector<int>> data, ans;
for (char t = 'a'; t <= 'z'; t++) {
vector<int> tmp(n + 1);
for (int j = 1; j <= n; j++) {
if (s[j - 1] == t) {
tmp[j]++;
}
tmp[j] += tmp[j - 1];
}
data[t] = tmp;
}
for (char t = 'a'; t <= 'z'; t++) {
vector<int> tmp(n + 1);
ans[t] = tmp;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
int x = j - i + 1 - (data[t][j] - data[t][i - 1]);
if (ans[t][x] <= j - i + 1) {
ans[t][x] = j - i + 1;
}
}
}
for (int i = 1; i <= n; i++) {
ans[t][i] = max(ans[t][i], ans[t][i - 1]);
}
}
cin >> q;
for (int i = 0; i < q; i++) {
int a;
char c;
cin >> a >> c;
cout << ans[c][a] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
string s;
cin >> s;
vector<vector<long long int>> mem(26, vector<long long int>(n + 1, 0));
long long int q;
cin >> q;
while (q--) {
long long int m;
char c;
cin >> m >> c;
if (mem[c - 'a'][m]) {
cout << mem[c - 'a'][m] << '\n';
continue;
}
long long int l = 0, r = 0, cnt = 0, ans = m;
while (r < n) {
cnt += (s[r] != c);
if (cnt > m) {
cnt -= (s[l] != c);
cnt -= (s[r] != c);
l++;
} else {
ans = max(ans, r - l + 1);
r++;
}
}
mem[c - 'a'][m] = ans;
cout << ans << '\n';
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int T = 1;
for (long long int TT = 1; TT <= T; TT++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int dp[1600][28];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
cin.ignore(256, '\n');
cin >> s;
int t;
cin >> t;
while (t--) {
int m;
char c;
cin >> m >> c;
int start = 0, convert = 0, ans = 0;
for (int i = 0; i < n; i++) {
if (s[i] != c) convert++;
while (convert > m) {
if (s[start] != c) convert--;
start++;
}
ans = max(ans, i - start + 1);
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
vector<vector<int> > dp;
vector<int> res;
void recalc(char col) {
dp = vector<vector<int> >(n + 1, vector<int>(n + 1, 0));
res = vector<int>(n, 0);
for (int(i) = 0; (i) < (n + 1); ++(i)) dp[i][0] = 0;
for (int(ncur) = (1); (ncur) < (n + 1); ++(ncur)) {
for (int(mcur) = (0); (mcur) < (n + 1); ++(mcur)) {
if (s[ncur - 1] == col) {
dp[mcur][ncur] = dp[mcur][ncur - 1] + 1;
continue;
}
if (mcur == 0) {
dp[mcur][ncur] = 0;
} else {
dp[mcur][ncur] = dp[mcur - 1][ncur - 1] + 1;
}
}
}
for (int(i) = 0; (i) < (n); ++(i)) {
for (int(j) = (1); (j) < (n + 1); ++(j)) {
res[i] = max(res[i], dp[i + 1][j]);
}
}
}
void solve() {
cin >> n;
cin >> s;
int q;
cin >> q;
vector<pair<pair<char, int>, int> > qrs(q);
for (int(i) = 0; (i) < (q); ++(i)) {
cin >> qrs[i].first.second >> qrs[i].first.first;
qrs[i].second = i;
}
sort(qrs.begin(), qrs.end());
vector<pair<int, int> > ans(q);
char lastcol = -1;
for (int(i) = 0; (i) < (q); ++(i)) {
char col = qrs[i].first.first;
int m = qrs[i].first.second;
if (col != lastcol) {
lastcol = col;
recalc(col);
}
ans[i].first = qrs[i].second;
ans[i].second = res[m - 1];
}
sort(ans.begin(), ans.end());
for (int(i) = 0; (i) < (q); ++(i)) cout << ans[i].second << endl;
}
int main() {
ios_base::sync_with_stdio(false);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
FILE *in, *out;
struct path {
int x, y, ind, neg;
};
int N, M, K;
bool operator<(path p, path q) { return (p.x != q.x) ? p.x < q.x : p.y < q.y; }
char ar[1510];
int read() {
int i, j, k;
fscanf(in, "%d", &N);
fscanf(in, "%s", ar);
for (i = 0; i < N; i++) ar[i] -= 'a';
return 0;
}
int reset() {
int i, j, k;
return 0;
}
int dn[1510][1510];
int res[30][1510];
int make() {
int i, j, k;
for (j = 0; j <= 'z' - 'a'; j++) {
for (i = N - 1; i >= 0; i--) {
if (j == ar[i])
dn[i][0] = dn[i + 1][0] + 1;
else
dn[i][0] = 0;
for (k = 1; k <= N; k++) {
if (j == ar[i])
dn[i][k] = dn[i + 1][k] + 1;
else
dn[i][k] = dn[i + 1][k - 1] + 1;
}
}
for (i = 0; i <= N; i++) {
for (k = 0; k < N; k++) res[j][i] = max(res[j][i], dn[k][i]);
}
}
char ss[20];
fscanf(in, "%d", &M);
for (i = 0; i < M; i++) {
fscanf(in, "%d %s", &j, ss);
printf("%d\n", res[ss[0] - 'a'][j]);
}
return 0;
}
int main() {
in = stdin;
read();
make();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
using pii = pair<int, int>;
using vi = vector<int>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vlli = vector<long long int>;
using vpii = vector<pair<int, int>>;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q, m, ans, other, dp[30][1510];
string s;
char fav;
cin >> n >> s >> q;
memset(dp, 0, sizeof dp);
for (int i = 0; i < q; i++) {
cin >> m >> fav;
if (dp[fav - 'a'][m])
cout << dp[fav - 'a'][m] << '\n';
else {
int l = 0, r = 0;
other = ans = 0;
if (s[l] != fav) other++;
while (l < n) {
if (other <= m) {
ans = max(ans, r - l + 1);
if (r + 1 < n) {
r++;
if (s[r] != fav) other++;
} else {
if (s[l] != fav) other--;
l++;
}
} else {
if (s[l] != fav) other--;
l++;
}
}
dp[fav - 'a'][m] = ans;
cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.1415926535897932384626;
long long MOD = 1000000007;
const long double EPS = 1e-9;
const int N = 3e5 + 7;
inline long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline unsigned int setbits(unsigned int v) {
unsigned int c;
for (c = 0; v; ++c) v &= (v - 1);
return c;
}
inline bool is_power_of_two(unsigned int v) { return (v && !(v & (v - 1))); }
inline void scan(int& a) { scanf("%d", &a); }
inline void scan(long long& a) { scanf("%lld", &a); }
inline void scan(long double& a) { scanf("%Lf", &a); }
inline void scan(string& a) { cin >> a; }
inline void scan(pair<int, int>& a) { scanf("%d %d", &a.first, &a.second); }
template <typename T>
inline void scanarr(const vector<T>& arr) {
for (int i = 0; i < arr.size(); ++i) scan(arr[i]);
}
template <typename T>
inline void scanarr2d(const vector<vector<T>>& arr) {
for (int i = 0; i < arr.size(); ++i)
for (int j = 0; j < arr[i].size(); ++j) cin >> arr[i][j];
}
inline void print(const int& v) { printf("%d\n", v); }
inline void print(const long long& v) { printf("%lld\n", v); }
inline void print(const long double& v) { printf("%Lf\n", v); }
inline void print(const string& v) { printf("%s\n", v.c_str()); }
inline void print(const pair<int, int>& v) {
printf("%d %d\n", v.first, v.second);
}
template <typename T>
inline void printarr(const vector<T>& arr) {
for (int i = 0; i < arr.size(); ++i) print(arr[i]);
}
template <typename T>
inline void printarr2d(const vector<vector<T>>& arr) {
for (int i = 0; i < arr.size(); ++i) {
for (int j = 0; j < arr[i].size(); ++j) cout << arr[i] << " ";
cout << '\n';
}
}
bool is_palin(const string& s) {
int i, j;
for (i = 0, j = s.length() - 1; i <= j; ++i, --j)
if (s[i] != s[j]) return false;
return true;
}
long long power(long long base, unsigned long long exp, long long mod = MOD) {
long long res = 1;
base %= mod;
while (exp) {
if (exp & 1) res = (res * base) % mod;
exp >>= 1;
base = (base * base) % mod;
}
return res;
}
long long modinv(long long a, long long mod = MOD) {
if (mod == 1) return 0;
long long x = 1, y = 0, m = mod;
while (a > 1) {
long long q = a / m, t = m;
m = a % m;
a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += mod;
return x;
}
inline unsigned int iabs(int x) {
unsigned int y = x;
return (y > 0) ? y : -y;
}
inline long long add(long long a, long long b, long long mod = MOD) {
long long res = (a % mod + b % mod) % mod;
return res;
}
inline long long sub(long long a, long long b, long long mod = MOD) {
long long res = (a % mod - b % mod + mod) % mod;
return res;
}
inline long long mult(long long a, long long b, long long mod = MOD) {
long long res = (a % mod * b % mod) % mod;
return res;
}
inline long long divi(long long a, long long b, long long mod = MOD) {
long long res = (a % mod * modinv(b, mod)) % mod;
return res;
}
void openf() {}
vector<vector<vector<int>>> dp(1500,
vector<vector<int>>(1501, vector<int>(2, 0)));
vector<vector<int>> ans(1501, vector<int>(26, 0));
int main() {
openf();
int m, n, q, msf = 1;
char c;
string s;
cin >> n >> s >> q;
for (int k = 0; k < 26; ++k) {
for (int i = 0; i < 1500; ++i) {
for (int j = 0; j < 1501; ++j) {
for (int w = 0; w < 2; ++w) {
dp[i][j][w] = 0;
}
}
}
if ((s[0] - 'a') == k) {
dp[0][0][1] = 1;
} else {
for (int j = 1; j < 1501; ++j) {
dp[0][j][1] = 1;
}
}
int mcl = 0;
if (s[0] - 'a' == k) {
++mcl;
}
for (int i = 1; i < n; ++i) {
for (int j = 1; j < 1501; ++j) {
if ((s[i] - 'a') == k) {
int ti = i - mcl - 1;
if (ti >= 0) {
dp[i][j][1] = 1 + mcl + dp[ti][j][1];
} else {
dp[i][j][1] = 1 + mcl;
}
dp[i][j][0] = dp[i - 1][j][0];
} else {
dp[i][j][0] = max(dp[i - 1][j][0], dp[i - 1][j][1]);
int ti = i - mcl - 1;
if (ti >= 0) {
dp[i][j][1] = 1 + mcl + dp[ti][j - 1][1];
} else {
dp[i][j][1] = 1 + mcl;
}
}
}
if (s[i] - 'a' == k) {
++mcl;
} else {
mcl = 0;
}
}
for (int i = 0; i < 1501; ++i) {
ans[i][k] = max(dp[n - 1][i][0], dp[n - 1][i][1]);
}
}
while (q--) {
cin >> m >> c;
cout << ans[m][c - 'a'] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
string s;
cin >> s;
int q;
cin >> q;
while (q--) {
int x;
char c;
cin >> x >> c;
int j = 0, y = x, ans = 0;
for (int i = 0; i < n; i++) {
while (j < n) {
if (s[j] != c) {
if (y == 0) break;
y--;
}
j++;
}
if (s[i] != c) y++;
if (j - i > ans) ans = j - i;
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
long long i, j, n, m;
cin >> n;
string s;
cin >> s;
long long q;
cin >> q;
long long ans[s.length() + 1][26];
long long len = s.length();
memset(ans, -1, sizeof(ans));
for (i = 0; i < 26; i++) {
char c = 'a' + i;
for (j = 0; j < len; j++) {
long long temp = 0;
for (long long l = j; l < len; l++) {
if (s[l] != c) {
temp++;
}
ans[temp][i] = max(ans[temp][i], l - j + 1);
}
}
}
long long lc[26] = {0};
for (i = 0; i < 26; i++) {
for (j = 1; j <= len; j++) {
if (ans[j][i] == -1) {
lc[i] = j;
break;
}
}
}
while (q--) {
long long num;
char c;
cin >> num >> c;
long long ind = c - 'a';
if (ans[num][ind] == -1)
cout << len << endl;
else
cout << ans[num][ind] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string inp;
unordered_map<char, unordered_map<int, int>> alphabet_dict;
vector<char> doesnt_contain_list;
void process(char letter) {
vector<int> places;
for (int x = 0; x < inp.size(); ++x) {
if (inp[x] != letter) {
places.push_back(x);
}
}
unordered_map<int, int> best;
for (int y = 0; y < places.size(); ++y) {
int left;
if (y != 0) {
left = places[y - 1] + 1;
} else {
left = 0;
}
int os = 1;
for (int z = y; z < places.size(); ++z) {
int right;
if (z + 1 >= places.size()) {
right = inp.size() - 1;
} else {
right = places[z + 1] - 1;
}
int myrange = right - left + 1;
if (best.count(os)) {
best[os] = max(myrange, best[os]);
} else {
best[os] = myrange;
}
++os;
}
}
alphabet_dict[letter] = best;
}
int main() {
std::ios::sync_with_stdio(false);
int N;
cin >> N;
cin >> inp;
for (char x = 'a'; x <= 'z'; ++x) {
if (inp.find(x) == string::npos) {
doesnt_contain_list.push_back(x);
} else {
process(x);
}
}
int numqueries;
cin >> numqueries;
for (int q = 0; q < numqueries; ++q) {
int changes;
char curletter;
cin >> changes >> curletter;
if (!alphabet_dict.count(curletter)) {
cout << changes << endl;
continue;
}
if (!alphabet_dict[curletter].count(changes)) {
cout << inp.size() << endl;
} else {
cout << alphabet_dict[curletter][changes] << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char T[1510];
vector<int> Q[26];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, q, m;
char c;
cin >> n;
cin.get();
cin.getline(T, 1510);
for (int i = 0; i < n; i++) {
Q[T[i] - 'a'].push_back(i);
}
cin >> q;
for (int t = 0; t < q; t++) {
cin >> m >> c;
int No = c - 'a';
int len = Q[No].size(), cnt = m, L = 0, R = 1, Out = 0;
for (int i = 0; i < len; i++) {
while (i > L) L = i, cnt += Q[No][L] - Q[No][L - 1] - 1;
while (R < len && cnt >= Q[No][R] - Q[No][R - 1] - 1)
cnt -= Q[No][R] - Q[No][R - 1] - 1, R++;
int H = cnt;
if (H > n - (Q[No][R - 1] - Q[No][L] + 1))
H = n - (Q[No][R - 1] - Q[No][L] + 1);
if (Q[No][R - 1] - Q[No][L] + 1 + H > Out)
Out = Q[No][R - 1] - Q[No][L] + 1 + H;
}
if (m > Out) Out = m;
cout << Out << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2005, M = 100005, mod = 1e9 + 7;
template <class T>
inline void gmin(T &x, const T &y) {
if (x > y) x = y;
}
template <class T>
inline void gmax(T &x, const T &y) {
if (x < y) x = y;
}
inline void ch(int &x, int y) { x = (x + y) % mod; }
template <class T>
inline void read(T &x) {
x = 0;
char ch = getchar(), rev = 0;
while (ch > '9' || ch < '0') rev = (ch == '-'), ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x = rev ? -x : x;
}
template <class T>
inline void print(T x) {
if (!x) {
puts("0");
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
int a[20], m = 0;
while (x) a[m++] = x % 10, x /= 10;
while (m--) putchar(a[m] + '0');
puts("");
}
inline int exp(int x, int y) {
int ans = 1;
while (y) {
if (y & 1) ans = (long long)ans * x % mod;
x = (long long)x * x % mod;
y >>= 1;
}
return ans;
}
int n, Q, dp[26][N], sum[26][N];
char s[N];
int main() {
ios::sync_with_stdio(0);
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) sum[j][i] = sum[j][i - 1] + (s[i] == j + 'a');
}
scanf("%d", &Q);
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= Q; i++) {
int m, c;
char tmp[10];
scanf("%d%s", &m, tmp);
c = tmp[0] - 'a';
if (~dp[c][m]) {
printf("%d\n", dp[c][m]);
continue;
}
int ans = 0;
for (int j = 1; j <= n; j++) {
int l = j - 1, r = n;
while (l < r) {
int mid = l + r + 1 >> 1;
if (sum[c][mid] - sum[c][j - 1] >= mid - j + 1 - m)
l = mid;
else
r = mid - 1;
}
gmax(ans, r - j + 1);
}
dp[c][m] = ans;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pre[27][1505];
int dp[27][1505];
char str[1505];
int main() {
int n;
scanf("%d", &n);
scanf("%s", str + 1);
for (int k = 0; k < 26; k++) {
for (int i = 1; i <= n; i++) {
for (int j = n; j > 0; j--) {
if (str[i] - 'a' == k) {
dp[k][j] = dp[k][j] + 1;
} else {
dp[k][j] = dp[k][j - 1] + 1;
}
pre[k][j] = max(pre[k][j], dp[k][j]);
}
bool flag = str[i] - 'a' == k ? true : false;
if (flag)
dp[k][0] = dp[k][0] + 1;
else
dp[k][0] = 0;
}
}
int q;
scanf("%d", &q);
while (q--) {
int m;
char s;
scanf("%d %c", &m, &s);
int k = s - 'a';
printf("%d\n", pre[k][m]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1550];
int ans[1550][30];
char s[1550];
int n;
int pre[1550][30];
int main() {
scanf("%d", &n);
scanf("%s", s);
for (int i = 1; i <= n; ++i) {
a[i] = s[i - 1] - 'a';
for (int j = 0; j < 26; ++j) pre[i][j] = pre[i - 1][j];
++pre[i][a[i]];
}
for (int i = 1; i <= n; ++i)
for (int j = i; j <= n; ++j) {
for (int col = 0; col < 26; ++col) {
int ned = (j - i + 1) - (pre[j][col] - pre[i - 1][col]);
ans[ned][col] = max(ans[ned][col], j - i + 1);
}
}
for (int i = 1; i <= n; ++i)
for (int j = 0; j < 26; ++j) ans[i][j] = max(ans[i][j], ans[i - 1][j]);
int q;
scanf("%d", &q);
char op[5];
int u, v;
while (q--) {
scanf("%d%s", &u, op);
v = *op - 'a';
printf("%d\n", ans[u][v]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-10;
int dcmp(double x) {
if (fabs(x) < eps)
return 0;
else
return x < 0 ? -1 : 1;
}
const int INF = 0x3f3f3f3f;
const int N = 1505;
char s[2 * N];
int dp[30][2 * N];
int main() {
memset(dp, 0, sizeof(dp));
int n;
scanf("%d", &n);
scanf("%s", s);
for (int i = 0; i < n; i++) {
for (int ch = 0; ch < 26; ch++) {
int x = 0;
for (int l = 1; l <= i + 1; l++) {
if (s[i - l + 1] - 'a' != ch) x++;
dp[ch][x] = max(dp[ch][x], l);
}
}
}
for (int ch = 0; ch < 26; ch++) {
for (int x = 1; x <= n; x++) dp[ch][x] = max(dp[ch][x], dp[ch][x - 1]);
}
int q;
scanf("%d", &q);
while (q--) {
int m;
char ch;
scanf("%d%*c%c", &m, &ch);
ch -= 'a';
printf("%d\n", dp[ch][m]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
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;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while ((c < '0' || c > '9') && (c != '-')) c = getchar();
if (c == '-') f = -1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
const int N = 1510;
int n, m, q, pre[N], ans[27][N];
char s[N];
int main() {
n = read();
scanf("%s", s + 1);
for (register int i = (0); i <= (25); i++) {
for (register int j = (1); j <= (n); j++)
pre[j] = pre[j - 1] + (s[j] != i + 'a');
for (register int j = (1); j <= (n); j++) {
int now = 1;
for (register int k = (1); k <= (n); k++) {
while (pre[k] - pre[now - 1] > j) ++now;
ans[i][j] = max(ans[i][j], k - now + 1);
}
}
}
q = read();
while (q--) {
scanf("%d%s", &m, s + 1);
printf("%d\n", ans[s[1] - 'a'][m]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
void tp(string s, int n, int u, char v) {
int i = 0, dem = 0, maxx = 0, j = 0;
while (j < n) {
for (; j < n; j++) {
if (s[j] != v) {
if (u == 0) {
break;
}
u--;
dem++;
maxx = max(maxx, dem);
} else {
dem++;
maxx = max(maxx, dem);
}
}
for (; i < n; i++) {
if (s[i] != v) {
u++;
dem--;
if (u != 0) {
i++;
break;
}
} else {
dem--;
}
}
}
cout << maxx << "\n";
}
int main() {
cin >> n;
cin >> s;
int q, m;
cin >> q;
char c;
for (int i = 0; i < q; i++) {
cin >> m >> c;
tp(s, n, m, c);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct segment;
struct line;
struct point;
struct vec;
struct ray;
struct point {
long double x, y;
point() {}
point(long long x1, long long y1) {
x = x1;
y = y1;
}
long double dist_to_point(point p) {
return sqrt((p.x - x) * (p.x - x) + (p.y - y) * (p.y - y));
}
bool operator<(point p) { return (x < p.x) || ((x == p.x) && (y < p.y)); }
};
struct vec {
long long x, y;
vec(long long x1, long long y1) {
x = x1;
y = y1;
}
vec(point a, point b) {
x = b.x - a.x;
y = b.y - a.y;
}
vec normal() {
vec ans;
ans.x = y;
ans.y = -x;
return ans;
}
vec opposite() {
vec ans;
ans.x = -x;
ans.y = -y;
return ans;
}
vec sum(vec b) {
vec ans;
ans.x = x + b.x;
ans.y = y + b.y;
return ans;
}
long double cross_product(vec v) { return x * v.y - v.x * y; }
long double dot_product(vec v) { return x * v.x + y * v.y; }
vec resize(long double size) {
vec ans;
ans.x = (x * size) / len();
ans.y = (y * size) / len();
return ans;
}
vec() {}
long double len() { return sqrt(x * x + y * y); }
};
struct line {
long long a, b, c;
line(point a1, point b1) {
a = a1.x - b1.x;
b = b1.y - a1.y;
c = -a1.x * a - a1.y * b;
}
line(long long a1, long long b1, long long c1) {
a = a1;
b = b1;
c = c1;
}
line() {}
vec normal_vec() {
vec ans;
ans.x = a;
ans.y = b;
return ans;
}
long double get_x(long double y1) {
if (a == 0) return 0;
return (-c - b * y1) / a;
}
long double get_y(long double x1) {
if (b == 0) return 0;
return (-c - a * x1) / b;
}
point intersection(line l) {
point ans;
ans.x = (-c * l.b + l.c * b) / (a * l.b - l.a * b);
ans.y = (-a * l.c + l.a * c) / (a * l.b - l.a * b);
return ans;
}
long double dist_to_point(point p) {
return abs((a * p.x + b * p.y + c) / (sqrt(a * a + b * b)));
}
long long is_inside(point p) {
long double k = a * p.x + b * p.y + c;
if (k < 0)
return -1;
else if (k == 0)
return 0;
return 1;
}
};
struct segment {
point a, b;
segment() {}
segment(point a1, point b1) {
a = a1;
b = b1;
}
long double len() {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
bool is_inside(point p) {
line l(a, b);
if (l.is_inside(p) != 0) return false;
vec v(p, a), v1(p, b);
if (v.dot_product(v1) > 0) return false;
return true;
}
long double dist_to_point(point p) {
vec v(a, p), v1(a, b), v2(b, p), v3(b, a);
if (v.dot_product(v1) < 0) return p.dist_to_point(a);
if (v2.dot_product(v3) < 0) return p.dist_to_point(b);
line l(a, b);
return l.dist_to_point(p);
}
};
struct ray {
point a, b;
ray(point p, point p1) {
a = p;
b = p1;
}
ray() {}
long double dist_to_point(point p) {
vec v(a, p), v1(a, b);
if (v.dot_product(v1) < 0) return a.dist_to_point(p);
line l(a, b);
return l.dist_to_point(p);
}
bool is_inside(point p) {
line l(a, b);
if (l.is_inside(p) != 0) return false;
vec v(a, p), v1(a, b);
if (v.dot_product(v1) < 0) return false;
return true;
}
};
struct polygon {
long long n;
vector<point> points;
long double get_area() {
vec v(points[0], points[1]);
long double ans = 0;
for (long long i = 2; i < n; ++i) {
vec v1(points[i - 1], points[i]);
ans = ans + v.cross_product(v1);
}
vec v1(points[n - 1], points[0]);
return ans + v.cross_product(v1);
}
};
struct triangle {
point a, b, c;
triangle() {}
triangle(point a1, point b1, point c1) {
a = a1;
b = b1;
c = c1;
}
long double get_area() {
vec v(a, b), v1(b, c), v2(c, a);
return v.cross_product(v1) + v1.cross_product(v2) + v2.cross_product(v);
}
};
long long power(long long a, long long b) {
if (b == 0)
return 1;
else if (b == 1)
return a;
else {
long long k = power(a, b / 2);
return k * k * power(a, b % 2);
}
}
long long power_mod(long long a, long long b, long long MOD) {
if (b == 0)
return 1;
else if (b == 1)
return a % MOD;
else {
long long k = power_mod(a, b / 2, MOD);
return ((k * k) % MOD * power_mod(a, b % 2, MOD)) % MOD;
}
}
long long sum_mod(long long a, long long b, long long MOD) {
return (a + b) % MOD;
}
long long mul_mod(long long a, long long b, long long MOD) {
return (a * b) % MOD;
}
long long ar[3000][3000];
long long arr[200][3000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
long long n;
cin >> n;
string s;
cin >> s;
long long l = 0;
long long r = 0;
for (char i = 'a'; i <= 'z'; ++i) {
for (long long r = n; r >= 0; --r) {
for (long long l = 0; l <= n; ++l) {
ar[r][l] = 0;
}
}
long long ans = 0;
for (long long j = 0; j < n; ++j) {
if (s[j] == i) ++ans;
}
ar[n][0] = n - ans;
arr[i][ar[n][0]] = n;
for (long long r = n; r > 0; --r) {
for (long long l = 0; l < r; ++l) {
if (r - l > arr[i][ar[r][l]]) arr[i][ar[r][l]] = r - l;
if (s[r - 1] == i)
ar[r - 1][l] = ar[r][l];
else
ar[r - 1][l] = ar[r][l] - 1;
if (s[l] == i)
ar[r][l + 1] = ar[r][l];
else
ar[r][l + 1] = ar[r][l] - 1;
}
}
}
for (long long i = 'a'; i <= 'z'; ++i) {
for (long long j = 1; j <= n; ++j) {
if (arr[i][j - 1] > arr[i][j]) arr[i][j] = arr[i][j - 1];
}
}
long long m;
cin >> m;
for (long long i = 0; i < m; ++i) {
long long a;
char c;
cin >> a >> c;
cout << arr[c][a] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
scanf("%d", &N);
char ch[N + 1];
scanf("%s", ch + 1);
int t[26][N + 1];
for (int j = 0; j < 26; ++j) t[j][1] = (ch[1] == 'a' + j), t[j][0] = 0;
for (int i = 1; i <= N; ++i)
for (int c = 0; c < 26; ++c) t[c][i] = t[c][i - 1] + (ch[i] == 'a' + c);
int d[26][N + 1];
for (int c = 0; c < 26; ++c)
for (int i = 1; i <= N; ++i) {
int l = 1, r = 1;
int ans = 0;
for (; l <= N; ++l) {
while (r <= N && r - l + 1 - t[c][r] + t[c][l - 1] <= i) ++r;
--r;
ans = max(ans, r - l + 1);
}
d[c][i] = ans;
}
int Q;
scanf("%d", &Q);
while (Q--) {
int x;
char c;
scanf("%d %c", &x, &c);
printf("%d\n", d[c - 'a'][x]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, Q;
string str;
short dp[1501][1501][26][2];
int main() {
scanf("%d", &N);
cin >> str;
scanf("%d", &Q);
for (int c = 0; c < 26; c++) {
for (int i = N - 1; i >= 0; i--) {
for (int j = 0; j <= N; j++) {
if (str[i] == 'a' + c) {
dp[i][j][c][1] = 1 + dp[i + 1][j][c][1];
} else {
if (j >= 1) dp[i][j][c][1] = 1 + dp[i + 1][j - 1][c][1];
}
dp[i][j][c][0] = max(dp[i][j][c][0], dp[i][j][c][1]);
dp[i][j][c][0] = max(dp[i][j][c][0], dp[i + 1][j][c][0]);
}
}
}
char c[3];
for (int i = 1; i <= Q; i++) {
int m;
scanf("%d %s", &m, c);
printf("%d\n", dp[0][m][c[0] - 'a'][0]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int men[30][2020], ans[30][2020], n, cnt[30][2020];
int main() {
scanf("%d", &n);
for (int(i) = (0); (i) < (n); (i)++) {
char c;
scanf(" %c", &c);
int p = c - 'a';
for (int(j) = (0); (j) < (30); (j)++) cnt[j][i] = (j != p);
if (i)
for (int(j) = (0); (j) < (30); (j)++) cnt[j][i] += cnt[j][i - 1];
}
for (int(i) = (0); (i) < (30); (i)++) {
for (int(m) = (1); (m) < (n + 1); (m)++) {
men[i][m] = 1e9;
for (int(j) = (0); (j) < (n - m + 1); (j)++)
men[i][m] = min(men[i][m], cnt[i][j + m - 1] - (j ? cnt[i][j - 1] : 0));
ans[i][men[i][m]] = max(ans[i][men[i][m]], m);
}
for (int(m) = (1); (m) < (n + 1); (m)++)
ans[i][m] = max(ans[i][m], ans[i][m - 1]);
}
int q;
scanf("%d", &q);
while (q--) {
int m;
char c;
scanf("%d %c", &m, &c);
printf("%d\n", ans[c - 'a'][m]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1502][26];
string s;
int n;
int len(int w, char c) {
if (dp[w][c - 'a'] != -1) {
return dp[w][c - 'a'];
}
int l = 0;
int m = 1;
int sum = 0;
int tail = 0;
for (int i = 0; i < n; i++) {
if (s[i] == c) {
l++;
} else {
if (sum < w) {
sum++;
l++;
} else {
while (s[tail] == c && tail < i) {
tail++;
}
tail++;
l = i - tail + 1;
}
}
if (l > m) {
m = l;
}
}
return dp[w][c - 'a'] = m;
}
int main() {
cin >> n;
int q;
cin >> s;
for (int i = 0; i < 26; i++) {
for (int j = 0; j <= n; j++) {
dp[j][i] = -1;
}
}
int w;
char c;
cin >> q;
for (int i = 0; i < q; i++) {
scanf("%d %c", &w, &c);
printf("%d\n", len(w, c));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> memo(26, vector<int>(1501, -1));
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
string s;
cin >> s;
for (int id = 0; id < 26; id++) {
for (int i = 0; i <= n; i++) {
int maxVal = 0;
int num = i;
int l = 0;
int r = 0;
for (int l = 0; r < n; l++) {
while (num > 0 && r < n) {
if (s[r] != id + 'a') num--;
r++;
}
while (num == 0 && s[r] == id + 'a') {
r++;
}
maxVal = max(maxVal, r - l);
if (s[l] != id + 'a') num++;
}
memo[id][i] = maxVal;
}
}
int q;
cin >> q;
while (q--) {
int i;
cin >> i;
char c;
cin >> c;
cout << memo[c - 'a'][i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void cass() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void maximize(int &a, int b) { a = max(a, b); }
const int N = 1506;
string st;
int n, q;
int dp[N][30];
int tmp[N][30];
int res[N][30];
void init() {
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n; j++)
for (int c = 0; c < 26; c++) tmp[j][c] = dp[j][c];
for (int j = 0; j <= n; j++)
for (int c = 0; c < 26; c++) {
if (st[i] - 'a' == c)
dp[j][c] = tmp[j][c] + 1;
else {
if (j)
dp[j][c] = tmp[j - 1][c] + 1;
else
dp[j][c] = 0;
}
maximize(res[j][c], dp[j][c]);
}
}
}
int main() {
cass();
cin >> n;
cin >> st;
st = " " + st;
init();
cin >> q;
int x;
char c;
while (q--) {
cin >> x >> c;
cout << res[x][c - 'a'] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int N, Q;
string s;
int best[1600][256];
int pre[1600][256];
int dp[1600][256];
int range(int l, int r, char c) {
if (l == 0) {
return pre[r][c];
}
return pre[r][c] - pre[l - 1][c];
}
int32_t main() {
ios_base::sync_with_stdio(false);
if (fopen("cf814c.in", "r")) {
freopen("cf814c.in", "r", stdin);
freopen("cf814c.out", "w", stdout);
}
cin >> N >> s;
for (char c = 'a'; c <= 'z'; c++) {
pre[0][c] = (bool)(s[0] == c);
for (int i = 1; i < N; i++) {
pre[i][c] = pre[i - 1][c] + (bool)(s[i] == c);
}
}
for (char c = 'a'; c <= 'z'; c++) {
for (int i = 0; i < N; i++) {
for (int j = i; j < N; j++) {
int num = (j - i + 1);
int cur = (range(i, j, c));
int rem = (num - cur);
dp[rem][c] = max(dp[rem][c], num);
}
}
}
for (int i = 1; i <= N; i++) {
for (char c = 'a'; c <= 'z'; c++) {
dp[i][c] = max(dp[i][c], dp[i - 1][c]);
}
}
cin >> Q;
for (int i = 0; i < Q; i++) {
int a;
char c;
cin >> a >> c;
cout << dp[a][c] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1510], q;
int n, f[30][1510];
int main() {
ios::sync_with_stdio(0);
cout.tie(0);
int m, i, j, k, p, t, l;
cin >> n;
cin >> s;
for (i = 0; i < 26; i++)
for (j = 0; j <= n; j++) f[i][j] = j;
for (k = 0; k < 26; k++)
for (i = 1; i < n; i++) {
t = 0;
if (s[i - 1] != k + 'a') {
t++;
f[k][t] = max(f[k][t], 1);
}
for (j = i + 1; j <= n; j++) {
if (s[j - 1] != 'a' + k) t++;
f[k][t] = max(f[k][t], j - i + 1);
}
for (j = t + 1; j <= n; j++) f[k][j] = max(f[k][j], f[k][t]);
}
cin >> m;
while (m--) {
cin >> p >> q;
printf("%d\n", f[q - 'a'][p]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int add(int a, int b) {
long long x = a + b;
if (x >= 1000000007) x -= 1000000007;
if (x < 0) x += 1000000007;
return x;
}
long long mul(long long a, long long b) { return (a * b) % 1000000007; }
long long pw(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return ans;
}
int n, q;
string s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
cin >> s;
cin >> q;
for (int i = 1; i <= q; ++i) {
int nr;
char c;
cin >> nr >> c;
int st = 0;
int dr = 0;
int dif = 0;
int ans = 0;
while (dr < n) {
while (dif > nr) {
if (s[st] != c) --dif;
++st;
}
if (s[dr] != c) ++dif;
while (dif > nr) {
if (s[st] != c) --dif;
++st;
}
ans = max(ans, dr - st + 1);
++dr;
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1505];
int main() {
int n, q;
scanf("%d", &n);
scanf("%s", s);
scanf("%d", &q);
for (; q--;) {
int k;
char ch;
scanf("%d %c", &k, &ch);
int R = 0, ans = 0, cnt = 0;
for (int i = 0; i < n; i++) {
while (R < n && s[R] == ch) ++R;
while (R < n && (cnt < k || s[R] == ch)) {
if (s[R] != ch) ++cnt;
++R;
}
ans = max(ans, R - i);
if (s[i] != ch) --cnt;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[26][2000];
int calc(int n, string& s, int m, char c) {
int l = 0, r = -1;
int w = m;
int ans = 0;
while (l < n) {
while (r + 1 < n) {
if (s[r + 1] != c) {
if (w == 0) {
break;
} else {
w--;
}
}
r++;
}
ans = max(ans, r - l + 1);
if (s[l] != c) {
w++;
}
l++;
}
return ans;
}
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < 26; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j] = calc(n, s, j, i + 'a');
}
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int m;
cin >> m;
char c;
cin >> c;
cout << dp[c - 'a'][m] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i, x, k, q, j, m, dp[26][1501][1501], ans[26][1501];
char a[1510], ch;
int main() {
cin >> n >> a >> q;
for (i = 0; i < 26; i++) {
for (x = 0; x < n; x++) {
for (j = n; j >= 0; j--) {
if (a[x] - 'a' == i) {
if (x - 1 >= 0) dp[i][x][j] += dp[i][x - 1][j];
dp[i][x][j]++;
ans[i][j] = max(ans[i][j], dp[i][x][j]);
} else {
if (x - 1 >= 0) {
if (j - 1 >= 0) {
dp[i][x][j - 1] = max(dp[i][x - 1][j] + 1, dp[i][x][j - 1]);
ans[i][j - 1] = max(ans[i][j - 1], dp[i][x][j - 1]);
}
} else {
if (j - 1 >= 0) {
dp[i][x][j - 1] = max(dp[i][x][j - 1], 1);
ans[i][j - 1] = max(ans[i][j - 1], 1);
}
}
}
}
}
}
for (i = 0; i < q; i++) {
cin >> m >> ch;
cout << ans[ch - 'a'][n - m] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7fffffff;
const int MAX_N = 2005;
const int MAX_V = 0;
const int MAX_M = 290;
const int MAX_K = 90;
int t;
string s;
char c;
int l, n;
void solve() {
if (l >= n)
printf("%d\n", n);
else {
int sum = 0, sum1 = 0;
int b = 0, x = 0;
while (x < n) {
while (x < n && s[x] == c) {
x++;
sum1++;
}
if (s[x] != c && x < n) {
l--;
x++;
sum1++;
}
while (x < n && s[x] == c) {
x++;
sum1++;
}
if (x == n) {
sum = max(sum, sum1);
break;
}
while (l == 0) {
sum = max(sum, sum1);
if (s[b] != c) {
b++;
l++;
sum1--;
} else if (s[b] == c) {
b++;
sum1--;
}
if (b == n) {
printf("%d\n", sum);
return;
}
}
}
printf("%d\n", sum);
}
}
int main() {
while (~scanf("%d", &n)) {
cin >> s;
n = s.size();
scanf("%d", &t);
for (int i = 0; i < t; i++) {
scanf("%d %c", &l, &c);
solve();
}
}
}
|
#include <bits/stdc++.h>
typedef int pInt[200000];
using namespace std;
int n;
int const N = 2e5;
int mn[26][1501];
string s;
void solv() {
for (char x = 'a'; x <= 'z'; x++) {
for (int i = 0; i < n; ++i) {
int cnt = 0;
for (int j = i; j < n; ++j) {
if (s[j] != x) cnt++;
mn[x - 'a'][cnt] = max(j - i + 1, mn[x - 'a'][cnt]);
}
}
}
for (char x = 'a'; x <= 'z'; x++) {
for (int i = 1; i <= n; ++i) {
mn[x - 'a'][i] = max(mn[x - 'a'][i], mn[x - 'a'][i - 1]);
}
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
cin >> s;
solv();
int q;
cin >> q;
while (q--) {
int x;
char y;
cin >> x >> y;
cout << mn[y - 'a'][x] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int mod = 10000;
const int N = 1005;
char s[1600];
int main() {
int n;
cin >> n;
scanf("%s", s);
int q;
cin >> q;
while (q--) {
int ans = 0;
int m;
char c;
cin >> m >> c;
int i = 0, j = 0;
int temp = m;
while (j < n) {
while (temp) {
if (s[j] != c) temp--;
j++;
if (j == n) break;
}
while (s[j] == c) j++;
ans = max(ans, j - i);
i++;
if (s[i - 1] == c)
temp = 0;
else
temp = 1;
}
printf("%d\n", ans);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.