text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
char s[101010];
int ss[101010];
int lc[101010][26], rc[101010][26];
int lv[101010][26], rv[101010][26];
int vv[101010];
struct abc {
int l, r;
bool tp;
bool operator<(const abc &a) const {
if (r != a.r) return r < a.r;
return l > a.l;
}
abc() {}
abc(int l, int r, bool tp) : l(l), r(r), tp(tp) {}
} a[6060606];
int solve(int l, int r) {
if (l > r) return 0;
bool ap[30];
int ret = 0, cl, cr, now;
for (int i = 0; i <= 26; i++) ap[i] = false;
for (int c = 0; c < 26; c++) {
cl = rc[l][c];
cr = lc[r][c];
if (cl <= cr) {
now = (rv[l][c] ^ vv[cl] ^ vv[cr] ^ lv[r][c]);
if (now < 26) ap[now] = true;
}
}
while (ap[ret]) ret++;
return ret;
}
int main() {
int n, m, an = 0, now, l, r;
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) ss[i] = s[i] - 'a';
for (int i = 0; i < 26; i++) lc[0][i] = 0;
for (int i = 0; i < 26; i++) rc[n + 1][i] = n + 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) lc[i][j] = lc[i - 1][j];
lc[i][ss[i]] = i;
}
for (int i = n; i >= 1; i--) {
for (int j = 0; j < 26; j++) rc[i][j] = rc[i + 1][j];
rc[i][ss[i]] = i;
}
for (int i = 1; i <= n; i++)
for (int j = 0; j < 26; j++) {
if (lc[i][j] != 0) a[++an] = abc(lc[i][j] + 1, i, 0);
if (rc[i][j] != n + 1) a[++an] = abc(i, rc[i][j] - 1, 1);
}
sort(a + 1, a + an + 1);
for (int i = 1; i <= an; i++) {
now = solve(a[i].l, a[i].r);
if (a[i].tp)
rv[a[i].l][ss[a[i].r + 1]] = now;
else
lv[a[i].r][ss[a[i].l - 1]] = now;
if (ss[a[i].l - 1] == ss[a[i].r + 1])
vv[a[i].r + 1] = (vv[a[i].l - 1] ^ now);
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &l, &r);
now = solve(l, r);
if (now)
printf("Alice\n");
else
printf("Bob\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char ch[100005];
int f[100005][27], g[100005];
int nxt[100005][26], lst[100005][26];
int MEX[27];
int n, l, r, len;
int work(int l, int r, int col, int op) {
if (l > r) return 0;
if (MEX[col] >= 0) return MEX[col];
int vis[31];
memset(vis, 0, sizeof(vis));
for (int i = 0; i < 26; ++i) {
int _l = nxt[l][i], _r = lst[r][i];
if (_r >= l) {
int v = g[_r] ^ g[_l] ^ (!op ? f[_l - 1][col] : work(l, _l - 1, i, 1)) ^
(op ? f[r][i] : work(_r + 1, r, i, 0));
vis[v] = 1;
}
}
for (int i = 0; i <= 26; ++i)
if (!vis[i]) {
return MEX[col] = i;
}
}
int main() {
scanf("%s", ch + 1);
len = strlen(ch + 1);
for (int i = 1; i <= len; ++i) {
for (int j = 0; j < 26; ++j) lst[i][j] = lst[i - 1][j];
lst[i][ch[i] - 'a'] = i;
}
for (int j = 0; j < 26; ++j) nxt[len + 1][j] = len + 1;
for (int i = len; i; --i) {
for (int j = 0; j < 26; ++j) nxt[i][j] = nxt[i + 1][j];
nxt[i][ch[i] - 'a'] = i;
}
for (int i = 1; i <= len; ++i) {
g[i] = g[lst[i - 1][ch[i] - 'a']] ^ f[i - 1][ch[i] - 'a'];
memset(MEX, -1, sizeof(MEX));
for (int j = 0; j < 26; ++j) {
f[i][j] = work(lst[i][j] + 1, i, j, 0);
}
}
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &l, &r);
memset(MEX, -1, sizeof(MEX));
puts(work(l, r, 26, 1) != 0 ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:3336777216")
using namespace std;
int IT_MAX = 1 << 19;
const long long MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
const double ERR = 1e-10;
int bit[26][100050];
void update(int x, int p, int v) {
for (; p <= 100000; p += p & (-p)) bit[x][p] ^= v;
}
int getsum(int x, int p) {
int rv = 0;
for (; p; p -= p & (-p)) rv ^= bit[x][p];
return rv;
}
char in[100050];
int nxt[100050][26];
int prv[100050][26];
int dpl[100050][26];
int dpr[100050][26];
vector<pair<int, int> > Vl;
bool mycmp(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first) return a.first > b.first;
return a.second < b.second;
}
vector<int> Vp[26];
bool grchk[30];
int getgr(int S, int E) {
memset(grchk, 0, sizeof(grchk));
int i;
for (i = 0; i < 26; i++) {
if (nxt[S][i] > E) continue;
int p1 = nxt[S][i];
int p2 = prv[E][i];
int gr = dpr[S][i] ^ dpl[E][i];
if (p1 < p2) {
gr ^= getsum(i, p2 - 1);
gr ^= getsum(i, p1 - 1);
}
grchk[gr] = true;
}
for (i = 0;; i++)
if (!grchk[i]) return i;
}
int DEBUG = 0;
int main() {
if (!DEBUG)
scanf("%s", in + 1);
else {
srand(132132);
for (int i = 1; i <= 100000; i++) in[i] = rand() % 26 + 'a';
}
int N = strlen(in + 1), i, j;
for (i = 1; i <= N; i++) {
for (j = 0; j < 26; j++) prv[i][j] = prv[i - 1][j];
prv[i][in[i] - 'a'] = i;
for (j = 0; j < 26; j++) {
if (in[i] - 'a' == j) continue;
if (prv[i][j] == 0) continue;
Vl.emplace_back(prv[i][j] + 1, i);
}
}
for (i = 0; i < 26; i++) nxt[N + 1][i] = N + 1;
for (i = N; i >= 1; i--) {
for (j = 0; j < 26; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][in[i] - 'a'] = i;
for (j = 0; j < 26; j++) {
if (in[i] - 'a' == j) continue;
if (nxt[i][j] == N + 1) continue;
Vl.emplace_back(i, nxt[i][j] - 1);
}
}
for (i = 1; i <= N; i++) Vp[in[i] - 'a'].push_back(i);
for (i = 0; i < 26; i++) {
for (j = 0; j + 1 < Vp[i].size(); j++) {
int t1 = Vp[i][j], t2 = Vp[i][j + 1];
if (t1 + 1 != t2) Vl.emplace_back(t1 + 1, t2 - 1);
}
}
sort((Vl).begin(), (Vl).end(), mycmp);
Vl.erase(unique((Vl).begin(), (Vl).end()), Vl.end());
int cnt = 0;
for (auto it : Vl) {
cnt++;
memset(grchk, 0, sizeof(grchk));
int S = it.first, E = it.second;
i = getgr(S, E);
if (S != 1 && E != N && in[S - 1] == in[E + 1])
update(in[S - 1] - 'a', S - 1, i);
if (E != N && nxt[S][in[E + 1] - 'a'] == E + 1) dpr[S][in[E + 1] - 'a'] = i;
if (S != 1 && prv[E][in[S - 1] - 'a'] == S - 1) dpl[E][in[S - 1] - 'a'] = i;
}
int Q;
if (!DEBUG)
scanf("%d", &Q);
else
Q = 100000;
while (Q--) {
int S, E;
if (!DEBUG)
scanf("%d %d", &S, &E);
else {
S = rand() % 100000 + 1;
E = rand() % 100000 + 1;
if (S > E) swap(S, E);
}
if (!getgr(S, E) && !DEBUG)
printf("Bob\n");
else if (!DEBUG)
printf("Alice\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int n, m, id[N], num[26];
int ql[26][N], qr[26][N], fl[26][N], fr[26][N];
int w[26][N], pos[N], cnt, tot;
char s[N];
struct L {
int len, l, r;
L() {}
L(int LEN, int QL, int QR) {
len = LEN;
l = QL;
r = QR;
}
} le[N * 30];
inline bool cmp(const L& x, const L& y) {
if (x.len != y.len) return x.len < y.len;
if (x.l != y.l) return x.l < y.l;
return x.r < y.r;
}
inline int get(int l, int r) {
int i, j, st, ed, res = 0, nw;
for (i = 0; i < 26; ++i)
if (qr[i][l] <= r) {
nw = 0;
st = qr[i][l];
ed = ql[i][r];
for (j = id[st] + 1; j <= id[ed]; ++j) nw ^= w[i][j];
if (l < st) {
if (fl[i][l] == -1) fl[i][l] = get(l, st - 1);
nw ^= fl[i][l];
}
if (ed < r) {
if (fr[i][r] == -1) fr[i][r] = get(ed + 1, r);
nw ^= fr[i][r];
}
res |= (1 << nw);
}
for (i = 0;; ++i)
if (!((res >> i) & 1)) return i;
}
inline int ask(int l, int r) {
int i, j, st, ed, res = 0, nw;
for (i = 0; i < 26; ++i)
if (qr[i][l] <= r) {
st = qr[i][l];
ed = ql[i][r];
nw = (w[i][id[st]] ^ w[i][id[ed]]);
if (l < st) {
if (fl[i][l] == -1) fl[i][l] = ask(l, st - 1);
nw ^= fl[i][l];
}
if (ed < r) {
if (fr[i][r] == -1) fr[i][r] = ask(ed + 1, r);
nw ^= fr[i][r];
}
res |= (1 << nw);
}
for (i = 0;; ++i)
if (!((res >> i) & 1)) return i;
}
int main() {
int i, j, alp, l, r;
memset(fl, 0xff, sizeof(fl));
memset(fr, 0xff, sizeof(fr));
scanf("%s", s + 1);
n = strlen(s + 1);
for (i = 1; i <= n; ++i) id[i] = ++num[s[i] - 'a'];
for (i = 0; i < 26; ++i) ql[i][0] = 0, qr[i][n + 1] = n + 1;
for (i = 1; i <= n; ++i) {
for (j = 0; j < 26; ++j) ql[j][i] = ql[j][i - 1];
ql[s[i] - 'a'][i] = i;
}
for (i = n; i; --i) {
for (j = 0; j < 26; ++j) qr[j][i] = qr[j][i + 1];
qr[s[i] - 'a'][i] = i;
}
for (i = 0; i < 26; ++i) {
for (cnt = 0, j = 1; j <= n; ++j)
if (s[j] - 'a' == i) pos[++cnt] = j;
for (j = 1; j < cnt; ++j)
le[++tot] = L(pos[j + 1] - pos[j] - 1, pos[j], pos[j + 1]);
}
sort(le + 1, le + tot + 1, cmp);
for (i = 1; i <= tot; ++i)
if (le[i].r > le[i].l + 1) {
j = le[i].r;
w[s[j] - 'a'][id[j]] = get(le[i].l + 1, j - 1);
}
for (i = 0; i < 26; ++i)
for (j = 2; j <= num[i]; ++j) w[i][j] ^= w[i][j - 1];
scanf("%d", &m);
for (; m; --m) {
scanf("%d%d", &l, &r);
puts(ask(l, r) ? "Alice" : "Bob");
}
}
|
#include <bits/stdc++.h>
const int maxn = 100010;
char s[maxn];
int n, m, nxt[maxn][26], las[maxn][26];
char f[maxn][26], g[maxn], mem[27];
char calc(int l, int r, int c, bool ty) {
if (mem[c] != -1) return mem[c];
int st = 0, t = 0;
for (int d = 0; d < 26; d++) {
int i = nxt[l][d], j = las[r][d];
if (i < r)
st |= 1 << ((ty ? f[l][d] : calc(l, i, d, 0)) ^ g[i] ^ g[j] ^
(ty ? calc(j + 1, r, d, 1) : f[j + 1][c]));
}
while (st >> t & 1) t++;
return mem[c] = t;
}
int main() {
scanf("%s%d", s, &m);
while (s[n]) s[n++] -= 97;
for (int i = 0; i < n; i++)
for (int j = 0; j < 26; j++) las[i + 1][j] = j == s[i] ? i : las[i][j];
for (int i = 26; i--;) nxt[n][i] = n;
for (int i = n, j; i--;) {
j = nxt[i + 1][s[i]];
g[i] = f[i + 1][s[i]] ^ g[j];
for (j = 26; j--;) nxt[i][j] = j == s[i] ? i : nxt[i + 1][j], mem[j] = -1;
for (j = 26; j--;) f[i][j] = calc(i, nxt[i][j], j, 0);
}
while (m--) {
int l, r;
scanf("%d%d", &l, &r);
for (int j = 27; j--;) mem[j] = -1;
puts(calc(l - 1, r, 26, 1) ? "Alice" : "Bob");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int ALPHA = 26;
const int MAX_G = 32;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string foo;
cin >> foo;
int n = (int)foo.size();
vector<int> s(n);
for (int i = 0; i < n; i++) {
s[i] = (int)(foo[i] - 'a');
}
vector<vector<int>> nxt(n + 1, vector<int>(ALPHA));
for (int c = 0; c < ALPHA; c++) {
nxt[n][c] = n;
}
for (int i = n - 1; i >= 0; i--) {
for (int c = 0; c < ALPHA; c++) {
nxt[i][c] = nxt[i + 1][c];
}
nxt[i][s[i]] = i;
}
vector<vector<int>> prv(n + 1, vector<int>(ALPHA));
for (int c = 0; c < ALPHA; c++) {
prv[0][c] = -1;
}
for (int i = 0; i < n; i++) {
for (int c = 0; c < ALPHA; c++) {
prv[i + 1][c] = prv[i][c];
}
prv[i + 1][s[i]] = i;
}
int m;
cin >> m;
vector<int> from(m), to(m);
for (int i = 0; i < m; i++) {
cin >> from[i] >> to[i];
from[i]--;
to[i]--;
}
vector<vector<int>> add(n);
for (int i = 0; i < m; i++) {
add[from[i]].push_back(to[i]);
for (int c = 0; c < ALPHA; c++) {
int j = prv[to[i] + 1][c];
if (j < to[i] && j >= from[i]) {
add[j + 1].push_back(to[i]);
}
}
}
vector<vector<int>> rs(n);
vector<vector<int>> dp(n);
auto get_dp = [&](int i, int j) {
if (i > j) {
return 0;
}
auto it = lower_bound(rs[i].begin(), rs[i].end(), j);
assert(!(it == rs[i].end() || *it != j));
int pos = (int)(it - rs[i].begin());
return dp[i][pos];
};
vector<vector<int>> get_dp_to(n + 1, vector<int>(ALPHA));
vector<vector<int>> get_dp_from(n + 1, vector<int>(ALPHA));
vector<int> xorval(n + 1, 0);
vector<int> touched(MAX_G, 0);
int iter = 0;
for (int i = n - 1; i >= 0; i--) {
if (i < n - 1) {
int j = nxt[i + 1][s[i]];
xorval[i] = xorval[j] ^ get_dp(i + 1, j - 1);
}
for (int c = 0; c < ALPHA; c++) {
if (nxt[i][c] != n && nxt[i][c] != i) {
rs[i].push_back(nxt[i][c] - 1);
}
}
rs[i].push_back(n - 1);
for (int j : add[i]) {
rs[i].push_back(j);
}
sort(rs[i].begin(), rs[i].end());
rs[i].resize(unique(rs[i].begin(), rs[i].end()) - rs[i].begin());
dp[i].resize(rs[i].size());
for (int jt = 0; jt < (int)rs[i].size(); jt++) {
int j = rs[i][jt];
iter++;
for (int c = 0; c < ALPHA; c++) {
if (nxt[i][c] > j) {
continue;
}
int A = nxt[i][c];
int B = prv[j + 1][c];
int cur = 0;
if (A > i) {
cur ^= get_dp_to[i][c];
}
if (B < j) {
cur ^= get_dp_from[j][c];
}
cur ^= xorval[A] ^ xorval[B];
touched[cur] = iter;
}
int &res = dp[i][jt];
res = 0;
while (touched[res] == iter) {
res++;
}
if (j < n - 1) {
if (nxt[i][s[j + 1]] == j + 1) {
get_dp_to[i][s[j + 1]] = res;
}
}
if (i > 0) {
if (prv[j + 1][s[i - 1]] == i - 1) {
get_dp_from[j][s[i - 1]] = res;
}
}
}
}
for (int i = 0; i < m; i++) {
int x = get_dp(from[i], to[i]);
cout << (x > 0 ? "Alice" : "Bob") << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
inline long long rd() {
long long _x = 0;
int _ch = getchar(), _f = 1;
for (; !isdigit(_ch) && (_ch != '-') && (_ch != EOF); _ch = getchar())
;
if (_ch == '-') {
_f = 0;
_ch = getchar();
}
for (; isdigit(_ch); _ch = getchar()) _x = _x * 10 + _ch - '0';
return _f ? _x : -_x;
}
void write(long long _x) {
if (_x >= 10)
write(_x / 10), putchar(_x % 10 + '0');
else
putchar(_x + '0');
}
inline void wrt(long long _x, char _p) {
if (_x < 0) putchar('-'), _x = -_x;
write(_x);
if (_p) putchar(_p);
}
struct hashmp {
int hd[30000001];
int nx[5000005];
long long val1[5000005];
int val2[5000005];
int cnt;
int query(long long x) {
int v = x % 30000001;
for (int i = hd[v]; i; i = nx[i]) {
if (val1[i] == x) return val2[i];
}
return -1;
}
int insert(long long x, int a) {
int v = x % 30000001;
nx[++cnt] = hd[v];
hd[v] = cnt;
val1[cnt] = x;
val2[cnt] = a;
return a;
}
} mp;
char s[100005];
int n, m;
int S[26][100005], mx[26];
int pos[26][100005], idx[26][100005], la[26], total[26];
inline long long id(int x, int y) { return 1ll * x * (n + 1) + y; }
int C1, C2;
int DP(int l, int r) {
C1++;
if (l > r) return 0;
int v = mp.query(id(l, r));
if (v != -1) return v;
C2++;
unsigned int vis = 0;
for (int i = 0; i < 26; i++) {
int L = pos[i][l - 1] + 1, R = pos[i][r];
if (L > R) continue;
while (mx[i] < R) {
mx[i]++;
S[i][mx[i]] =
S[i][mx[i] - 1] ^ DP(idx[i][mx[i] - 1] + 1, idx[i][mx[i]] - 1);
}
int res = S[i][R] ^ S[i][L];
res ^= DP(l, idx[i][L] - 1) ^ DP(idx[i][R] + 1, r);
vis |= 1 << res;
}
return mp.insert(id(l, r), __builtin_ctz(~vis));
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
int x = s[i] - 'a';
total[x]++, la[x] = i;
pos[x][i] = total[x];
idx[x][total[x]] = i;
for (int j = 0; j < 26; j++) {
pos[j][i] = pos[j][la[j]];
}
}
m = rd();
for (int i = 1; i <= m; i++) {
int l = rd(), r = rd();
bool flag = DP(l, r);
if (flag)
printf("Alice\n");
else
printf("Bob\n");
}
}
|
#include <bits/stdc++.h>
using std::cin;
using std::cout;
const int maxn = 100100;
char s[maxn];
int next[maxn][26], prev[maxn][26], n;
int next_sg[maxn][26], prev_sg[maxn][26];
int pre[maxn][26];
inline int calc(int l, int r);
inline int prv_sg(int r, int c) {
if (~prev_sg[r][c]) return prev_sg[r][c];
return prev_sg[r][c] = calc(prev[r][c] + 1, r);
}
inline int nxt_sg(int r, int c) {
if (~next_sg[r][c]) return next_sg[r][c];
return next_sg[r][c] = calc(r, next[r][c] - 1);
}
inline int pre_sum(int r, int c) {
if (r == 0) return 0;
if (~pre[r][c]) return pre[r][c];
return pre[r][c] =
pre_sum(prev[r - 1][c], c) ^ calc(prev[r - 1][c] + 1, r - 1);
}
inline int calc(int l, int r) {
if (l > r) return 0;
int w = -1;
for (int i = 0; i < 26; ++i)
if (next[l][i] <= r) {
int sg = prv_sg(r, i) ^ nxt_sg(l, i) ^ pre_sum(prev[r][i], i) ^
pre_sum(next[l][i], i);
w &= ~(1 << sg);
}
return __builtin_ctz(w);
}
int main() {
std::ios::sync_with_stdio(false), cin.tie(0);
cin >> s + 1, n = strlen(s + 1);
for (int i = 1; i <= n + 1; ++i) {
for (int j = 0; j < 26; ++j) prev[i][j] = prev[i - 1][j];
if (i != n + 1) prev[i][s[i] - 'a'] = i;
}
for (int i = 0; i < 26; ++i) next[n + 1][i] = n + 1;
for (int i = n; i >= 0; --i) {
for (int j = 0; j < 26; ++j) next[i][j] = next[i + 1][j];
if (i) next[i][s[i] - 'a'] = i;
}
memset(next_sg, -1, sizeof next_sg);
memset(prev_sg, -1, sizeof prev_sg);
memset(pre, -1, sizeof pre);
int q;
cin >> q;
for (int i = 0, l, r; i < q; ++i) {
cin >> l >> r;
cout << (calc(l, r) ? "Alice" : "Bob") << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
char ch[100010];
int n, a[100010], pre[100010][26], suf[100010][26];
int f[100010][26], g[100010], mem[27];
int mex(int sta) { return __builtin_ctz(~sta); }
int calc(int l, int r, int c, int flag) {
if (l > r) {
return 0;
}
if (~mem[c]) {
return mem[c];
}
int sta = 0;
for (int j = 0; j < 26; j++) {
int dx = suf[l][j], dy = pre[r][j];
if (dy >= l) {
sta |=
1 << (g[dy] ^ g[dx] ^ (!flag ? f[dx - 1][c] : calc(l, dx - 1, j, 1)) ^
(flag ? f[r][j] : calc(dy + 1, r, j, 0)));
}
}
return mem[c] = mex(sta);
}
int main() {
scanf("%s", ch + 1);
n = strlen(ch + 1);
for (int i = 1; i <= n; i++) {
a[i] = ch[i] - 'a';
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) {
pre[i][j] = pre[i - 1][j];
}
pre[i][a[i]] = i;
}
for (int j = 0; j < 26; j++) {
suf[n + 1][j] = n + 1;
}
for (int i = n; i >= 1; i--) {
for (int j = 0; j < 26; j++) {
suf[i][j] = suf[i + 1][j];
}
suf[i][a[i]] = i;
}
for (int i = 1; i <= n; i++) {
g[i] = f[i - 1][a[i]] ^ g[pre[i - 1][a[i]]];
memset(mem, -1, sizeof(mem));
for (int j = 0; j < 26; j++) {
f[i][j] = calc(pre[i][j] + 1, i, j, 0);
}
}
int q;
cin >> q;
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d%d", &l, &r);
memset(mem, -1, sizeof(mem));
if (calc(l, r, 26, 1)) {
cout << "Alice\n";
} else {
cout << "Bob\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxN = 1e5, A = 26;
string s;
int n, m, lc[A], pos[A][mxN], prv[mxN][A], nxt[mxN][A], dpp[A][mxN],
dps[A][mxN], pdp[A][mxN];
vector<int> tp[mxN];
int cdp(int l, int r) {
if (l >= r) return l == r;
vector<int> gs;
for (int i = 0; i < A; ++i) {
int a = nxt[l][i], b = prv[r][i];
if (a > b) continue;
gs.push_back(dps[i][l] ^ pdp[i][b] ^ pdp[i][a] ^ dpp[i][r]);
}
sort(gs.begin(), gs.end());
gs.resize(unique(gs.begin(), gs.end()) - gs.begin());
for (int i = 0;; ++i)
if (i >= gs.size() || gs[i] != i) {
return i;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s >> m;
n = s.size();
for (int i = 0; i < n; ++i) {
int c = s[i] - 'a';
for (int j = 0; j < A; ++j)
prv[i][j] = j == c ? lc[c] : (i ? prv[i - 1][j] : -1);
pos[c][lc[c]++] = i;
}
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < A; ++j)
nxt[i][j] = s[i] - 'a' == j ? prv[i][j] : (i < n - 1 ? nxt[i + 1][j] : n);
for (int j = i + 1; j < n && s[j] != s[i]; ++j) tp[j].push_back(i + 1);
}
for (int i = 1; i < n; ++i) {
int j1 = i - 1, j2 = 0, c = s[i] - 'a', a = prv[i - 1][c],
b = a >= 0 ? pos[c][a] : -1;
while (j1 >= b || j2 < tp[i - 1].size()) {
if (j1 == b && j1 >= 0) {
pdp[c][a + 1] = pdp[c][a] ^ dps[c][j1 + 1];
}
if (j1 > b) dps[c][j1] = cdp(j1, i - 1);
if (j2 < tp[i - 1].size() && (j1 == tp[i - 1][j2] || j1 <= b)) {
dpp[s[tp[i - 1][j2] - 1] - 'a'][i - 1] = cdp(tp[i - 1][j2], i - 1);
++j2;
}
--j1;
}
}
for (int a : tp[n - 1]) dpp[s[a - 1] - 'a'][n - 1] = cdp(a, n - 1);
while (m--) {
int l, r;
cin >> l >> r, --l, --r;
cout << (cdp(l, r) ? "Alice" : "Bob") << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
char S[N];
int A[N], n;
int posr[N][26], posl[N][26];
int pre[N][26], suf[N][26], Xor[N];
int calc(int l, int r) {
int mask = 0;
for (int j = 0; j <= 25; j++)
if (posr[l][j] <= r) {
int w = Xor[posl[r][j]] ^ Xor[posr[l][j]] ^ suf[l][j] ^ pre[r][j];
mask |= 1 << w;
}
for (int i = 0; i <= 26; i++)
if (!(mask & (1 << i))) return i;
assert(false);
return 0;
}
pair<int, int> seg[N + 50];
int main() {
scanf("%s", S + 1);
n = strlen(S + 1);
for (int i = 1; i <= n; i++) A[i] = S[i] - 'a';
for (int i = 1; i <= n; i++)
for (int j = 0; j <= 25; j++) posl[i][j] = A[i] == j ? i : posl[i - 1][j];
for (int j = 0; j <= 25; j++) posr[n + 1][j] = n + 1;
for (int i = n; i >= 1; i--)
for (int j = 0; j <= 25; j++) posr[i][j] = A[i] == j ? i : posr[i + 1][j];
for (int i = 1; i <= n; i++) {
int c = 0;
Xor[i] = Xor[posl[i - 1][A[i]]] ^ pre[i - 1][A[i]];
for (int j = 0; j <= 25; j++)
if (posl[i][j] != i && posl[i][j])
seg[++c] = pair<int, int>(posl[i][j] + 1, 0);
if (i != n) {
int L = posl[i][A[i + 1]];
for (int j = L + 1; j <= i; j++) seg[++c] = pair<int, int>(j, 1);
}
sort(seg + 1, seg + c + 1, greater<pair<int, int> >());
for (int j = 1; j <= c; j++) {
int w = calc(seg[j].first, i);
if (seg[j].second)
suf[seg[j].first][A[i + 1]] = w;
else
pre[i][A[seg[j].first - 1]] = w;
}
}
int q;
scanf("%d", &q);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
puts(calc(l, r) ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 77, ALPHA = 27;
char S[N];
int n, q, dpL[N][ALPHA], dpR[N][ALPHA], Px[N][ALPHA];
int Le[N][ALPHA], Ri[N][ALPHA];
int T[ALPHA];
bool M[ALPHA];
inline int GetMex(vector<int>& V) {
for (int& x : V) M[x] = 1;
int ans = 0;
while (M[ans]) ++ans;
for (int& x : V) M[x] = 0;
return ans;
}
int main() {
scanf("%s", S + 1);
n = strlen(S + 1);
fill(T, T + ALPHA, n + 1);
for (int i = n + 1; i >= 0; --i) {
if (i <= n && i > 0) T[S[i] - 'a'] = i;
for (int j = 0; j < ALPHA; ++j) Ri[i][j] = T[j];
}
memset(T, 0, sizeof T);
for (int i = 0; i <= n + 1; ++i) {
if (i >= 1 && i <= n) T[S[i] - 'a'] = i;
for (int j = 0; j < ALPHA; ++j) Le[i][j] = T[j];
}
vector<int> V;
vector<pair<int, int> > X;
for (int i = n; i > 0; --i) {
X.clear();
for (int j = 0; j < ALPHA; ++j) {
int le = i;
int ri = Ri[i][j];
X.push_back(make_pair(ri, j));
}
sort(X.begin(), X.end());
for (auto x : X) {
int j = x.second, ri = x.first, le = i;
V.clear();
for (int k = 0; k < ALPHA; ++k) {
if (Ri[i][k] >= ri) continue;
int nw = dpR[le][k] ^ Px[Ri[le][k] + 1][k] ^ Px[Le[ri][k] + 1][k] ^
dpR[Le[ri][k] + 1][j];
V.push_back(nw);
}
dpR[i][j] = GetMex(V);
}
for (int j = 0; j < ALPHA; ++j) Px[i][j] = Px[Ri[i][j] + 1][j] ^ dpR[i][j];
}
memset(Px, 0, sizeof Px);
for (int i = 1; i <= n; ++i) {
X.clear();
for (int j = 0; j < ALPHA; ++j) {
int ri = i;
int le = Le[i][j];
X.push_back(make_pair(-le, j));
}
sort(X.begin(), X.end());
for (auto x : X) {
int j = x.second, ri = i, le = -x.first;
V.clear();
for (int k = 0; k < ALPHA; ++k) {
if (Le[i][k] <= le) continue;
int nw = dpL[ri][k] ^ Px[Le[ri][k] - 1][k] ^ Px[Ri[le][k] - 1][k] ^
dpL[Ri[le][k] - 1][j];
V.push_back(nw);
}
dpL[i][j] = GetMex(V);
}
for (int j = 0; j < ALPHA; ++j) {
if (Le[i][j] == 0)
Px[i][j] = dpL[i][j];
else
Px[i][j] = Px[Le[i][j] - 1][j] ^ dpL[i][j];
}
}
scanf("%d", &q);
while (q--) {
V.clear();
int le, ri;
scanf("%d %d", &le, &ri);
--le;
for (int k = 0; k < ALPHA; ++k) {
if (Le[ri][k] <= le) continue;
int nw = Px[ri][k] ^ Px[Ri[le + 1][k] - 1][k] ^ dpR[le + 1][k];
V.push_back(nw);
}
if (GetMex(V) == 0)
printf("Bob\n");
else
printf("Alice\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100010];
struct data {
int l, r, c;
};
bool operator<(data a, data b) {
if (a.r == b.r)
return a.l > b.l;
else
return a.r < b.r;
}
data A[5500000];
map<int, int> id[100010];
vector<int> posi[30];
int cur[30], tot, pre[100010][30], nxt[100010][30], used[30], pre_sg[100010], n,
sg[5500000];
int tl[100010][30], tr[100010][30];
int read() {
int tmp = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
tmp = tmp * 10 + c - '0';
c = getchar();
}
return tmp;
}
void solve() {
for (int i = 1; i <= n; i++)
for (int j = 0; j <= 25; j++) {
if (id[i].find(nxt[i][j] - 1) != id[i].end())
tl[i][j] = id[i][nxt[i][j] - 1];
int tmp = pre[i][j] + 1;
if (id[tmp].find(i) != id[tmp].end()) tr[i][j] = id[tmp][i];
}
for (int i = 1; i <= tot; i++) {
if (A[i].l <= A[i].r) {
memset(used, 0, sizeof(used));
for (int j = 0; j <= 25; j++) {
int t1 = nxt[A[i].l][j], t2 = pre[A[i].r][j], tmp;
if (t1 > A[i].r) continue;
tmp = sg[tl[A[i].l][j]] ^ sg[tr[A[i].r][j]];
tmp ^= pre_sg[t2] ^ pre_sg[t1];
used[tmp] = 1;
}
for (int j = 0; j <= 29; j++)
if (used[j] == 0) {
sg[i] = j;
if (A[i].l != 1 && A[i].r != n)
pre_sg[A[i].r + 1] = pre_sg[A[i].l - 1] ^ j;
if (A[i].l == 1) pre_sg[A[i].r + 1] = j;
break;
}
}
if (i == tot || A[i].r != A[i + 1].r) {
int tmp = A[i].r + 1;
pre_sg[tmp] =
pre_sg[pre[tmp - 1][s[tmp] - 'a']] ^ sg[tr[tmp - 1][s[tmp] - 'a']];
}
}
}
int query(int l, int r) {
memset(used, 0, sizeof(used));
for (int i = 0; i <= 25; i++) {
int t1 = nxt[l][i], t2 = pre[r][i];
if (t1 > r) continue;
int tmp = pre_sg[t2] ^ pre_sg[t1];
if (s[l] - 'a' != i) tmp ^= sg[tl[l][i]];
if (s[r] - 'a' != i) tmp ^= sg[tr[r][i]];
used[tmp] = 1;
}
for (int i = 0; i <= 29; i++)
if (used[i] == 0) return i;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) posi[s[i] - 'a'].push_back(i);
for (int i = 0; i <= 25; i++) {
int len = posi[i].size();
if (len == 0)
for (int j = 1; j <= n; j++) pre[j][i] = 0, nxt[j][i] = n + 1;
else {
for (int j = 1; j <= posi[i][0] - 1; j++)
pre[j][i] = 0, nxt[j][i] = posi[i][0];
for (int j = posi[i][len - 1] + 1; j <= n; j++)
pre[j][i] = posi[i][len - 1], nxt[j][i] = n + 1;
for (int j = 0; j <= len - 2; j++)
for (int k = posi[i][j] + 1; k <= posi[i][j + 1] - 1; k++)
pre[k][i] = posi[i][j], nxt[k][i] = posi[i][j + 1];
for (int j = 0; j <= len - 1; j++)
pre[posi[i][j]][i] = nxt[posi[i][j]][i] = posi[i][j];
}
}
for (int i = 1; i <= n; i++)
for (int j = 0; j <= 25; j++) {
A[++tot] = (data){i, nxt[i][j] - 1, j};
A[++tot] = (data){pre[i][j] + 1, i, j};
}
sort(A + 1, A + tot + 1);
int top = 1;
for (int i = 2; i <= tot; i++)
if (A[i].l != A[top].l || A[i].r != A[top].r) A[++top] = A[i];
tot = top;
for (int i = 1; i <= tot; i++) id[A[i].l][A[i].r] = i;
solve();
int q = read();
for (int i = 1; i <= q; i++) {
int l = read(), r = read();
if (query(l, r) == 0)
puts("Bob");
else
puts("Alice");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100050;
int n, q;
char str[maxn];
int pre[26][maxn], suf[26][maxn];
int arr[26][maxn], ar[26][maxn];
int Pf[26][maxn], Sf[26][maxn];
int solve(int, int, int);
int hd(int k, int l, int r, int dep) {
if (ar[k][l])
return Sf[k][l];
else {
ar[k][l] = 1, Sf[k][l] = solve(l, r, dep + 1);
return Sf[k][l];
}
}
int pd(int k, int r, int l, int dep) {
if (arr[k][r])
return Pf[k][r];
else {
arr[k][r] = 1, Pf[k][r] = solve(l, r, dep + 1);
return Pf[k][r];
}
}
int app[maxn][28];
int solve(int l, int r, int dep) {
if (l > r) return 0;
if (l == r) return 1;
for (int k = 0; k <= 26; k++) app[dep][k] = 0;
for (int k = 0; k < 26; k++) {
int pv = suf[k][l], sv = pre[k][r];
if (pv > r || sv < l || pv == -1 || sv == -1) continue;
int ans = Pf[k][sv] ^ Pf[k][pv];
if (pre[k][r] != r) ans ^= pd(k, r, sv + 1, dep);
if (suf[k][l] != l) ans ^= hd(k, l, pv - 1, dep);
app[dep][ans] = 1;
}
for (int i = 0; i <= 26; i++)
if (app[dep][i] == 0) return i;
}
void init() {
for (int i = 0; i < n; i++) {
if (i - 1 >= 0 && pre[str[i] - 'a'][i - 1] != -1) {
int k = str[i] - 'a';
if (pre[k][i - 1] + 1 > i - 1)
Pf[k][i] = Pf[k][pre[k][i - 1]];
else
Pf[k][i] = Pf[k][pre[k][i - 1]] ^ Pf[k][i - 1];
arr[k][i] = 1;
}
for (int k = 0; k < 26; k++) {
if (pre[k][i] == -1) continue;
if (arr[k][i]) continue;
if (pre[k][i] != i) Pf[k][i] = solve(pre[k][i] + 1, i, 0);
arr[k][i] = 1;
}
}
for (int i = n - 1; i >= 0; i--) {
if (i + 1 < n && suf[str[i] - 'a'][i + 1] != -1) {
int k = str[i] - 'a';
if (i + 1 > suf[k][i + 1] - 1)
Sf[k][i] = Sf[k][suf[k][i + 1]];
else
Sf[k][i] = Sf[k][suf[k][i + 1]] ^ Sf[k][i + 1];
ar[k][i] = 1;
}
for (int k = 0; k < 26; k++) {
if (suf[k][i] == -1) continue;
if (ar[k][i]) continue;
if (suf[k][i] != i) Sf[k][i] = solve(i, suf[k][i] - 1, 0);
ar[k][i] = 1;
}
}
}
void read() {
scanf("%s", str);
scanf("%d", &q);
n = strlen(str);
for (int k = 0; k < 26; k++) {
for (int i = 0; i < n; i++) pre[k][i] = suf[k][i] = -1;
}
for (int i = 0; i < n; i++)
pre[str[i] - 'a'][i] = i, suf[str[i] - 'a'][i] = i;
for (int k = 0; k < 26; k++) {
for (int i = 1; i < n; i++)
if (pre[k][i] == -1) pre[k][i] = pre[k][i - 1];
for (int i = n - 2; i >= 0; i--)
if (suf[k][i] == -1) suf[k][i] = suf[k][i + 1];
}
}
void work() {
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d%d", &l, &r);
int flag = solve(l - 1, r - 1, 0);
if (flag)
puts("Alice");
else
puts("Bob");
}
}
int main() {
read();
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
char s[N];
int pl[N][26], pr[N][26], n;
int pre[N][26], suf[N][26], Xor[N];
int calc(int l, int r) {
int msk = 0;
for (int j = (int)(0); j <= (int)(25); j++)
if (pr[l][j] <= r) {
int w = Xor[pl[r][j]] ^ Xor[pr[l][j]] ^ suf[l][j] ^ pre[r][j];
msk |= (1 << w);
}
for (int j = (int)(0); j <= (int)(26); j++)
if (!(msk & (1 << j))) return j;
}
pair<int, int> seg[55 + N];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = (int)(1); i <= (int)(n); i++) s[i] -= 'a';
for (int i = (int)(1); i <= (int)(n); i++)
for (int j = (int)(0); j <= (int)(25); j++)
pl[i][j] = (s[i] == j ? i : pl[i - 1][j]);
for (int j = (int)(0); j <= (int)(25); j++) pr[n + 1][j] = n + 1;
for (int i = (int)(n); i >= (int)(1); i--)
for (int j = (int)(0); j <= (int)(25); j++)
pr[i][j] = (s[i] == j ? i : pr[i + 1][j]);
for (int i = (int)(1); i <= (int)(n); i++) {
int cnt = 0;
Xor[i] = Xor[pl[i - 1][s[i]]] ^ pre[i - 1][s[i]];
for (int j = (int)(0); j <= (int)(25); j++)
if (pl[i][j] != i && pl[i][j])
seg[++cnt] = pair<int, int>(pl[i][j] + 1, 0);
if (i != n) {
int L = pl[i][s[i + 1]];
for (int j = (int)(L + 1); j <= (int)(i); j++)
seg[++cnt] = pair<int, int>(j, 1);
}
sort(seg + 1, seg + cnt + 1, greater<pair<int, int> >());
for (int j = (int)(1); j <= (int)(cnt); j++) {
int w = calc(seg[j].first, i);
if (seg[j].second)
suf[seg[j].first][s[i + 1]] = w;
else
pre[i][s[seg[j].first - 1]] = w;
}
}
int Q;
scanf("%d", &Q);
while (Q--) {
int l, r;
scanf("%d%d", &l, &r);
puts(calc(l, r) ? "Alice" : "Bob");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, l, r, i, j, f[2][N][26], p[2][N][26];
char c[N];
int bi[26][N];
inline void mdy(int o, int x, int v) {
if (o == 3) ++o, --o;
for (; x <= n; x += x & -x) bi[o][x] ^= v;
}
inline int ask(int o, int x) {
int ans = 0;
for (; x; x -= x & -x) ans ^= bi[o][x];
return ans;
}
struct node {
int l, r, o, c;
} a[N * 55];
int xb;
inline int query(int l, int r) {
if (l + 1 == r) return 0;
static int buc[28];
memset(buc, 0, sizeof buc);
int y, z, i;
for (i = 0; i < 26; ++i)
if (y = p[1][l][i], y && y < r)
z = p[0][r][i],
++buc[f[1][l][i] ^ f[0][r][i] ^ (y == z ? 0 : ask(i, z) ^ ask(i, y))];
for (i = 0; buc[i]; ++i)
;
return i;
}
int main() {
scanf("%s%d", c + 1, &m);
n = strlen(c + 1);
for (i = 2; i <= n + 1; ++i) {
memcpy(p[0][i], p[0][i - 1], 104), p[0][i][c[i - 1] - 'a'] = i - 1;
for (j = 0; j < 26; ++j)
if (p[0][i][j]) a[++xb] = (node){p[0][i][j], i, 0, j};
}
for (i = n - 1; i >= 0; --i) {
memcpy(p[1][i], p[1][i + 1], 104), p[1][i][c[i + 1] - 'a'] = i + 1;
for (j = 0; j < 26; ++j)
if (p[1][i][j]) a[++xb] = (node){i, p[1][i][j], 1, j};
}
sort(a + 1, a + xb + 1,
[&](const node& a, const node& b) { return a.r - a.l < b.r - b.l; });
memset(f, -1, sizeof f);
for (i = 1; i <= xb; ++i) {
if (1 <= a[i].l && a[i].r <= n && c[a[i].l] == c[a[i].r]) {
int &x = f[1][a[i].l][a[i].c], &y = f[0][a[i].r][a[i].c];
if (x != -1) {
y = x;
continue;
}
if (y != -1) {
x = y;
continue;
}
}
int& v = a[i].o == 1 ? f[1][a[i].l][a[i].c] : f[0][a[i].r][a[i].c];
v = query(a[i].l, a[i].r);
if (1 <= a[i].l && a[i].r <= n && c[a[i].l] == c[a[i].r])
mdy(c[a[i].l] - 'a', a[i].r, v);
}
for (; m--;)
scanf("%d%d", &l, &r), puts(query(l - 1, r + 1) ? "Alice" : "Bob");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100500;
int n, m, l, r, pre[maxn][30], suc[maxn][30], f[maxn][30], a[maxn], g[maxn],
sg[30];
char s[maxn];
int calc(int l, int r, int c, int op) {
if (l > r) return 0;
if (~sg[c]) return sg[c];
int now = 0;
for (int j = 0; j <= 25; j++) {
int le = suc[l][j], ri = pre[r][j];
if (ri >= l)
now |=
1 << (g[ri] ^ g[le] ^ (!op ? f[le - 1][c] : calc(l, le - 1, j, op)) ^
(!op ? calc(ri + 1, r, j, op) : f[r][j]));
}
return sg[c] = __builtin_ctz(~now);
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) a[i] = s[i] - 'a';
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 25; j++) {
if (j == a[i])
pre[i][j] = i;
else
pre[i][j] = pre[i - 1][j];
}
}
for (int i = 0; i <= 25; i++) suc[n + 1][i] = n + 1;
for (int i = n; i >= 1; i--) {
for (int j = 0; j <= 25; j++) {
if (j == a[i])
suc[i][j] = i;
else
suc[i][j] = suc[i + 1][j];
}
}
for (int i = 1; i <= n; i++) {
g[i] = f[i - 1][a[i]] ^ g[pre[i - 1][a[i]]];
memset(sg, -1, sizeof(sg));
for (int j = 0; j <= 25; j++) f[i][j] = calc(pre[i][j] + 1, i, j, 0);
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d%d", &l, &r);
memset(sg, -1, sizeof(sg));
if (calc(l, r, 26, 1))
puts("Alice");
else
puts("Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int ALPHA = 26;
const int MAX_G = 32;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string foo;
cin >> foo;
int n = (int)foo.size();
vector<int> s(n);
for (int i = 0; i < n; i++) {
s[i] = (int)(foo[i] - 'a');
}
vector<vector<int>> nxt(n + 1, vector<int>(ALPHA));
for (int c = 0; c < ALPHA; c++) {
nxt[n][c] = n;
}
for (int i = n - 1; i >= 0; i--) {
for (int c = 0; c < ALPHA; c++) {
nxt[i][c] = nxt[i + 1][c];
}
nxt[i][s[i]] = i;
}
vector<vector<int>> prv(n + 1, vector<int>(ALPHA));
for (int c = 0; c < ALPHA; c++) {
prv[0][c] = -1;
}
for (int i = 0; i < n; i++) {
for (int c = 0; c < ALPHA; c++) {
prv[i + 1][c] = prv[i][c];
}
prv[i + 1][s[i]] = i;
}
int m;
cin >> m;
vector<int> from(m), to(m);
for (int i = 0; i < m; i++) {
cin >> from[i] >> to[i];
from[i]--;
to[i]--;
}
vector<vector<int>> add(n);
for (int i = 0; i < m; i++) {
add[from[i]].push_back(to[i]);
for (int c = 0; c < ALPHA; c++) {
int j = prv[to[i] + 1][c];
if (j < to[i] && j >= from[i]) {
add[j + 1].push_back(to[i]);
}
}
}
vector<vector<int>> rs(n);
vector<vector<int>> dp(n);
auto get_dp = [&](int i, int j) {
if (i > j) {
return 0;
}
auto it = lower_bound(rs[i].begin(), rs[i].end(), j);
assert(!(it == rs[i].end() || *it != j));
int pos = (int)(it - rs[i].begin());
return dp[i][pos];
};
vector<int> xorval(n + 1, 0);
vector<int> touched(MAX_G, 0);
int iter = 0;
for (int i = n - 1; i >= 0; i--) {
if (i < n - 1) {
int j = nxt[i + 1][s[i]];
xorval[i] = xorval[j] ^ get_dp(i + 1, j - 1);
}
for (int c = 0; c < ALPHA; c++) {
if (nxt[i][c] != n && nxt[i][c] != i) {
rs[i].push_back(nxt[i][c] - 1);
}
}
rs[i].push_back(n - 1);
for (int j : add[i]) {
rs[i].push_back(j);
}
sort(rs[i].begin(), rs[i].end());
rs[i].resize(unique(rs[i].begin(), rs[i].end()) - rs[i].begin());
dp[i].resize(rs[i].size());
for (int jt = 0; jt < (int)rs[i].size(); jt++) {
int j = rs[i][jt];
iter++;
for (int c = 0; c < ALPHA; c++) {
if (nxt[i][c] > j) {
continue;
}
int A = nxt[i][c];
int B = prv[j + 1][c];
int cur = 0;
if (A > i) {
cur ^= get_dp(i, A - 1);
}
if (B < j) {
cur ^= get_dp(B + 1, j);
}
cur ^= xorval[A] ^ xorval[B];
touched[cur] = iter;
}
int &res = dp[i][jt];
res = 0;
while (touched[res] == iter) {
res++;
}
}
}
for (int i = 0; i < m; i++) {
int x = get_dp(from[i], to[i]);
cout << (x > 0 ? "Alice" : "Bob") << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct point {
int l, r;
point() {}
point(int ll, int rr) { l = ll, r = rr; }
bool operator<(const point &other) const {
if (l == other.l) return r < other.r;
return l < other.l;
}
};
map<point, int> vist, dp;
int a[200011], Q, len, ans, nxt[200011][26], pre[200011][26], f[200011][26],
g[200011], Map[27];
char s[200011];
int dfs(int l, int r, int c, int op) {
if (l > r) return 0;
if (Map[c] != -1) return Map[c];
int hashh[51] = {0};
for (int i = 0; i < 26; i++) {
int tl = nxt[l - 1][i], tr = pre[r + 1][i];
if (tr < l) continue;
int t = g[tr] ^ g[tl];
if (op)
t ^= f[tl - 1][c];
else
t ^= dfs(l, tl - 1, i, 0);
if (!op)
t ^= f[r][i];
else
t ^= dfs(tr + 1, r, i, 1);
hashh[t] = 1;
}
for (int i = 0; i <= 100; i++) {
if (!hashh[i]) {
Map[c] = i;
return i;
}
}
}
int main() {
int l, r;
scanf("%s", s + 1);
len = strlen(s + 1);
for (int i = 1; i <= len; i++) a[i] = s[i] - 'a';
for (int i = 0; i < 26; i++) nxt[len][i] = len + 1, pre[1][i] = 0;
for (int i = len; i >= 1; i--) {
for (int j = 0; j < 26; j++) nxt[i - 1][j] = nxt[i][j];
nxt[i - 1][a[i]] = i;
}
for (int i = 1; i <= len; i++) {
for (int j = 0; j < 26; j++) pre[i + 1][j] = pre[i][j];
pre[i + 1][a[i]] = i;
}
for (int i = 1; i <= len; i++) {
g[i] = g[pre[i][a[i]]] ^ f[i - 1][a[i]];
memset(Map, -1, sizeof(Map));
for (int j = 0; j < 26; j++) {
f[i][j] = dfs(pre[i + 1][j] + 1, i, j, 1);
}
}
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
scanf("%d%d", &l, &r);
memset(Map, -1, sizeof(Map));
ans = dfs(l, r, 26, 0);
if (ans)
printf("Alice\n");
else
printf("Bob\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[100050];
int pre[100050][26], nxt[100050][26];
int l[26][100050], sl[26][100050];
int r[26][100050], sr[26][100050];
bool ex[26 + 5];
int lst[26], pos[26];
bool cmp(int i, int j) { return lst[i] > lst[j]; }
void calc(const char *s, int n, int dp[26][100050], int sum[26][100050]) {
for (int c = 0; c < 26; ++c) pos[c] = c;
memset(lst, 0, sizeof(lst));
for (int i = n; ~i; --i) {
memcpy(nxt[i], nxt[i + 1], sizeof(nxt[i]));
if (i) nxt[i][s[i] - 'a'] = i;
}
for (int i = 1; i <= n; ++i) {
lst[s[i] - 'a'] = i;
memcpy(pre[i], lst, sizeof(lst));
sort(pos, pos + 26, cmp);
for (int o = 0; o < 26; ++o) {
int c = pos[o], j = lst[c];
if (j == i) continue;
memset(ex, 0, sizeof(ex));
for (int ch = 0; ch < 26; ++ch) {
if (lst[ch] <= j) continue;
int k = lst[ch] - 1, p = nxt[j][ch] - 1;
ex[dp[c][p] ^ sum[ch][p] ^ sum[ch][k] ^ dp[ch][i]] = 1;
}
while (ex[dp[c][i]]) ++dp[c][i];
}
for (int c = 0; c < 26; ++c)
if (lst[c])
sum[c][i] = dp[c][i] ^ sum[c][lst[c] - 1];
else
sum[c][i] = dp[c][i];
}
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
reverse(s + 1, s + n + 1);
calc(s, n, r, sr);
for (int c = 0; c < 26; ++c)
reverse(r[c] + 1, r[c] + n + 1), reverse(sr[c] + 1, sr[c] + n + 1);
reverse(s + 1, s + n + 1);
calc(s, n, l, sl);
scanf("%d", &m);
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
bool flag = 0;
for (int c = 0; c < 26; ++c) {
if (pre[b][c] < a || nxt[a][c] > b) continue;
int i = nxt[a][c] - 1, j = pre[b][c] - 1;
int sg = r[c][a] ^ sl[c][i] ^ sl[c][j] ^ l[c][b];
if (!sg) flag = 1;
}
puts(flag ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int RLEN = 1 << 18 | 1;
inline char nc() {
static char ibuf[RLEN], *ib, *ob;
(ib == ob) && (ob = (ib = ibuf) + fread(ibuf, 1, RLEN, stdin));
return (ib == ob) ? -1 : *ib++;
}
inline int rd() {
char ch = nc();
int i = 0, f = 1;
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = nc();
}
while (isdigit(ch)) {
i = (i << 1) + (i << 3) + ch - '0';
ch = nc();
}
return i * f;
}
const int N = 1e5 + 50;
char ch[N];
int n, a[N], pre[N][26], suf[N][26];
int f[N][26], g[N], mem[27];
inline int mex(int sta) { return __builtin_ctz(~sta); }
inline int calc(int l, int r, int c, int flag) {
if (l > r) return 0;
if (~mem[c]) return mem[c];
int sta = 0;
for (int j = 0; j < 26; ++j) {
int _l = suf[l][j], _r = pre[r][j];
if (_r >= l)
sta |=
1 << (g[_r] ^ g[_l] ^ (!flag ? f[_l - 1][c] : calc(l, _l - 1, j, 1)) ^
(flag ? f[r][j] : calc(_r + 1, r, j, 0)));
}
return mem[c] = mex(sta);
}
int main() {
scanf("%s", ch + 1);
n = strlen(ch + 1);
for (int i = 1; i <= n; i++) a[i] = ch[i] - 'a';
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; ++j) pre[i][j] = pre[i - 1][j];
pre[i][a[i]] = i;
}
for (int j = 0; j < 26; ++j) suf[n + 1][j] = n + 1;
for (int i = n; i >= 1; i--) {
for (int j = 0; j < 26; ++j) suf[i][j] = suf[i + 1][j];
suf[i][a[i]] = i;
}
for (int i = 1; i <= n; i++) {
g[i] = f[i - 1][a[i]] ^ g[pre[i - 1][a[i]]];
memset(mem, -1, sizeof(mem));
for (int j = 0; j < 26; ++j) f[i][j] = calc(pre[i][j] + 1, i, j, 0);
}
int q = rd();
for (int i = 1; i <= q; i++) {
int l = rd(), r = rd();
memset(mem, -1, sizeof(mem));
if (calc(l, r, 26, 1))
puts("Alice");
else
puts("Bob");
}
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100011];
int n;
int nxt[100011][26];
int prv[100011][26];
int lft[100011][26];
int rgt[100011][26];
int xo[100011][26];
inline int ch(char a) { return a - 'a'; }
vector<pair<int, int> > vp;
bool cmp(pair<int, int> u, pair<int, int> v) {
if (u.first == v.first) return u.second < v.second;
return u.first > v.first;
}
int vst[1111];
int runs;
inline int grundy(int l, int r) {
runs++;
for (int i = 0; i < 26; i++) {
int L = nxt[l][i];
int R = prv[r][i];
if (L > R) continue;
int tmp = rgt[l][i] ^ lft[r][i];
tmp ^= xo[L + 1][i] ^ xo[R + 1][i];
vst[tmp] = runs;
}
for (int i = 0;; i++)
if (vst[i] != runs) return i;
}
vector<int> vec[26];
void pre() {
n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) {
prv[i][j] = prv[i - 1][j];
}
prv[i][ch(s[i])] = i;
}
for (int j = 0; j < 26; j++) nxt[n + 1][j] = n + 1;
for (int i = n; i >= 1; i--) {
for (int j = 0; j < 26; j++) {
nxt[i][j] = nxt[i + 1][j];
}
nxt[i][ch(s[i])] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) {
int ed = nxt[i][j];
if (ed == n + 1) continue;
if (ed == i) continue;
vp.push_back(pair<int, int>(i, ed - 1));
}
for (int j = 0; j < 26; j++) {
int st = prv[i][j];
if (st == 0 or st == i) continue;
vp.push_back(pair<int, int>(st + 1, i));
}
}
for (int i = 1; i <= n; i++) vec[ch(s[i])].push_back(i);
for (int i = 0; i < 26; i++) {
for (int j = 0; j + 1 < vec[i].size(); j++) {
int l = vec[i][j], r = vec[i][j + 1];
vp.push_back(pair<int, int>(l + 1, r - 1));
}
}
sort(vp.begin(), vp.end(), cmp);
vp.erase(unique(vp.begin(), vp.end()), vp.end());
for (auto p : vp) {
int l = p.first, r = p.second;
int g = grundy(l, r);
if (r < n and nxt[l][ch(s[r + 1])] == r + 1) {
rgt[l][ch(s[r + 1])] = g;
}
if (l > 1 and prv[r][ch(s[l - 1])] == l - 1) {
lft[r][ch(s[l - 1])] = g;
}
if (l > 1 and r < n and s[l - 1] == s[r + 1]) {
xo[l][ch(s[l - 1])] = g ^ xo[r + 2][ch(s[l - 1])];
}
}
}
void solve() {
scanf("%s", s + 1);
int q;
cin >> q;
pre();
while (q--) {
int l, r, g;
scanf("%d %d", &l, &r);
g = grundy(l, r);
if (g)
puts("Alice");
else
puts("Bob");
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[109999];
int n;
vector<int> ap[26], qz[26];
pair<pair<int, int>, pair<int, int> > qs[5800999];
int qn = 0;
bool cmp(pair<pair<int, int>, pair<int, int> > a,
pair<pair<int, int>, pair<int, int> > b) {
if (a.first.second != b.first.second) return a.first.second < b.first.second;
return a.first.first > b.first.first;
}
int nx[109999][26], pv[100099][26], ps[109999], ts[109999], tl[26][109999],
tr[26][109999];
int gans(pair<int, int> t) {
if (t.first > t.second) return 0;
int w[26];
for (int i = 0; i < 26; ++i) {
w[i] = -1;
int b = pv[t.second][i];
if (ap[i][b] < t.first) continue;
int a = nx[t.first][i];
w[i] = tl[i][t.first] ^ tr[i][t.second] ^ qz[i][b - 1] ^ qz[i][a - 1];
}
for (int i = 0; i < 26; ++i)
if (~w[i]) ++ts[w[i]];
int g = 0;
while (ts[g]) ++g;
for (int i = 0; i < 26; ++i)
if (~w[i]) --ts[w[i]];
return g;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 0; i < 26; ++i) ap[i].push_back(0);
for (int i = 1; i <= n; ++i)
ps[i] = ap[s[i] - 'a'].size(), ap[s[i] - 'a'].push_back(i);
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 26; ++j) pv[i][j] = pv[i - 1][j];
pv[i][s[i] - 'a'] = ps[i];
}
for (int j = 0; j < 26; ++j) nx[n + 1][j] = 1e9;
for (int i = n; i >= 1; --i) {
for (int j = 0; j < 26; ++j) nx[i][j] = nx[i + 1][j];
nx[i][s[i] - 'a'] = ps[i];
}
for (int i = 0; i < 26; ++i) {
qz[i].push_back(0);
for (int j = 1; j + 1u < ap[i].size(); ++j)
qs[++qn] = make_pair(pair<int, int>(ap[i][j] + 1, ap[i][j + 1] - 1),
pair<int, int>(i, j));
for (int j = 1; j <= n; ++j) {
int u = pv[j][i];
if (u)
qs[++qn] = make_pair(pair<int, int>(ap[i][u] + 1, j),
pair<int, int>(-j, i * 2));
}
for (int j = 1; j <= n; ++j) {
int u = nx[j][i];
if (u <= n)
qs[++qn] = make_pair(pair<int, int>(j, ap[i][u] - 1),
pair<int, int>(-j, i * 2 + 1));
}
}
sort(qs + 1, qs + 1 + qn, cmp);
for (int i = 1; i <= qn; ++i) {
int w = gans(qs[i].first), u = qs[i].second.first;
if (u >= 0)
qz[u].push_back(qz[u].back() ^ w);
else {
if (qs[i].second.second & 1)
tl[qs[i].second.second >> 1][-u] = w;
else
tr[qs[i].second.second >> 1][-u] = w;
}
}
int T, l, r;
scanf("%d", &T);
while (T--) {
scanf("%d%d", &l, &r);
if (gans(pair<int, int>(l, r)))
puts("Alice");
else
puts("Bob");
}
}
|
#include <bits/stdc++.h>
int read() {
static int ch, x;
while ((ch = getchar()) < 48) {
}
x = ch ^ 48;
while ((ch = getchar()) >= 48) x = (((x << 2) + x) << 1) + (ch ^ 48);
return x;
}
const int SIG = 27;
char s[100010];
int a[100010], sum[100010];
int pre[100010][SIG], suf[100010][SIG], pans[100010][SIG], sans[100010][SIG];
bool vis[SIG];
std::pair<int, int> st[SIG + 10];
int main() {
scanf("%s", s + 2);
const int n = strlen(s + 2) + 2;
s[1] = s[n] = 26 + 'a';
for (int i = 1; i <= n; ++i) {
a[i] = s[i] - 'a';
for (int j = 0; j < SIG; ++j) pre[i][j] = pre[i - 1][j];
pre[i][a[i]] = i;
}
for (int i = n; i >= 1; --i) {
for (int j = 0; j < SIG; ++j) suf[i][j] = suf[i + 1][j];
suf[i][a[i]] = i;
}
for (int i = n; i >= 1; --i) {
int top = 0;
for (int j = 0; j < SIG; ++j) {
if (const int t = suf[i][j]) st[++top] = std::make_pair(t, j);
}
std::sort(st + 1, st + top + 1);
const int t = suf[i + 1][a[i]];
if (t && t < n) {
sum[i] = pans[i + 1][a[i]];
sum[i] ^= sum[t];
}
for (int j = 1; j <= top; ++j) {
const int pos = st[j].first, col = st[j].second;
for (int k = 0; k < SIG; ++k) vis[k] = false;
for (int k = 1; k < j; ++k) {
const int p = st[k].second, u = pre[pos][p];
int res = pans[i][p] ^ sum[suf[i][p]] ^ sum[u];
if (u) res ^= pans[u + 1][col];
if (res < SIG) vis[res] = true;
}
int &res = pans[i][col];
while (res < SIG && vis[res]) ++res;
}
for (int j = 0; j < SIG; ++j)
if (!suf[i][j]) pans[i][j] = pans[i][SIG - 1];
}
for (int i = 1; i <= n; ++i) {
int top = 0;
for (int j = 0; j < SIG; ++j) {
if (const int t = pre[i][j]) st[++top] = std::make_pair(t, j);
}
std::sort(st + 1, st + top + 1, std::greater<std::pair<int, int>>());
for (int j = 1; j <= top; ++j) {
const int pos = st[j].first, col = st[j].second;
for (int k = 0; k < SIG; ++k) vis[k] = false;
for (int k = 1; k < j; ++k) {
const int p = st[k].second, u = suf[pos][p];
int res = sans[i][p] ^ sum[pre[i][p]] ^ sum[u];
if (u <= n) res ^= sans[u - 1][col];
if (res < SIG) vis[res] = true;
}
int &res = sans[i][col];
while (res < SIG && vis[res]) ++res;
}
for (int j = 0; j < SIG; ++j)
if (!pre[i][j]) sans[i][j] = sans[i][SIG - 1];
}
for (int m = read(); m--;) {
const int l = read() + 1, r = read() + 1;
bool flag = false;
for (int i = 0; i < SIG; ++i) {
const int t = suf[l][i];
if (t && t <= r) {
const int u = pre[r][i];
int res = pans[l][i] ^ sum[t] ^ sum[u];
if (u) res ^= sans[r][i];
if (!res) {
flag = true;
break;
}
}
}
puts(flag ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 100010;
const int SIGMA = 26;
char s[N];
int right[N][SIGMA], left[N][SIGMA];
unsigned suf[N][SIGMA], right_ans[N][SIGMA], left_ans[N][SIGMA];
std::vector<int> vec[N];
unsigned calc(int l, int r) {
unsigned vis = 0;
for (int i = 0; i < SIGMA; ++i) {
int ll = right[l][i], rr = left[r][i];
if (ll > rr) {
continue;
}
unsigned sum = right_ans[l][i] ^ left_ans[r][i] ^ suf[ll][i] ^ suf[rr][i];
vis |= 1u << sum;
}
for (unsigned i = 0; i < 32; ++i) {
if (!(vis >> i & 1u)) {
return i;
}
}
return UINT_MAX;
}
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
s[0] = s[n + 1] = '*';
for (int j = 0; j < SIGMA; ++j) {
int cur = 0;
for (int i = 0; i <= n + 1; ++i) {
if (s[i] == '*' || s[i] == j + 'a') {
cur = i;
}
left[i][j] = cur;
}
for (int i = n + 1; i >= 0; --i) {
if (s[i] == '*' || s[i] == j + 'a') {
cur = i;
}
right[i][j] = cur;
}
}
for (int i = 1; i <= n; ++i) {
int j = i - 1;
while (s[j] != s[i] && s[j] != '*') {
--j;
}
for (int k = j + 1; k < i; ++k) {
vec[k].push_back(i - 1);
}
}
for (int i = n; i >= 1; --i) {
int j = i + 1;
while (s[j] != s[i] && s[j] != '*') {
++j;
}
unsigned last = 0;
int ch = s[i] - 'a';
for (int k = i + 1; k < j; ++k) {
last = left_ans[k][ch] = calc(i + 1, k);
}
suf[i][ch] = suf[right[i + 1][ch]][ch] ^ last;
for (auto u : vec[i]) {
right_ans[i][s[u + 1] - 'a'] = calc(i, u);
}
}
int test;
scanf("%d", &test);
while (test--) {
int l, r;
scanf("%d%d", &l, &r);
unsigned sg = calc(l, r);
puts(sg ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char ch[100010];
int l, q, pre[100010][27], nxt[100010][27], sg[100010][27], preg[100010], f[27];
int calc(int x, int y, int z, int kind) {
if (x > y) return 0;
if (f[z] != -1) return f[z];
int gruddy = 0;
for (int i = 0; i < 26; i++) {
int o = nxt[x][i], p = pre[y][i];
if (o > y || o < x) continue;
if (kind == 0)
gruddy |=
(1 << (sg[o - 1][z] ^ preg[o] ^ preg[p] ^ calc(p + 1, y, i, kind)));
else
gruddy |= (1 << (calc(x, o - 1, i, kind) ^ preg[o] ^ preg[p] ^ sg[y][i]));
}
int res = 0;
while (gruddy & 1) gruddy >>= 1, res++;
f[z] = res;
return f[z];
}
void init() {
for (int i = 1; i <= l; i++) {
for (int j = 0; j < 26; j++)
pre[i][j] = (('a' + j) == ch[i] ? i : pre[i - 1][j]);
}
for (int i = l; i; i--)
for (int j = 0; j < 26; j++)
nxt[i][j] = (('a' + j) == ch[i] ? i : nxt[i + 1][j]);
for (int i = 1; i <= l; i++) {
int now = ch[i] - 'a';
preg[i] = preg[pre[i - 1][now]] ^ sg[i - 1][now];
for (int j = 0; j < 26; j++) f[j] = -1;
for (int j = 0; j < 26; j++)
if (pre[i][j] != 0) sg[i][j] = calc(pre[i][j] + 1, i, j, 0);
}
}
int main() {
scanf("%s", ch + 1);
l = strlen(ch + 1);
init();
scanf("%d", &q);
while (q--) {
int o, p;
scanf("%d%d", &o, &p);
for (int j = 0; j <= 26; j++) f[j] = -1;
if (calc(o, p, 26, 1))
printf("Alice\n");
else
printf("Bob\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int cs = 26;
const int N = 1e5 + 2;
int n;
array<int, cs> pa[N];
array<int, cs> sa[N];
array<int, cs> psg[N];
array<int, cs> ssg[N];
int ppg[N];
int spg[N];
string s, t;
int f(char c) { return c - 'a'; }
int inv(int x) { return n + 1 - x; }
void init(array<int, cs>& x) {
for (int i = 0; i < cs; i++) x[i] = cs;
}
int mex(array<int, cs>& x) {
bool vis[cs];
for (int i = 0; i < cs; i++) vis[i] = false;
for (int i = 0; i < cs; i++)
if (x[i] < cs) vis[x[i]] = true;
for (int i = 0; i < cs; i++)
if (!vis[i]) return i;
return cs;
}
array<int, cs> ord;
void build(string& p, array<int, cs>* a, array<int, cs>* sg, int* pg) {
for (int i = 1; i <= n + 1; i++) {
for (int j = 0; j < cs; j++) a[i][j] = a[i - 1][j];
if (i != n + 1) a[i][f(p[i])] = i;
}
}
void solve(string& p, array<int, cs>* a, array<int, cs>* sg, int* pg,
bool tok) {
for (int i = 0; i < cs; i++) ord[i] = i;
for (int i = 1; i <= n; i++) {
pg[i] = pg[a[i - 1][f(p[i])]] ^ sg[i - 1][f(p[i])];
for (int j = cs - 1; j >= 1; j--)
if (ord[j] == f(p[i])) swap(ord[j - 1], ord[j]);
for (int j = 0; j < cs; j++) {
array<int, cs> cur;
init(cur);
for (int k = 0; k < j; k++) {
if (a[i][ord[k]] > a[i][ord[j]]) {
int pr = a[i][ord[k]], pl;
if (tok)
pl = inv(sa[inv(a[i][ord[j]])][ord[k]]);
else
pl = inv(pa[inv(a[i][ord[j]])][ord[k]]);
cur[k] = sg[i][ord[k]] ^ pg[pr] ^ pg[pl] ^ sg[pl - 1][ord[j]];
}
}
sg[i][ord[j]] = mex(cur);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> s;
n = s.size();
s = '?' + s + '?';
t = s;
reverse(t.begin(), t.end());
build(s, pa, psg, ppg);
build(t, sa, ssg, spg);
solve(s, pa, psg, ppg, 1);
solve(t, sa, ssg, spg, 0);
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
array<int, cs> cur;
init(cur);
for (int i = 0; i < cs; i++) {
int pr = pa[r][i], pl = inv(sa[inv(l)][i]);
if (pr < l) continue;
cur[i] = ppg[pr] ^ ppg[pl] ^ psg[r][i] ^ ssg[inv(l)][i];
}
int res = mex(cur);
if (res == 0)
cout << "Bob\n";
else
cout << "Alice\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
using nimber = uint32_t;
const int MAXN = 1.1e5;
int N;
int A[MAXN];
const int MAXD = 30;
const int D = 26;
int nxt[MAXN][MAXD];
int prv[MAXN][MAXD];
nimber pref[MAXN];
nimber dpnxt[MAXN][MAXD];
nimber dpprv[MAXN][MAXD];
nimber solveRange(int l, int r) {
vector<nimber> nxts;
if (l > r) return 0;
for (int d = 0; d < D; d++) {
if (nxt[l][d] > r) continue;
int x = nxt[l][d];
int y = prv[r][d];
assert(x <= y);
assert(l <= x && x <= y && y <= r);
assert(A[x] == d && A[y] == d);
assert(dpnxt[l][d] != nimber(-1));
assert(dpprv[r][d] != nimber(-1));
assert(pref[y] != nimber(-1));
assert(pref[x] != nimber(-1));
nimber v = dpnxt[l][d] ^ dpprv[r][d];
v ^= pref[y] ^ pref[x];
nxts.push_back(v);
}
sort(nxts.begin(), nxts.end());
nxts.resize(size_t(unique(nxts.begin(), nxts.end()) - nxts.begin()));
nimber res = 0;
while (res < nxts.size() && nxts[res] == res) res++;
return res;
}
int main() {
ios_base::sync_with_stdio(0);
string S;
cin >> S;
N = int(S.size());
for (int i = 0; i < N; i++) {
A[i + 1] = S[i] - 'a';
}
for (int d = 0; d < D; d++) {
prv[0][d] = 0;
nxt[N + 1][d] = N + 1;
}
for (int i = 1; i <= N; i++) {
for (int d = 0; d < D; d++) {
prv[i][d] = prv[i - 1][d];
}
prv[i][A[i]] = i;
}
for (int i = N; i >= 1; i--) {
for (int d = 0; d < D; d++) {
nxt[i][d] = nxt[i + 1][d];
}
nxt[i][A[i]] = i;
}
memset(dpnxt, -1, sizeof(dpnxt));
memset(dpprv, -1, sizeof(dpprv));
memset(pref, -1, sizeof(pref));
for (int i = 1; i <= N; i++) {
int p = prv[i - 1][A[i]];
if (p > 0) {
assert(dpprv[i - 1][A[i]] != nimber(-1));
pref[i] = pref[p] ^ dpprv[i - 1][A[i]];
} else {
pref[i] = 0;
}
for (int j = i; j > p; j--) {
assert(i == nxt[i][A[i]]);
dpnxt[j][A[i]] = solveRange(j, i - 1);
}
vector<pair<int, int>> lefts;
for (int d = 0; d < D; d++) {
if (prv[i][d] == 0) continue;
lefts.emplace_back(-prv[i][d], d);
}
sort(lefts.begin(), lefts.end());
for (auto it : lefts) {
int d = it.second;
dpprv[i][d] = solveRange(prv[i][d] + 1, i);
}
}
int Q;
cin >> Q;
for (int q = 0; q < Q; q++) {
int l, r;
cin >> l >> r;
nimber v = solveRange(l, r);
cout << (v ? "Alice" : "Bob") << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int read() {
int f = 1, g = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) g = g * 10 + ch - '0';
return f * g;
}
int n, m, a[N], nex[N][26], las[N][26], f[N][26], g[N][26], s[N], cur[26];
char ch[N];
int calc(int l, int r);
int calcl(int x, int i) {
if (f[x][i] == -1) f[x][i] = calc(x, nex[x][i]);
return f[x][i];
}
int calcr(int x, int i) {
if (g[x][i] == -1) g[x][i] = calc(las[x][i], x);
return g[x][i];
}
int cal(int x, int i) {
if (s[x] == -1) s[x] = cal(las[x][i], i) ^ calcr(x, i);
return s[x];
}
int calc(int l, int r) {
if (l + 1 > r - 1) return 0;
int t = 0;
for (int i = 0; i < 26; i++) {
if (nex[l][i] >= r) continue;
t |= (1 << (calcl(l, i) ^ calcr(r, i) ^ cal(las[r][i], i) ^
cal(nex[l][i], i)));
}
for (int i = 0; i < 27; i++)
if ((t & (1 << i)) == 0) return i;
}
int main() {
scanf("%s", ch + 1);
n = strlen(ch + 1);
for (int i = 1; i <= n; i++) a[i] = ch[i] - 'a';
memset(cur, 0, sizeof(cur));
for (int i = 1; i <= n + 1; i++) {
memcpy(las[i], cur, 26 * 4);
cur[a[i]] = i;
}
for (int i = 0; i < 26; i++) cur[i] = n + 1;
for (int i = n; i >= 0; i--) {
memcpy(nex[i], cur, 26 * 4);
cur[a[i]] = i;
}
memset(f, -1, sizeof(f));
memset(g, -1, sizeof(g));
memset(s, -1, sizeof(s));
s[0] = 0;
scanf("%d", &m);
while (m--) {
int l, r;
scanf("%d %d", &l, &r);
puts(calc(l - 1, r + 1) ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
uint64_t rnd_data = 0xDEADBEEFDULL;
inline void my_srand(int seed) { rnd_data = ((uint64_t)seed << 16) | 0x330E; }
inline int my_rand() {
rnd_data = rnd_data * 0x5DEECE66DULL + 0xB;
return (rnd_data >> 17) & 0x7FFFFFFF;
}
template <typename T>
void my_random_shuffle(T b, T e) {
for (int i = (1); i <= (int)((int)(e - b) - 1); i++) {
swap(b[i], b[my_rand() % (i + 1)]);
}
}
template <class _T>
inline _T sqr(const _T &x) {
return x * x;
}
template <typename type_t, typename less_t = std::less<type_t>>
inline bool uin(type_t &a, const type_t &b, const less_t &ls = less_t()) {
return ls(b, a) ? a = b, true : false;
}
template <typename type_t, typename less_t = std::less<type_t>>
inline bool uax(type_t &a, const type_t &b, const less_t &ls = less_t()) {
return ls(a, b) ? a = b, true : false;
}
const long double PI = 3.1415926535897932384626433832795L;
const long double EPS = 1e-9;
int n, m;
char s[102400];
int b[102400][2];
int dl[102400][26];
int dr[102400][26];
vector<int> pos[26];
vector<int> tx[26];
int zx[26];
vector<pair<int, int>> sq;
int nextc[102400][26];
int prevc[102400][26];
int idx[102400];
inline void tadd(int j, int first, int k) {
first += zx[j];
while (first) {
tx[j][first] ^= k;
first >>= 1;
}
}
inline int txor(int j, int l, int r) {
int ans = 0;
l += zx[j];
r += zx[j];
while (l <= r) {
if (l & 1) ans ^= tx[j][l];
if (!(r & 1)) ans ^= tx[j][r];
l = (l + 1) >> 1;
r = (r - 1) >> 1;
}
return ans;
}
int solvel(int l, int j, bool calc_tadd = false);
int solver(int r, int j, bool calc_tadd = false);
int solve0(int l, int r, bool calc_tadd = false) {
if (r < l) return 0;
int u = 0;
for (int i = 0; i < (int)(26); i++) {
int xpos = nextc[l][i];
if (xpos >= n) continue;
int first = idx[xpos];
if (pos[i][first] > r) continue;
int ypos = prevc[r][i];
int second = idx[ypos];
int cur = txor(i, first, second - 1);
cur ^= solvel(l, i, calc_tadd);
cur ^= solver(r, i, calc_tadd);
u |= 1 << cur;
}
for (int i = 0; i < (int)(30); i++) {
if (!(u & (1 << i))) {
if (l > 0 && r < n - 1 && s[l - 1] == s[r + 1] && calc_tadd) {
int ch = s[l - 1] - 'a';
int first = idx[l - 1];
if (pos[ch][first + 1] == r + 1) tadd(ch, first, i);
}
return i;
}
}
assert(false);
return -1;
}
int solvel(int l, int j, bool calc_tadd) {
int &ans = dl[l][j];
if (ans >= 0) return ans;
int posj = nextc[l][j];
int first = posj == n ? pos[j].size() - 1 : idx[posj];
int r = pos[j][first] - 1;
if (r < l) {
return ans = 0;
}
return ans = solve0(l, r, calc_tadd);
}
int solver(int r, int j, bool calc_tadd) {
int &ans = dr[r][j];
if (ans >= 0) return ans;
int posj = prevc[r][j];
int first = posj == -1 ? 0 : idx[posj];
int l = pos[j][first] + 1;
if (r < l) {
return ans = 0;
}
return ans = solve0(l, r, calc_tadd);
}
void precalc() {
for (int i = (n)-1; i >= 0; i--) {
for (int j = 0; j < (int)(26); j++) {
solvel(i, j);
}
}
for (int i = 0; i < (int)(n); i++) {
for (int j = 0; j < (int)(26); j++) {
solver(i, j);
}
}
}
int main() {
memset(dl, 0xff, sizeof(dl));
memset(dr, 0xff, sizeof(dr));
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < (int)(26); i++) {
pos[i].push_back(-1);
}
for (int i = 0; i < (int)(n); i++) {
int first = s[i] - 'a';
pos[first].push_back(i);
idx[i] = pos[first].size() - 1;
}
for (int i = 0; i < (int)(26); i++) {
pos[i].push_back(n);
}
for (int j = 0; j < (int)(26); j++) {
nextc[n][j] = n;
for (int i = (n)-1; i >= 0; i--) {
nextc[i][j] = s[i] == 'a' + j ? i : nextc[i + 1][j];
}
}
for (int j = 0; j < (int)(26); j++) {
prevc[0][j] = s[0] == 'a' + j ? 0 : -1;
for (int i = (1); i <= (int)(n); i++) {
prevc[i][j] = s[i] == 'a' + j ? i : prevc[i - 1][j];
}
}
for (int i = 0; i < (int)(26); i++) {
zx[i] = 1;
while ((int)pos[i].size() > zx[i]) zx[i] <<= 1;
tx[i].resize(zx[i] * 2, 0);
}
scanf("%d", &m);
for (int i = 0; i < (int)(m); i++) {
scanf("%d%d", &b[i][0], &b[i][1]);
b[i][0]--;
b[i][1]--;
}
for (int i = 0; i < (int)(26); i++) {
for (int j = 0; j < (int)(pos[i].size() - 1); j++) {
if (pos[i][j] + 1 <= pos[i][j + 1] - 1)
sq.push_back(make_pair(pos[i][j] + 1, pos[i][j + 1] - 1));
}
}
sort((sq).begin(), (sq).end(), [](pair<int, int> l, pair<int, int> r) {
return l.second - l.first < r.second - r.first;
});
for (auto &qq : sq) {
solve0(qq.first, qq.second, true);
}
precalc();
for (int i = 0; i < (int)(m); i++) {
puts(solve0(b[i][0], b[i][1]) ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n;
char s[maxn];
int pre[26][maxn], nxt[26][maxn];
int pre_f[26][maxn], suf_f[26][maxn];
int sum[maxn];
int ask(int l, int r) {
static int vis[26];
if (l > r) return 0;
memset(vis, 0, sizeof(vis));
for (int i = 0; i < 26; i++)
if (pre[i][r] >= l) {
int v = suf_f[i][l] ^ sum[pre[i][r]] ^ sum[nxt[i][l]] ^ pre_f[i][r];
vis[v] = 1;
}
for (int i = 0;; i++) {
if (!vis[i]) {
return i;
}
}
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 0; i < 26; i++) {
for (int j = 1; j <= n; j++) {
pre[i][j] = (s[j] == 'a' + i) ? j : pre[i][j - 1];
}
nxt[i][n + 1] = n + 1;
for (int j = n; j; j--) {
nxt[i][j] = (s[j] == 'a' + i) ? j : nxt[i][j + 1];
}
}
for (int i = 1; i <= n; i++) {
int ch = s[i] - 'a';
int L = pre[ch][i - 1];
if (L) sum[i] = pre_f[ch][i - 1] ^ sum[L];
for (int j = i - 1; j > L; j--) {
suf_f[ch][j] = ask(j, i - 1);
}
vector<pair<int, int> > seg;
for (int j = 0; j < 26; j++)
if (j != ch && pre[j][i] != 0) {
seg.push_back(make_pair(pre[j][i] + 1, j));
}
sort(seg.begin(), seg.end());
reverse(seg.begin(), seg.end());
for (pair<int, int> x : seg) {
pre_f[x.second][i] = ask(x.first, i);
}
}
int qn;
scanf("%d", &qn);
for (; qn--;) {
int l, r;
scanf("%d%d", &l, &r);
printf("%s\n", ask(l, r) ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
const int maxn = 2018;
const ll inf = 10000000000000;
int main(int argc, char *argv[]) {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
ll n, m, x, a[maxn], b[maxn], pa[maxn], pb[maxn], ma[maxn], mb[maxn];
std::cin >> n >> m;
pa[0] = pb[0] = 0;
for (int i = 1; i <= n; i++) {
std::cin >> a[i];
pa[i] = pa[i - 1] + a[i];
}
for (int i = 1; i <= m; i++) {
std::cin >> b[i];
pb[i] = pb[i - 1] + b[i];
}
std::cin >> x;
std::fill(ma, ma + maxn, inf);
std::fill(mb, mb + maxn, inf);
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
ma[j - i] = std::min(pa[j] - pa[i], ma[j - i]);
}
}
for (int i = 0; i < m; i++) {
for (int j = i + 1; j <= m; j++) {
mb[j - i] = std::min(pb[j] - pb[i], mb[j - i]);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (ma[i] * mb[j] <= x) {
ans = std::max(i * j, ans);
}
}
}
std::cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100005];
long long b[100005];
long long x;
long long n, m;
long long c[100005];
long long d[100005];
void solve() {
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> a[i];
if (i) a[i] += a[i - 1];
c[i + 1] = 1e9;
}
for (long long i = 0; i < m; i++) {
cin >> b[i];
if (i) b[i] += b[i - 1];
d[i + 1] = 1e10;
}
cin >> x;
long long fans = 0;
for (long long i = 0; i < n; i++) {
for (long long j = i; j < n; j++) {
long long l = j - i + 1;
if (i)
c[l] = min(c[l], a[j] - a[i - 1]);
else
c[l] = min(c[l], a[j]);
}
}
for (long long i = 0; i < m; i++) {
for (long long j = i; j < m; j++) {
long long l = j - i + 1;
if (i)
d[l] = min(d[l], b[j] - b[i - 1]);
else
d[l] = min(d[l], b[j]);
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (c[i] * d[j] <= x) {
fans = max(fans, i * j);
}
}
}
cout << fans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long T;
T = 1;
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5 + 2000;
pair<long long, int> all[MAXN * MAXN];
int maxi[MAXN * MAXN];
long long arr1[MAXN], arr2[MAXN];
int n, m, sz;
long long query(int i, int j, long long* arr) {
return arr[j] - (i == 0 ? 0LL : arr[i - 1]);
}
int bs(long long k) {
int low = 0, high = sz - 1, best = -1;
while (low <= high) {
int mid = (low + high) >> 1;
if (all[mid].first <= k) {
best = mid;
low = 1 + mid;
} else {
high = mid - 1;
}
}
return best;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int ans = 0;
cin >> n >> m;
for (int i = (int)0; i < (int)n; ++i) {
cin >> arr1[i];
if (i) arr1[i] += arr1[i - 1];
}
for (int i = (int)0; i < (int)m; ++i) {
cin >> arr2[i];
if (i) arr2[i] += arr2[i - 1];
}
long long x;
cin >> x;
sz = 0;
for (int i = (int)0; i < (int)m; ++i)
for (int j = (int)i; j < (int)m; ++j)
all[sz++] = {query(i, j, arr2), 1 + j - i};
auto f = [](pair<long long, int>& a, pair<long long, int>& b) -> bool {
return a.first < b.first;
};
sort(all, all + sz, f);
maxi[0] = all[0].second;
for (int i = (int)1; i < (int)sz; ++i) {
maxi[i] = max(maxi[i - 1], all[i].second);
}
int idx;
long long k;
for (int i = (int)0; i < (int)n; ++i) {
for (int j = (int)i; j < (int)n; ++j) {
k = x / query(i, j, arr1);
idx = bs(k);
if (idx >= 0) {
ans = max(ans, (1 + j - i) * maxi[idx]);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, X;
int A[2001], B[2001];
int main() {
scanf("%d %d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%d", &A[i]);
A[i] += A[i - 1];
}
for (int i = 1; i <= M; i++) {
scanf("%d", &B[i]);
B[i] += B[i - 1];
}
scanf("%d", &X);
int mx = 0;
for (int len = 1; len <= N; len++) {
int amn = 1e9;
for (int i = len; i <= N; i++) {
amn = min(amn, A[i] - A[i - len]);
}
int l = 0, r = 1;
while (l < M) {
r = max(l, r);
while (r <= M && 1LL * (B[r] - B[l]) * amn <= X) r++;
r--;
mx = max(mx, len * (r - l));
l++;
}
}
printf("%d\n", mx);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int const MaxVal = 2500010;
int tree[MaxVal + 10];
void update(int idx, int val) {
while (idx <= MaxVal) {
tree[idx] = max(val, tree[idx]);
idx += (idx & -idx);
}
}
int read(int idx) {
int ans = 0;
while (idx > 0) {
ans = max(tree[idx], ans);
idx -= (idx & -idx);
}
return ans;
}
int main() {
int n, m;
cin >> n >> m;
long long x;
vector<int> a(n + 1);
vector<int> b(m + 1);
int sum = 0;
for (int i = 1; i <= n; i++) {
int t;
cin >> t;
sum += t;
a[i] = sum;
}
sum = 0;
for (int i = 1; i <= m; i++) {
int t;
cin >> t;
sum += t;
b[i] = sum;
}
cin >> x;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
update(a[j] - a[i - 1], j - i + 1);
}
}
long long ans = 0;
for (int i = 1; i <= m; i++) {
for (int j = i; j <= m; j++) {
int s = b[j] - b[i - 1];
int target = x / s;
target = min(MaxVal - 1, target);
if (target) {
long long l1 = j - i + 1;
long long l2 = read(target);
ans = max(ans, l1 * l2);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long maxn = 2005;
long long n, m;
long long qzmn[maxn], qzmx[maxn];
long long a[maxn], b[maxn];
long long xx;
signed main() {
memset(qzmn, 127, sizeof(qzmn));
memset(qzmx, 127, sizeof(qzmx));
scanf("%I64d%I64d", &n, &m);
for (long long i = 1; i <= n; i++)
scanf("%I64d", &a[i]), a[i] = a[i - 1] + a[i];
for (long long i = 1; i <= m; i++)
scanf("%I64d", &b[i]), b[i] = b[i - 1] + b[i];
scanf("%I64d", &xx);
for (long long i = 1; i <= n; i++)
for (long long j = i; j <= n; j++) {
qzmn[j - i + 1] = min(qzmn[j - i + 1], a[j] - a[i - 1]);
}
for (long long i = 1; i <= m; i++)
for (long long j = i; j <= m; j++)
qzmx[j - i + 1] = min(qzmx[j - i + 1], b[j] - b[i - 1]);
long long ans = 0;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) {
if (qzmn[i] * qzmx[j] <= xx) {
ans = max(ans, i * j);
}
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2000;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
vector<long long> A[2];
vector<pair<long long, int> > S[2];
for (int k : {0, 1}) {
int n;
cin >> n;
A[k].resize(n + 1, 0);
}
for (int k : {0, 1}) {
auto& V = A[k];
int n = V.size() - 1;
for (int i = 1; i <= n; i++) {
cin >> V[i];
V[i] += V[i - 1];
}
auto& P = S[k];
P.reserve(n * n);
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
P.emplace_back(V[j] - V[i], j - i);
}
}
sort(P.begin(), P.end());
for (int i = 1; i < (int)P.size(); i++) {
P[i].second = max(P[i].second, P[i - 1].second);
}
}
long long T;
cin >> T;
int n = S[0].size(), m = S[1].size();
int ans = 0;
for (int i = 0, j = m - 1; i < n; i++) {
while (j >= 0 && S[0][i].first * S[1][j].first > T) j--;
if (j < 0) break;
ans = max(ans, S[0][i].second * S[1][j].second);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long re = 0, flag = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
re = (re << 1) + (re << 3) + ch - '0', ch = getchar();
return re * flag;
}
int AFSDGHJ[300010], LLLBBNB[300010];
int n, m;
long long s[300010], s1[300010];
long long MAAIINNN[300010];
void input() {
int i;
for (i = 1; i <= n; i++) {
AFSDGHJ[i] = read();
s1[i] = s1[i - 1] + AFSDGHJ[i];
}
for (i = 1; i <= m; i++) {
LLLBBNB[i] = read();
s[i] = s[i - 1] + LLLBBNB[i];
MAAIINNN[i] = 2e9;
}
}
void getmin() {
int i, j;
for (i = 1; i <= m; i++) {
for (j = i; j <= m; j++) {
MAAIINNN[j - i + 1] = min(MAAIINNN[j - i + 1], s[j] - s[i - 1]);
}
}
}
int main() {
n = read();
m = read();
int i, j;
input();
getmin();
long long ret = 0, XX = read(), l, r, mid, X, ans;
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j++) {
ans = 0;
X = s1[j] - s1[i - 1];
l = 1, r = m;
while (l <= r) {
mid = (l + r) >> 1;
if (1LL * X * MAAIINNN[mid] <= XX) {
l = mid + 1;
ans = mid;
} else
r = mid - 1;
}
ret = max(ret, ans * (j - i + 1));
}
}
cout << ret;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> sa[4000005], sb[4000005];
int a[2005], b[2005], ca, cb, mx[4000005];
int main() {
int n, m, x, i, j;
cin >> n >> m;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= m; i++) scanf("%d", &b[i]);
cin >> x;
for (i = 1; i <= n; i++) {
int sum = 0;
for (j = i; j <= n; j++) {
sum += a[j];
sa[++ca] = make_pair(sum, j - i + 1);
}
}
for (i = 1; i <= m; i++) {
int sum = 0;
for (j = i; j <= m; j++) {
sum += b[j];
sb[++cb] = make_pair(sum, j - i + 1);
}
}
sort(sa + 1, sa + 1 + ca);
sort(sb + 1, sb + 1 + cb);
for (i = 1; i <= cb; i++) mx[i] = max(mx[i - 1], sb[i].second);
j = cb;
int ans = 0;
for (i = 1; i <= ca; i++) {
while (j > 0 && (long long)sa[i].first * sb[j].first > x) j--;
if (j) ans = max(ans, sa[i].second * mx[j]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[2005], b[2005];
int suma[10000];
int sumb[10000];
long long ansa[10000];
long long ansb[10000];
int main() {
int n, m;
int x;
cin >> n >> m;
suma[0] = 0;
sumb[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
suma[i] = suma[i - 1] + a[i];
}
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]);
sumb[i] = sumb[i - 1] + b[i];
}
cin >> x;
memset(ansa, 0, sizeof(ansa));
memset(ansb, 0, sizeof(ansb));
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) {
if (ansa[i - j] == 0)
ansa[i - j] = suma[i] - suma[j];
else
ansa[i - j] = min(ansa[i - j], (long long)suma[i] - suma[j]);
}
}
for (int i = 1; i <= m; i++) {
for (int j = 0; j < i; j++) {
if (ansb[i - j] == 0)
ansb[i - j] = sumb[i] - sumb[j];
else
ansb[i - j] = min(ansb[i - j], (long long)sumb[i] - sumb[j]);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (ansa[i] * ansb[j] <= x) ans = max(ans, i * j);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
return !b ? a : gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
return a * (b / gcd(a, b));
}
template <typename T>
T sqr(T a) {
return a * a;
}
template <typename T>
T cube(T a) {
return a * a * a;
}
template <typename T>
inline void smin(T &a, T b) {
a = a < b ? a : b;
}
template <typename T>
inline void smax(T &a, T b) {
a = a > b ? a : b;
}
template <typename T>
void fill(T a[], T n, T b) {
for (int i = 0; i <= n; i++) a[i] = b;
}
int in() {
int n;
scanf("%d", &n);
return n;
}
long long Lin() {
long long n;
scanf("%lld", &n);
return n;
}
double Din() {
double n;
scanf("%lf", &n);
return n;
}
const int inf = 2e9;
const long long mod = (long long)1e9 + 7;
const int N = 2e3 + 5;
long long a[N], b[N];
long long dp[N], dp2[N];
int solve() {
int n = in(), m = in();
for (int i = 1; i <= n; i++) {
a[i] = Lin();
a[i] += a[i - 1];
}
for (int i = 1; i <= m; i++) {
b[i] = Lin();
b[i] += b[i - 1];
}
long long x = Lin(), ans = 0;
for (int i = 1; i <= n || i <= m; i++) {
dp[i] = dp2[i] = inf;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
smin(dp[j - i + 1], a[j] - a[i - 1]);
}
}
for (int i = 1; i <= m; i++) {
for (int j = i; j <= m; j++) {
smin(dp2[j - i + 1], b[j] - b[i - 1]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (dp[i] * dp2[j] <= x) ans = max(ans, (long long)i * j);
}
}
cout << ans << '\n';
return 0;
}
int main() {
int test = 1, tc = 0;
while (test--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
long long n, m;
cin >> n >> m;
vector<long long> a(n), b(m);
for (long long i = 0; i < n; ++i) {
cin >> a[i];
}
for (long long i = 0; i < m; ++i) {
cin >> b[i];
}
long long x;
cin >> x;
vector<pair<long long, long long>> c;
for (long long i = 0; i < m; ++i) {
long long sum = 0;
for (long long j = i; j < m; ++j) {
sum += b[j];
c.push_back(make_pair(sum, j - i + 1));
}
}
sort(c.begin(), c.end());
set<pair<long long, long long>> real;
long long max_dist = 0;
for (auto el : c) {
if (el.second > max_dist) {
real.insert(el);
max_dist = el.second;
}
}
long long ans = 0;
for (long long i = 0; i < n; ++i) {
long long sum = 0;
for (long long j = i; j < n; ++j) {
sum += a[j];
long long bla = x / sum;
auto blabla = make_pair(bla + 1, 0);
auto it = real.upper_bound(blabla);
if (it != real.begin()) {
--it;
ans = max(ans, (j - i + 1) * it->second);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int inf = 1e9;
int mod = 1e9 + 7;
double eps = 1e-9;
int dr[] = {-1, 0, 0, 1};
int dc[] = {0, 1, -1, 0};
int rng(int l, int r) {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<int>(l, r)(rng);
}
int main() {
int t, n, m, i, j;
cin >> n >> m;
vector<int> a(n), b(m), sa(n + 10, 0), sb(m + 10, 0);
for (i = 0; i < n; i++) {
cin >> a[i];
if (i) sa[i] = sa[i - 1] + a[i - 1];
}
sa[i] = sa[i - 1] + a[i - 1];
for (i = 0; i < m; i++) {
cin >> b[i];
if (i) sb[i] = sb[i - 1] + b[i - 1];
}
sb[i] = sb[i - 1] + b[i - 1];
long long int x;
cin >> x;
vector<int> mxa(n + 2, inf), mxb(m + 2, inf);
for (i = 0; i < n; i++)
for (j = i; j < n; j++)
mxa[j - i + 1] = min(mxa[j - i + 1], sa[j + 1] - sa[i]);
for (i = 0; i < m; i++)
for (j = i; j < m; j++)
mxb[j - i + 1] = min(mxb[j - i + 1], sb[j + 1] - sb[i]);
int ans = 0;
for (i = 0; i < mxa.size(); i++)
for (j = 0; j < mxb.size(); j++)
if (mxb[j] * 1ll * mxa[i] <= x) ans = max(ans, j * i);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 2e3 + 1024;
using namespace std;
int solve() { return 0; }
long long a[N], b[N], sa[N], sb[N];
long long one[N], two[N];
int main() {
for (int i = 1; i <= 2020; ++i) one[i] = two[i] = 10000000000000000;
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
sa[i] = sa[i - 1] + a[i];
}
for (int i = 1; i <= m; ++i) {
cin >> b[i];
sb[i] = sb[i - 1] + b[i];
}
long long x;
cin >> x;
int ans = 0;
for (int mid = 1; mid <= n; ++mid) {
for (int i = 1; i <= n - mid + 1; ++i) {
one[mid] = min(one[mid], sa[i + mid - 1] - sa[i - 1]);
}
}
for (int mid = 1; mid <= m; ++mid) {
for (int i = 1; i <= m - mid + 1; ++i) {
two[mid] = min(two[mid], sb[i + mid - 1] - sb[i - 1]);
}
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (one[i] * two[j] <= x) ans = max(ans, i * j);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long N = 3e5 + 5;
long long a[N][2];
long long ans[N][2];
long long n, m;
void get(long long idx, long long n) {
for (long long i = 0; i < n; ++i) ans[i][idx] = mod;
for (long long i = 0; i < n; ++i) {
long long sum = 0;
for (long long j = i; j < n; ++j) {
sum += a[j][idx];
ans[j - i][idx] = min(ans[j - i][idx], sum);
}
}
}
void gogo() {
cin >> n >> m;
for (long long i = 0; i < n; ++i) cin >> a[i][0];
for (long long i = 0; i < m; ++i) cin >> a[i][1];
long long x;
cin >> x;
get(0, n);
get(1, m);
long long res = 0;
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < m; ++j) {
if (ans[i][0] * ans[j][1] <= x) {
res = max(res, (i + 1) * (j + 1));
}
}
}
cout << res << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
gogo();
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long cA[2345], cB[2345];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
long long a[n];
long long b[m];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < m; i++) {
cin >> b[i];
}
long long x;
cin >> x;
for (long long i = 0; i < 2345; i++) {
cA[i] = 2000000007;
}
cA[0] = 0;
for (long long i = 0; i < n; i++) {
long long atual = 0;
for (long long j = i; j < n; j++) {
atual += a[j];
cA[j - i + 1] = min(cA[j - i + 1], atual);
}
}
for (long long i = 0; i < 2345; i++) {
cB[i] = 2000000007;
}
cB[0] = 0;
for (long long i = 0; i < m; i++) {
long long atual = 0;
for (long long j = i; j < m; j++) {
atual += b[j];
cB[j - i + 1] = min(cB[j - i + 1], atual);
}
}
long long res = 0;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (cA[i] * cB[j] <= x) {
res = max(res, i * j);
}
}
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
unordered_map<string, int> strs;
int w[105];
unordered_map<string, int> querys;
unordered_map<string, int> ans;
struct q {
string bina;
int index;
int k;
q(string a, int b, int c) : bina(a), index(b), k(c) {}
q() {}
};
vector<q> qs;
const int maxn = 2005;
long long a[maxn];
long long b[maxn];
long long ppla[maxn];
long long pplb[maxn];
long long suma[maxn];
long long sumb[maxn];
int main() {
int m, n;
long long x;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%lld", &b[i]);
}
scanf("%lld", &x);
int ans = 0;
for (int i = 1; i <= n && ans == 0; i++)
for (int j = 1; j <= m; j++) {
if (a[i] * b[j] <= x) {
ans = 1;
break;
}
}
if (ans == 0) {
printf("0\n");
return 0;
}
suma[0] = 0;
sumb[0] = 0;
for (int i = 1; i <= n; i++) {
suma[i] = suma[i - 1] + a[i];
}
for (int i = 1; i <= m; i++) {
sumb[i] = sumb[i - 1] + b[i];
}
memset(ppla, 0x3f, sizeof(ppla));
memset(pplb, 0x3f, sizeof(pplb));
for (int i = 0; i < n; i++)
for (int j = i + 1; j <= n; j++) {
if (suma[j] - suma[i] < ppla[j - i]) {
ppla[j - i] = suma[j] - suma[i];
}
}
for (int i = 0; i < m; i++)
for (int j = i + 1; j <= m; j++) {
if (sumb[j] - sumb[i] < pplb[j - i]) {
pplb[j - i] = sumb[j] - sumb[i];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (ppla[i] * pplb[j] <= x && i * j > ans) {
ans = i * j;
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2010;
inline long long read() {
long long s = 0, w = 1;
register char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * w;
}
long long n, m, a[N], b[N], X, qza[N], qzb[N], mia[N], mib[N], ans;
signed main() {
n = read(), m = read();
for (register long long i = 1; i <= n; i++)
a[i] = read(), qza[i] = a[i] + qza[i - 1], mia[i] = 1e12;
for (register long long i = 1; i <= m; i++)
b[i] = read(), qzb[i] = b[i] + qzb[i - 1], mib[i] = 1e12;
X = read();
for (register long long i = 1; i <= n; i++)
for (register long long j = 1; j <= i; j++)
mia[j] = min(mia[j], qza[i] - qza[i - j]);
for (register long long i = 1; i <= m; i++)
for (register long long j = 1; j <= i; j++)
mib[j] = min(mib[j], qzb[i] - qzb[i - j]);
for (register long long i = m, now = 1; i; i--) {
while (now <= n && mib[i] * mia[now] <= X) now++;
ans = max(ans, (now - 1) * i);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, x, a[3000], b[3000], qmi[3000], ymi[3000];
string s;
int main() {
iostream::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i + 1];
a[i + 1] += a[i];
}
for (int j = 0; j < m; j++) {
cin >> b[j + 1];
b[j + 1] += b[j];
}
cin >> x;
for (int l = 1; l <= n; l++) {
qmi[l] = x + 1;
for (int j = 0; j + l <= n; j++) {
qmi[l] = min(qmi[l], a[j + l] - a[j]);
}
}
for (int l = 1; l <= m; l++) {
ymi[l] = x + 1;
for (int j = 0; j + l <= m; j++) {
ymi[l] = min(ymi[l], b[j + l] - b[j]);
}
}
int ans = 0;
for (int l = 1; l <= n; l++) {
for (int xl = 1; xl <= m; xl++) {
if (qmi[l] <= x / ymi[xl]) {
ans = max(ans, l * xl);
}
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int a[n + 1], b[m + 1];
a[0] = 0;
b[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
for (int i = 1; i <= m; i++) {
cin >> b[i];
b[i] += b[i - 1];
}
int c[n + 1], d[m + 1];
for (int i = 0; i <= n; i++) {
c[i] = INT_MAX;
}
for (int i = 0; i <= m; i++) {
d[i] = INT_MAX;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j + i <= n; j++) {
c[i] = min(c[i], a[j + i] - a[j]);
}
}
for (int i = 1; i <= m; i++) {
for (int j = 0; j + i <= m; j++) {
d[i] = min(d[i], b[j + i] - b[j]);
}
}
int x, p;
cin >> x;
int dp = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
p = x / c[i];
if (d[j] <= p)
dp = max(dp, i * j);
else
break;
}
}
cout << dp;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int MAX = 4000005;
long long modexp(long long x, long long n) {
if (n == 0) return 1LL;
if (n % 2 == 0) {
long long y = modexp(x, n / 2) % mod;
return (y * y) % mod;
}
return (x * modexp(x, n - 1) % mod) % mod;
}
long long powr(long long x, long long n) {
long long ans = 1;
for (int i = 1; i <= n; i++) ans = ans * x;
return ans;
}
int h[MAX];
int main() {
int n, m;
scanf("%d", &n), scanf("%d", &m);
int a[n], b[m];
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < m; i++) {
scanf("%d", &b[i]);
}
int x;
scanf("%d", &x);
for (int i = 0; i < m; i++) {
int sum = 0;
int len = 0;
for (int j = i; j < m; j++) {
sum += b[j];
len++;
h[sum] = max(h[sum], len);
}
}
for (int i = 1; i < MAX; i++) h[i] = max(h[i], h[i - 1]);
int ans = 0;
for (int i = 0; i < n; i++) {
int sum = 0;
int len = 0;
for (int j = i; j < n; j++) {
sum += a[j];
len++;
int req = x / sum;
if (req >= MAX) {
ans = max(ans, len * m);
} else {
ans = max(ans, len * h[req]);
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
char c = getchar();
x = 0;
int f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
x *= f;
}
const int N = 2007;
long long n, m, a[N], b[N], sa[N], sb[N], ans, mi, q;
int main() {
read(n);
read(m);
for (int i = 1; i <= n; i++) read(a[i]), sa[i] = sa[i - 1] + a[i];
for (int i = 1; i <= m; i++) read(b[i]), sb[i] = sb[i - 1] + b[i];
read(q);
for (int i = 1; i <= n; i++) {
mi = 1e18;
for (int j = 1; j <= n - i + 1; j++)
mi = min(mi, sa[j + i - 1] - sa[j - 1]);
long long p1 = m, p2 = m;
while (p1 >= 0) {
if ((sb[p2] - sb[p1]) * mi <= q) {
ans = max(ans, (p2 - p1) * i);
p1--;
} else
p2--;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int r[4000][3], r1[4000][3], a[4000], b[4000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
long long int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> a[i], a[i] = i == 0 ? a[i] : a[i] + a[i - 1];
for (int i = 0; i < m; i++)
cin >> b[i], b[i] = i == 0 ? b[i] : b[i] + b[i - 1];
long long int x;
cin >> x;
for (int i = 0; i <= 2000; i++) r[i][0] = r1[i][0] = LLONG_MAX;
for (int i = 0; i < m; i++)
for (int j = i; j < m; j++)
if (i == 0) {
if (r[j - i + 1][0] > b[j]) {
r[j - i + 1][0] = b[j];
r[j - i + 1][1] = i;
r[j - i + 1][2] = j;
}
} else {
if (r[j - i + 1][0] > b[j] - b[i - 1]) {
r[j - i + 1][0] = b[j] - b[i - 1];
r[j - i + 1][1] = i;
r[j - i + 1][2] = j;
}
}
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++)
if (i == 0) {
if (r1[j - i + 1][0] > a[j]) {
r1[j - i + 1][0] = a[j];
r1[j - i + 1][1] = i;
r1[j - i + 1][2] = j;
}
} else {
if (r1[j - i + 1][0] > a[j] - a[i - 1]) {
r1[j - i + 1][0] = a[j] - a[i - 1];
r1[j - i + 1][1] = i;
r1[j - i + 1][2] = j;
}
}
long long int sx1 = 0, sx2 = 0, sy1 = 0, sy2 = 0, s = 0;
for (int i = n; i >= 1; i--)
for (int j = m; j >= 1; j--) {
if (r1[i][0] * r[j][0] <= x) {
long long int x1 = r1[i][1], x2 = r1[i][2], y1 = r[j][1], y2 = r[j][2];
if (s <= (x2 - x1 + 1) * (y2 - y1 + 1))
s = (x2 - x1 + 1) * (y2 - y1 + 1), sx1 = x1, sx2 = x2, sy1 = y1,
sy2 = y2;
}
}
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, m, A[2005], B[2005], sum[2005], sum2[2005], x, cev;
int main() {
scanf("%lld %lld", &n, &m);
for (int i = 1; i <= n; i++) scanf("%lld", &A[i]);
for (int i = 1; i <= n; i++) {
long long int cev37 = 0;
for (int j = i; j <= n; j++) {
cev37 += A[j];
sum[j - i + 1] =
(sum[j - i + 1] == 0 ? cev37 : min(sum[j - i + 1], cev37));
}
}
for (int i = 1; i <= m; i++) scanf("%lld", &B[i]);
for (int i = 1; i <= m; i++) {
long long int cev73 = 0;
for (int j = i; j <= m; j++) {
cev73 += B[j];
sum2[j - i + 1] =
(sum2[j - i + 1] == 0 ? cev73 : min(sum2[j - i + 1], cev73));
}
}
scanf("%lld", &x);
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
if (sum[i] * sum2[j] > x) break;
cev = max(cev, i * j);
}
}
printf("%lld", cev);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 99999999999999;
int a[2010], b[2010], ans;
long long aa[2010], bb[2010], dis[2010], x;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (register int i = 1; i <= n; i++)
scanf("%d", &a[i]), aa[i] = aa[i - 1] + a[i];
for (register int i = 1; i <= m; i++)
scanf("%d", &b[i]), bb[i] = bb[i - 1] + b[i];
scanf("%d", &x);
for (register int i = 1; i <= m + 1; i++) dis[i] = inf;
for (register int i = 1; i <= m; i++)
for (register int j = 1; i + j - 1 <= m; j++)
dis[i] = min(dis[i], bb[i + j - 1] - bb[j - 1]);
for (register int i = 1; i <= n; i++) {
for (register int j = i; j <= n; j++) {
if (aa[j] - aa[i - 1] > x) continue;
int pos =
lower_bound(dis + 1, dis + 1 + m, x / (aa[j] - aa[i - 1])) - dis;
if (dis[pos] > x / (aa[j] - aa[i - 1])) pos--;
ans = max(ans, pos * (j - i + 1));
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2004;
map<long long, int> mp;
int n, m, a[N], b[N];
long long s[N], t[N], z, sum;
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
s[i] = s[i - 1] + a[i];
}
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]);
t[i] = t[i - 1] + b[i];
}
scanf("%lld", &z);
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
sum = s[j] - s[i - 1];
mp[sum] = max(mp[sum], j - i + 1);
}
int pre = -1;
for (auto it = mp.begin(); it != mp.end(); it++) {
it->second = max(it->second, pre);
pre = it->second;
}
int ans = 0;
for (int i = 1; i <= m; i++)
for (int j = i; j <= m; j++) {
sum = t[j] - t[i - 1];
long long x = z / sum;
auto it = mp.upper_bound(x);
if (it == mp.begin()) continue;
it--;
ans = max(ans, (j - i + 1) * it->second);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
int32_t main() {
cin >> n >> m;
long long a[n + 1], b[m + 1];
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long j = 1; j <= m; j++) cin >> b[j];
long long k;
cin >> k;
long long prea[n + 1], preb[m + 1];
prea[0] = preb[0] = 0;
for (long long i = 1; i <= n; i++) {
prea[i] = prea[i - 1] + a[i];
}
for (long long i = 1; i <= m; i++) {
preb[i] = preb[i - 1] + b[i];
}
long long A[n + 1], B[m + 1];
for (long long i = 0; i <= n; i++) A[i] = INT_MAX;
for (long long i = 0; i <= m; i++) B[i] = INT_MAX;
for (long long len = 0; len <= n; len++) {
for (long long i = 1; i <= n; i++) {
long long j = i + len;
if (j > n) continue;
A[len + 1] = min(A[len + 1], prea[j] - prea[i - 1]);
}
}
for (long long len = 0; len <= m; len++) {
for (long long i = 1; i <= m; i++) {
long long j = i + len;
if (j > m) continue;
B[len + 1] = min(B[len + 1], preb[j] - preb[i - 1]);
}
}
long long s = 0;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (i * j >= s && A[i] * B[j] <= k) {
s = i * j;
}
}
}
cout << s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mpow(int base, int exp);
void ipgraph(int n, int m);
void dfs(int u, int par);
const int N = 3e5, M = N;
void solve() {
int n, m;
cin >> n >> m;
vector<int> a1(n), a2(m);
int s2 = 0;
int s3 = 0;
for (int i = 0; i < (n); i++) {
cin >> a1[i];
s3 += a1[i];
}
for (int i = 0; i < (m); i++) {
cin >> a2[i];
s2 += a2[i];
}
vector<int> s(s2 + 1, 0);
vector<int> len(s3 + 1, 0);
int x;
cin >> x;
vector<int> prefix(n + 1, 0);
vector<int> prefix2(m + 1, 0);
int ans = 0;
for (int i = 0; i < (n); i++) prefix[i + 1] = prefix[i] + a1[i];
for (int i = 0; i < (m); i++) prefix2[i + 1] = prefix2[i] + a2[i];
for (int i = (1); i <= (m); i++) {
for (int j = (i); j <= (m); j++) {
int sum = prefix2[j] - prefix2[i - 1];
s[sum] = max(s[sum], j - i + 1);
}
}
for (int i = (1); i <= (n); i++) {
for (int j = (i); j <= (n); j++) {
int sum = prefix[j] - prefix[i - 1];
len[sum] = max(len[sum], j - i + 1);
}
}
int mx = 0;
for (int i = 0; i < (s.size()); i++) {
mx = max(mx, s[i]);
s[i] = mx;
}
mx = 0;
for (int i = 0; i < (len.size()); i++) {
mx = max(mx, len[i]);
len[i] = mx;
}
for (int i = (1); i <= (n); i++) {
for (int j = (i); j <= (n); j++) {
int sum = prefix[j] - prefix[i - 1];
int aux = x / sum;
if (aux < 1 || aux >= s.size()) continue;
if (aux >= s.size()) aux = s.size() - 1;
ans = max(ans, (j - i + 1) * s[aux]);
}
}
for (int i = (1); i <= (m); i++) {
for (int j = (i); j <= (m); j++) {
int sum = prefix2[j] - prefix2[i - 1];
int aux = x / sum;
if (aux < 1) continue;
if (aux >= len.size()) aux = len.size() - 1;
ans = max(ans, (j - i + 1) * len[aux]);
}
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int MAXN = 1e5 + 10;
inline long long in() {
long long x = 0, flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return x * flag;
}
long long n, m, S, sx, sy, ex, ey, ans;
long long a[2010], b[2010], c[2010][2010];
long long suma[2010], sumb[2010], lena[2010], lenb[2010];
long long sum[2010][2010];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
a[i] = in(), suma[i] = suma[i - 1] + a[i], lena[i] = 1e13;
for (int i = 1; i <= m; i++)
b[i] = in(), sumb[i] = sumb[i - 1] + b[i], lenb[i] = 1e13;
S = in();
for (int i = 1; i <= n; i++) {
for (int bg = 1; bg <= n - i + 1; bg++) {
lena[i] = min(lena[i], suma[bg + i - 1] - suma[bg - 1]);
}
}
for (int i = 1; i <= m; i++) {
for (int bg = 1; bg <= m - i + 1; bg++) {
lenb[i] = min(lenb[i], sumb[bg + i - 1] - sumb[bg - 1]);
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (lena[i] * lenb[j] <= S) ans = max(ans, i * j);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 10;
int n, m;
long long ans, x, s1[N], s2[N], a[N], b[N], tmp[N * N];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
s1[i] = s1[i - 1] + a[i];
}
for (int i = 1; i <= m; ++i) {
scanf("%lld", &b[i]);
s2[i] = s2[i - 1] + b[i];
}
cin >> x;
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= n; ++j) {
tmp[s1[j] - s1[i - 1]] = max(tmp[s1[j] - s1[i - 1]], 0ll + j - i + 1);
}
}
for (int i = 1; i <= N * N; ++i) {
tmp[i + 1] = max(tmp[i + 1], tmp[i]);
}
for (int i = 1; i <= m; ++i) {
for (int j = i; j <= m; ++j) {
long long l = j - i + 1;
long long del = x / (s2[j] - s2[i - 1]);
if (del > N * N) del = N * N;
ans = max(ans, l * tmp[del]);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void init() {
ios::sync_with_stdio(false);
cin.tie(0);
}
void test() {
const int INF = 2004;
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> b(m);
for (int i = 0; i < m; i++) cin >> b[i];
int x;
cin >> x;
vector<long long> amin(n + 1, x + 1), bmin(m + 1, x + 1);
for (int i = 0; i < n; i++) {
long long sum = 0;
for (int j = i; j < n; j++) {
sum += a[j];
amin[j - i + 1] = min(amin[j - i + 1], sum);
}
}
for (int i = 0; i < m; i++) {
long long sum = 0;
for (int j = i; j < m; j++) {
sum += b[j];
bmin[j - i + 1] = min(bmin[j - i + 1], sum);
}
}
int mx = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (amin[i] * bmin[j] <= x) {
mx = max(mx, i * j);
}
}
}
cout << mx << '\n';
}
int main() {
init();
test();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long presuma[2005] = {}, presumb[2005] = {};
long long suma[2005], sumb[2005];
int main(int argc, const char* argv[]) {
int n, m;
long long tt;
scanf("%d%d", &n, &m);
int tmp = 0;
for (int i = 1; i <= 2000; i++) suma[i] = sumb[i] = 0x3f3f3f3f;
for (int i = 1; i <= n; i++) {
scanf("%d", &tmp);
presuma[i] = presuma[i - 1] + tmp;
}
for (int i = 1; i <= m; i++) {
scanf("%d", &tmp);
presumb[i] = presumb[i - 1] + tmp;
}
scanf("%lld", &tt);
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++)
suma[i] = min(presuma[j] - presuma[j - i], suma[i]);
}
for (int i = 1; i <= m; i++) {
for (int j = i; j <= m; j++)
sumb[i] = min(presumb[j] - presumb[j - i], sumb[i]);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if ((long long)suma[i] * sumb[j] > tt) break;
ans = max(i * j, ans);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void calcMinSumLength(vector<int>& a, int n, vector<int>& sum_a,
vector<int>& min_sum_len_a) {
for (int i = 0; i < n; ++i) {
int min_sum = 5000000;
for (int j = 1; j <= n - i; ++j)
min_sum = min(min_sum, sum_a[j + i] - sum_a[j - 1]);
min_sum_len_a[i] = min_sum;
}
}
void debug(vector<int>& x, int n) {
for (int i = 0; i < n; ++i) cout << x[i] << " ";
cout << endl;
}
bool canFind(vector<vector<int> >& sum_len_a, vector<vector<int> >& sum_len_b,
int i, int j, int x) {
if (i == 2 && j == 2) return true;
return false;
}
const int MAX = 2005;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
vector<int> a(MAX);
vector<int> b(MAX);
vector<int> sum_a(MAX);
vector<int> sum_b(MAX);
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= m; ++i) cin >> b[i];
int x;
cin >> x;
for (int i = 1; i <= n; ++i) sum_a[i] = sum_a[i - 1] + a[i];
for (int i = 1; i <= m; ++i) sum_b[i] = sum_b[i - 1] + b[i];
vector<int> min_sum_len_a(MAX);
vector<int> min_sum_len_b(MAX);
calcMinSumLength(a, n, sum_a, min_sum_len_a);
calcMinSumLength(b, m, sum_b, min_sum_len_b);
int res = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if ((long long)min_sum_len_a[i] * min_sum_len_b[j] <= x)
res = max(res, (i + 1) * (j + 1));
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
const int mx = 2e3 + 123;
long long sum[mx][mx], a[mx], a1[mx], b[mx], b1[mx], ans = 0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m, x;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
for (int j = 1; j <= m; j++) {
cin >> b[j];
b[j] += b[j - 1];
}
cin >> x;
for (int i = 0; i <= 2e3; i++) a1[i] = b1[i] = inf;
for (int i = 1; i <= n; i++) {
for (int j = n; j - i >= 0; j--) {
a1[i] = min(a1[i], a[j] - a[j - i]);
}
}
for (int i = 1; i <= m; i++) {
for (int j = m; j - i >= 0; j--) {
b1[i] = min(b1[i], b[j] - b[j - i]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
long long d = a1[i] * b1[j];
if (d <= x) ans = max((long long)(i * j), ans);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long sum1[2002], sum2[2002], arr1[2002], arr2[2002], len1[2002],
len2[2002];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
long long n, m, x, ans = 0;
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> arr1[i];
for (int j = 1; j <= m; ++j) {
cin >> arr2[j];
}
vector<long long> arr;
for (int i = 1; i <= n; ++i) sum1[i] = sum1[i - 1] + arr1[i];
for (int j = 1; j <= m; ++j) sum2[j] = sum2[j - 1] + arr2[j];
cin >> x;
fill(len1 + 0, len1 + 2001, 6e9);
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= n - i; ++j)
len1[i] = min(len1[i], sum1[j + i] - sum1[j]);
fill(len2 + 0, len2 + 2001, 6e9);
for (int i = 1; i <= m; ++i)
for (int j = 0; j <= m - i; ++j)
len2[i] = min(len2[i], sum2[j + i] - sum2[j]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (len1[i] * len2[j] <= x) ans = max(ans, (long long)(i * j));
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(0);
long long n, m;
cin >> n >> m;
vector<long long> a, b;
vector<long long> sum1, sum2;
long long prev = 0;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
prev += x;
a.push_back(x);
sum1.push_back(prev);
}
prev = 0;
for (int i = 0; i < m; i++) {
long long x;
cin >> x;
prev += x;
b.push_back(x);
sum2.push_back(prev);
}
long long z;
cin >> z;
vector<long long> dp1, dp2;
for (int l = 1; l <= n; l++) {
long long mini = sum1[l - 1];
for (int i = l; i < sum1.size(); i++) {
mini = min(sum1[i] - sum1[i - l], mini);
}
dp1.push_back(mini);
}
for (int l = 1; l <= m; l++) {
long long mini = sum2[l - 1];
for (int i = l; i < sum2.size(); i++) {
mini = min(sum2[i] - sum2[i - l], mini);
}
dp2.push_back(mini);
}
long long prod = 0;
for (long long i = 0; i < dp1.size(); i++) {
for (long long j = 0; j < dp2.size(); j++) {
if (dp1[i] * dp2[j] <= z) {
prod = max((i + 1) * (j + 1), prod);
}
}
}
cout << prod;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
inline int read_int() {
char c;
int ret = 0, sgn = 1;
do {
c = getchar();
} while ((c < '0' || c > '9') && c != '-');
if (c == '-')
sgn = -1;
else
ret = c - '0';
while ((c = getchar()) >= '0' && c <= '9') ret = ret * 10 + (c - '0');
return sgn * ret;
}
inline long long read_ll() {
char c;
long long ret = 0, sgn = 1;
do {
c = getchar();
} while ((c < '0' || c > '9') && c != '-');
if (c == '-')
sgn = -1;
else
ret = c - '0';
while ((c = getchar()) >= '0' && c <= '9') ret = ret * 10 + (c - '0');
return sgn * ret;
}
inline bool Get_Line(string& s) {
s.clear();
char ch;
while ((ch = getchar()) && ch != '\n' && ch != '\r') {
if (ch == EOF) return false;
s.push_back(ch);
}
return true;
}
int n, m, a[2000 + 5], b[2000 + 5], ans;
long long suma[2000 + 5], sumb[2000 + 5], x, mina[2000 + 5], minb[2000 + 5],
sum;
int main(void) {
n = read_int();
m = read_int();
for (int i = 1; i <= n; ++i) {
a[i] = read_int();
suma[i] = suma[i - 1] + a[i];
}
for (int i = 1; i <= m; ++i) {
b[i] = read_int();
sumb[i] = sumb[i - 1] + b[i];
}
x = read_ll();
fill(mina, mina + 2000 + 5, 0x7fffffff);
fill(minb, minb + 2000 + 5, 0x7fffffff);
for (int i = 1; i <= n; i++) {
sum = 0;
for (int j = i; j <= n; j++) {
sum += a[j];
mina[j - i + 1] = ((mina[j - i + 1]) < (sum) ? (mina[j - i + 1]) : (sum));
}
}
for (int i = 1; i <= m; i++) {
sum = 0;
for (int j = i; j <= m; j++) {
sum += b[j];
minb[j - i + 1] = ((minb[j - i + 1]) < (sum) ? (minb[j - i + 1]) : (sum));
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (mina[i] * minb[j] <= x) ans = ((ans) > (i * j) ? (ans) : (i * j));
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
int main() {
int n, m;
long long x;
scanf("%d%d", &n, &m);
vector<long long> a(n), b(m), pra(n, 0), prb(m, 0);
for (int i = 0; i < n; ++i) {
scanf("%lld", &a[i]);
pra[i] = a[i];
if (i > 0) {
pra[i] += pra[i - 1];
}
}
for (int i = 0; i < m; ++i) {
scanf("%lld", &b[i]);
prb[i] = b[i];
if (i > 0) {
prb[i] += prb[i - 1];
}
}
scanf("%lld", &x);
vector<long long> mina(n), minb(m);
for (int i = 1; i <= n; ++i) {
mina[i - 1] = INF;
for (int j = 0; j <= n - i; ++j) {
long long sum = pra[j + i - 1];
if (j) {
sum -= pra[j - 1];
}
mina[i - 1] = min(mina[i - 1], sum);
}
}
for (int i = 1; i <= m; ++i) {
minb[i - 1] = INF;
for (int j = 0; j <= m - i; ++j) {
long long sum = prb[j + i - 1];
if (j) {
sum -= prb[j - 1];
}
minb[i - 1] = min(minb[i - 1], sum);
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (mina[i] * minb[j] <= x) {
ans = max(ans, (i + 1) * (j + 1));
}
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
map<long long, long long> la;
map<long long, long long> lb;
void label(vector<long long> &arr, long long n, map<long long, long long> &l) {
for (long long i = 1; i <= n; i++) {
long long minVal = INT_MAX;
for (long long j = 0; (j + i) <= n; j++) {
if (j == 0) {
minVal = min(arr[i - 1], minVal);
} else
minVal = min(minVal, arr[j + i - 1] - arr[j - 1]);
}
l[i] = minVal;
}
}
int32_t main() {
long long n, m;
cin >> n >> m;
vector<long long> a(n);
vector<long long> b(m);
for (long long i = 0; i < n; ++i) cin >> a[i];
for (long long i = 0; i < m; ++i) cin >> b[i];
for (long long i = 1; i < n; i++) a[i] += a[i - 1];
for (long long i = 1; i < m; i++) b[i] += b[i - 1];
long long x;
cin >> x;
label(a, n, la);
label(b, m, lb);
long long maxArea = 0;
for (auto an : la) {
for (auto bn : lb) {
if (an.second * bn.second <= x) {
maxArea = max(maxArea, an.first * bn.first);
}
}
}
cout << maxArea;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[2007], b[2007], sum_a[2007], sum_b[2007], fa[2007], fb[2007];
int max(int x, int y) { return x > y ? x : y; }
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m, x, s = 0;
memset(fa, 0x3f3f3f3f, sizeof(fa));
memset(fb, 0x3f3f3f3f, sizeof(fb));
sum_a[0] = sum_b[0] = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum_a[i] = sum_a[i - 1] + a[i];
}
for (int i = 1; i <= m; i++) {
cin >> b[i];
sum_b[i] = sum_b[i - 1] + b[i];
}
cin >> x;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n - i; j++) {
fa[i] = min(fa[i], sum_a[j + i] - sum_a[j]);
}
}
for (int i = 1; i <= m; i++) {
for (int j = 0; j <= m - i; j++) {
fb[i] = min(fb[i], sum_b[j + i] - sum_b[j]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (fa[i] * fb[j] <= x) {
s = max(i * j, s);
}
}
}
cout << s;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops")
using namespace std;
const int inf = numeric_limits<int>::max() / 2;
const long double eps = 1e-9;
const long double pi = acos(-1);
inline void solve(), read();
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
read();
solve();
return 0;
}
int n, m;
vector<int> a, b;
int x;
inline void solve() {
set<pair<int, int> > ma;
for (int i = 0; i < n; i++) {
int s = 0;
for (int j = i; j < n; j++) {
s += a[j];
auto it = ma.lower_bound({s, -inf});
if (it == ma.end() || it->first != s) {
ma.insert({s, j - i + 1});
} else {
if (it->second < j - i + 1) {
ma.erase(it);
ma.insert({s, j - i + 1});
}
}
}
}
vector<pair<int, int> > ps;
int cur = 0;
for (pair<int, int> p : ma) {
(cur) = ((cur) < (p.second)) ? (p.second) : (cur);
ps.push_back({p.first, max(p.second, cur)});
}
int ans = 0;
for (int i = 0; i < m; i++) {
int s = 0;
for (int j = i; j < m; j++) {
s += b[j];
auto it =
upper_bound((ps).begin(), (ps).end(), pair<int, int>(x / s, inf));
if (it == ps.begin()) {
continue;
}
--it;
(ans) = ((ans) < ((j - i + 1) * it->second)) ? ((j - i + 1) * it->second)
: (ans);
}
}
cout << ans << "\n";
}
inline void read() {
cin >> n >> m;
a.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
b.resize(m);
for (int i = 0; i < m; i++) {
cin >> b[i];
}
cin >> x;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int MAXN = 2000;
long long a[MAXN + 1], b[MAXN + 1];
long long mna[MAXN + 1], mnb[MAXN + 1];
int main() {
int i, j, n, m;
ios::sync_with_stdio(false);
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
for (i = 1; i <= m; i++) {
cin >> b[i];
b[i] += b[i - 1];
}
int x;
cin >> x;
for (int len = 1; len <= n; len++) {
mna[len] = INF;
for (i = len; i <= n; i++) {
mna[len] = min(mna[len], a[i] - a[i - len]);
}
}
for (int len = 1; len <= m; len++) {
mnb[len] = INF;
for (i = len; i <= m; i++) {
mnb[len] = min(mnb[len], b[i] - b[i - len]);
}
}
int ans = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (mna[i] * mnb[j] <= x) {
ans = max(ans, i * j);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long qreadInt() {
long long x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') (x *= 10) += (ch - '0'), ch = getchar();
return x;
}
long long qreadLL() {
long long x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') (x *= 10) += (ch - '0'), ch = getchar();
return x;
}
long long a[2010], b[2010];
pair<long long, long long> q[4000010];
map<long long, long long> Map;
signed main() {
long long n = qreadInt(), m = qreadInt();
for (long long i = (1); i <= (n); ++i) a[i] = qreadInt();
for (long long i = (1); i <= (m); ++i) b[i] = qreadInt();
long long x = qreadInt();
for (long long i = (1); i <= (n); ++i) {
long long sum = 0;
for (long long j = (i); j <= (n); ++j) {
sum += a[j];
Map[sum] = max(Map[sum], (j - i + 1));
}
}
long long now = -1, cnt = 0;
for (map<long long, long long>::iterator it = Map.begin(); it != Map.end();
++it)
if (it->second > now) {
now = it->second;
q[++cnt] = make_pair(it->first, it->second);
}
long long Ans = 0;
for (long long i = (1); i <= (m); ++i) {
long long sum = 0;
for (long long j = (i); j <= (m); ++j) {
sum += b[j];
long long Max = x / sum;
long long l = 0, r = cnt;
while (l < r) {
long long mid = (l + r + 1) / 2;
if (q[mid].first <= Max)
l = mid;
else
r = mid - 1;
}
if (l) Ans = max(Ans, (j - i + 1) * q[l].second);
}
}
cout << Ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
long long int a[n], b[m];
for (long long int i = 0; i < n; i++) cin >> a[i];
for (long long int i = 1; i < n; i++) a[i] += a[i - 1];
for (long long int i = 0; i < m; i++) cin >> b[i];
for (long long int i = 1; i < m; i++) b[i] += b[i - 1];
long long int c[n], d[m], tar, ans = 0;
cin >> tar;
for (long long int i = 0; i < n; i++) {
c[i] = LLONG_MAX;
for (long long int j = i; j < n; j++) {
if (j - i == 0)
c[i] = min(c[i], a[j]);
else
c[i] = min(c[i], a[j] - a[j - i - 1]);
}
}
for (long long int i = 0; i < m; i++) {
d[i] = LLONG_MAX;
for (long long int j = i; j < m; j++) {
if (j - i == 0)
d[i] = min(d[i], b[j]);
else
d[i] = min(d[i], b[j] - b[j - i - 1]);
}
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
if (c[i] * d[j] <= tar) ans = max(ans, (i + 1) * (j + 1));
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 6;
long long l[maxn], r[maxn], ans, mx;
int a[maxn], b[maxn];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i] += a[i - 1];
for (int i = 1; i <= m; i++) scanf("%d", &b[i]), b[i] += b[i - 1];
cin >> mx;
for (int i = 1; i <= n; i++) {
l[i] = a[n] + 1;
for (int j = i; j <= n; j++) l[i] = min(l[i], 1ll * (a[j] - a[j - i]));
}
for (int i = 1; i <= m; i++) {
r[i] = b[m] + 1;
for (int j = i; j <= m; j++) r[i] = min(r[i], 1ll * (b[j] - b[j - i]));
}
for (int i = 1; i <= n; i++) {
for (int j = m; j >= 1; j--)
if (l[i] * r[j] <= mx) ans = max(ans, 1ll * (i * j));
}
for (int i = 0; i < m; i++) i++;
for (int i = n + 1000; i >= 0; i--) i--;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 10, MAXN = 1e9;
int a[N], b[N], n, m, x;
vector<pair<int, int>> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
cin >> x;
for (int i = 0; i < m; i++) {
int second = 0;
for (int j = i; j < m; j++) {
second += b[j];
v.push_back({second, j - i + 1});
}
}
sort(v.begin(), v.end());
for (int i = 1; i < v.size(); i++)
if (v[i - 1].second > v[i].second) v[i].second = v[i - 1].second;
int ans = 0;
for (int i = 0; i < n; i++) {
int second = 0;
for (int j = i; j < n; j++) {
second += a[j];
int t =
upper_bound(v.begin(), v.end(), (pair<int, int>){x / second, MAXN}) -
v.begin();
if (t > 0 && (v[t - 1].second * (j - i + 1)) > ans)
ans = v[t - 1].second * (j - i + 1);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2500;
long long n, m, num[MAXN][MAXN], a[MAXN], b[MAXN], MAX, sum_a[MAXN],
sum_b[MAXN];
long long len_a[MAXN], len_b[MAXN];
int main() {
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
sum_a[i] = sum_a[i - 1] + a[i];
}
for (long long i = 1; i <= m; i++) {
cin >> b[i];
sum_b[i] = sum_b[i - 1] + b[i];
}
cin >> MAX;
memset(len_a, 0x3f3f3f, sizeof(len_a));
memset(len_b, 0x3f3f3f, sizeof(len_b));
for (long long i = 1; i <= n; i++)
for (long long j = 1; j + i - 1 <= n; j++) {
len_a[i] = min(len_a[i], sum_a[i + j - 1] - sum_a[j - 1]);
}
for (long long i = 1; i <= m; i++)
for (long long j = 1; j + i - 1 <= m; j++) {
len_b[i] = min(len_b[i], sum_b[i + j - 1] - sum_b[j - 1]);
}
long long ans = 0;
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) {
if (len_a[i] * len_b[j] <= MAX) {
ans = max(ans, i * j);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, a[2002], b[2002], x[2002], y[2002];
long long c[2002], d[2002], f[2002][2002], ans = 0;
int main() {
cin >> n >> m;
for (long long i = 1; i <= n; i++) cin >> a[i], x[i] = x[i - 1] + a[i];
for (long long i = 1; i <= m; i++) cin >> b[i], y[i] = y[i - 1] + b[i];
cin >> k;
for (long long i = 1; i <= n; i++) {
c[i] = 1e18;
for (long long j = 1; j <= n - i + 1; j++) {
c[i] = min(c[i], x[j + i - 1] - x[j - 1]);
}
}
for (long long i = 1; i <= m; i++) {
d[i] = 1e18;
for (long long j = 1; j <= m - i + 1; j++) {
d[i] = min(d[i], y[j + i - 1] - y[j - 1]);
}
}
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) {
if (c[i] * d[j] <= k) {
ans = max(ans, i * j);
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
int n, m, a[N], b[N], x, Ans;
long long s[N], s1[N];
void check(long long sx, int len) {
for (int l = 1, r = 0; r < m; l++) {
while (r < m && sx * (s1[r + 1] - s1[l - 1]) <= x) r++;
Ans = max(Ans, len * (r - l + 1));
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
cin >> x;
if (n > m) swap(n, m), swap(a, b);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i];
for (int i = 1; i <= m; i++) s1[i] = s1[i - 1] + b[i];
for (int i = 1; i <= n; i++) {
long long sum = 1e18;
for (int j = 1; j <= n - i + 1; j++)
sum = min(sum, s[j + i - 1] - s[j - 1]);
check(sum, i);
}
printf("%d\n", Ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
int n, m;
long long a[N], b[N];
long long f[N], g[N];
long long x;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
for (int i = 1; i <= m; ++i) scanf("%lld", &b[i]);
scanf("%lld", &x);
for (int i = 1; i <= n; ++i) f[i] = x + 1;
for (int i = 1; i <= m; ++i) g[i] = x + 1;
for (int i = 1; i <= n; ++i) {
long long sum = 0;
for (int j = i; j <= n; ++j) {
sum += a[j];
f[j - i + 1] = min(f[j - i + 1], sum);
}
}
for (int i = 1; i <= m; ++i) {
long long sum = 0;
for (int j = i; j <= m; ++j) {
sum += b[j];
g[j - i + 1] = min(g[j - i + 1], sum);
}
}
int res = 0;
for (int i = 1, j = m; i <= n; ++i) {
for (; j && f[i] * g[j] > x; --j)
;
if (!j) break;
res = max(res, i * j);
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long aa[2003], bb[2003], a[2003], b[2003], x;
template <typename T>
void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <typename T>
void checkmax(T &a, T b) {
if (b > a) a = b;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
aa[i] = 21000000000000;
}
for (int i = 1; i <= m; ++i) {
bb[i] = 21000000000000;
}
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
a[i] += a[i - 1];
}
for (int i = 1; i <= m; ++i) {
scanf("%lld", &b[i]);
b[i] += b[i - 1];
}
scanf("%lld", &x);
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= n; ++j) {
checkmin(aa[j - i + 1], a[j] - a[i - 1]);
}
}
for (int i = 1; i <= m; ++i) {
for (int j = i; j <= m; ++j) {
checkmin(bb[j - i + 1], b[j] - b[i - 1]);
}
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (aa[i] * bb[j] <= x) {
checkmax(ans, i * j);
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2000 + 100;
const long long INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lowbit(long long x) { return x & -x; }
long long a[maxn];
long long b[maxn];
long long ss[maxn];
long long tt[maxn];
int32_t main() {
long long n, m;
cin >> n >> m;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= m; i++) cin >> b[i];
long long x;
cin >> x;
for (long long i = 1; i <= n; i++) {
long long k = 0;
for (long long j = 1; j <= i; j++) k += a[j];
ss[i] = k;
for (long long j = i + 1; j <= n; j++) {
k += a[j];
k -= a[j - i];
if (k < ss[i]) ss[i] = k;
}
}
for (long long i = 1; i <= m; i++) {
long long k = 0;
for (long long j = 1; j <= i; j++) k += b[j];
tt[i] = k;
for (long long j = i + 1; j <= m; j++) {
k += b[j], k -= b[j - i];
if (k < tt[i]) tt[i] = k;
}
}
long long ans = 0;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (ss[i] * tt[j] <= x) {
ans = max(ans, i * j);
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
const int MAXN = 10000000;
int main() {
int n = 0, m = 0;
std::cin >> n >> m;
int a[n], b[m];
for (int i = 0; i < n; ++i) std::cin >> a[i];
for (int i = 0; i < m; ++i) std::cin >> b[i];
int La[n + 1];
int Lb[m + 1];
for (int i = 0; i <= n; ++i) La[i] = MAXN;
for (int i = 0; i <= m; ++i) Lb[i] = MAXN;
int suma[n + 1];
int sumb[m + 1];
suma[0] = sumb[0] = 0;
for (int i = 1; i <= n; ++i) suma[i] = suma[i - 1] + a[i - 1];
for (int i = 1; i <= m; ++i) sumb[i] = sumb[i - 1] + b[i - 1];
for (int len = 0; len <= n; ++len)
for (int i = 0; i <= n - len; ++i)
La[len] = std::min(La[len], suma[i + len] - suma[i]);
for (int len = 0; len <= m; ++len)
for (int i = 0; i <= m - len; ++i)
Lb[len] = std::min(Lb[len], sumb[i + len] - sumb[i]);
int x = 0;
std::cin >> x;
int s = 0;
for (int i = 1; i <= n; ++i) {
int j = static_cast<int>(std::upper_bound(Lb, Lb + m + 1, x / La[i]) - Lb);
if (j > 0 && (i * (j - 1) > s)) s = i * (j - 1);
}
std::cout << s << "\n";
}
|
#include <bits/stdc++.h>
long long int a[2100], b[2100], n, i, j, m, k, d[10000000], f[10000000], x, y,
z = 0;
int main() {
while (scanf("%lld %lld", &n, &m) != EOF) {
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
for (i = 1; i <= m; i++) {
scanf("%lld", &b[i]);
}
scanf("%lld", &k);
for (i = 1; i <= n; i++) {
a[i] = a[i] + a[i - 1];
}
for (i = 1; i <= m; i++) {
b[i] = b[i] + b[i - 1];
}
for (i = 1; i <= n; i++) {
d[i] = 300000000;
for (j = 1; j <= n; j++) {
if (i + j - 1 > n) {
break;
}
x = a[i + j - 1] - a[j - 1];
if (x < d[i]) {
d[i] = x;
}
}
}
for (i = 1; i <= m; i++) {
f[i] = 300000000;
for (j = 1; j <= m; j++) {
if (i + j - 1 > m) {
break;
}
y = b[i + j - 1] - b[j - 1];
if (y < f[i]) {
f[i] = y;
}
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (d[i] * f[j] <= k) {
if (i * j * 1 > z) {
z = i * j * 1;
}
if (i * j * 1 <= z) {
continue;
}
}
}
}
printf("%lld", z);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[2005], b[2005];
long long len[2005], sa[2005], sb[2005], ans, x;
int main() {
memset(len, 0x7f, sizeof len);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i], sa[i] = sa[i - 1] + 1ll * a[i];
for (int i = 1; i <= m; i++) cin >> b[i], sb[i] = sb[i - 1] + 1ll * b[i];
for (int i = 1; i <= n; i++) {
for (int l = 1, r = i; r <= n; l++, r++) {
len[i] = min(len[i], sa[r] - sa[l - 1]);
}
}
cin >> x;
for (long long i = 1; i <= n; i++) {
long long l = 1, r = 1;
for (l = 1; l <= m; l++) {
while (len[i] * (sb[r] - sb[l - 1]) <= x && r <= m) {
ans = max(ans, i * (r - l + 1));
r++;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)3e18;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
vector<long long> a(n), b(m);
vector<pair<long long, long long> > v;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < m; i++) {
cin >> b[i];
}
for (long long i = 0; i < n; i++) {
long long s = 0;
for (long long j = i; j < n; j++) {
s += a[j];
v.push_back({s, (j - i + 1)});
}
}
sort(v.begin(), v.end());
for (long long i = 1; i < v.size(); i++) {
v[i].second = max(v[i - 1].second, v[i].second);
}
long long x;
cin >> x;
long long ans = 0;
for (long long i = 0; i < m; i++) {
long long s = 0;
for (long long j = i; j < m; j++) {
s += b[j];
long long t = x / s;
pair<long long, long long> t1 = {t, INF};
int pos = upper_bound(v.begin(), v.end(), t1) - v.begin();
pos--;
if (pos < 0) continue;
ans = max(ans, ((v[pos].second) * (j - i + 1)));
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
void precompute(int* A, int N, int* lA) {
for (int l = (1); l < (N + 1); ++l) {
int S = 0;
lA[l] = 2e9 + 10;
for (int j = 0; j < (N); ++j) {
S += A[j];
if (j >= l) S -= A[j - l];
if (j >= l - 1) lA[l] = min(lA[l], S);
}
}
}
int N, M;
int A[2000], B[2000];
int lA[2005], lB[2005];
int main() {
scanf("%d%d", &N, &M);
for (int i = 0; i < (N); ++i) scanf("%d", &A[i]);
for (int i = 0; i < (M); ++i) scanf("%d", &B[i]);
int X;
scanf("%d", &X);
precompute(A, N, lA);
precompute(B, M, lB);
int result = 0;
for (int i = (1); i < (N + 1); ++i)
for (int j = (1); j < (M + 1); ++j)
if (lA[i] * (long long)lB[j] <= X) result = max(result, i * j);
printf("%d\n", result);
}
|
#include <bits/stdc++.h>
using namespace std;
int a[2010], aa[2010], b[2010];
int bb[4000010];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, x;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
for (int j = 0; j < i; j++) {
if (aa[i - j] == 0) aa[i - j] = a[i] - a[j];
aa[i - j] = min(aa[i - j], a[i] - a[j]);
}
}
for (int i = 1; i <= m; i++) {
cin >> b[i];
b[i] += b[i - 1];
for (int j = 0; j <= i; j++) {
bb[b[i] - b[j]] = max(bb[b[i] - b[j]], i - j);
}
}
cin >> x;
for (int i = 1; i < 4000010; i++) {
bb[i] = max(bb[i], bb[i - 1]);
}
int ans = 0;
for (int len = 1; len <= n; len++) {
ans = max(ans, len * bb[min(4000000, x / aa[len])]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > v, t;
vector<long long int> u;
long long int bin(long long int f) {
long long int low = 0, high = t.size() - 1, mid;
while (low <= high) {
mid = (low + high) / 2;
if (f >= t[mid].first) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return low;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int n, m, i, sum, j, e, tx, ty, f, x, maxx = 0, y = 0;
cin >> n >> m;
long long int ara[n];
for (i = 0; i < n; i++) {
cin >> ara[i];
}
for (i = 0; i < n; i++) {
sum = 0;
for (j = i; j < n; j++) {
sum += ara[j];
v.push_back(make_pair(j - i + 1, sum));
}
}
long long int tak[m];
for (i = 0; i < m; i++) {
cin >> tak[i];
}
for (i = 0; i < m; i++) {
sum = 0;
for (j = i; j < m; j++) {
sum += tak[j];
t.push_back(make_pair(sum, j - i + 1));
}
}
cin >> f;
sort(t.begin(), t.end());
pair<long long int, long long int> pq;
for (i = 0; i < t.size(); i++) {
pq = t[i];
maxx = max(maxx, pq.second);
u.push_back(maxx);
}
for (i = 0; i < v.size(); i++) {
pq = v[i];
tx = pq.second;
ty = f / tx;
x = bin(ty);
if (x - 1 >= 0) {
y = max(y, u[x - 1] * pq.first);
}
}
cout << y << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int a[2010], b[2010];
int c[2010 * 2010];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= m; ++i) scanf("%d", &b[i]);
int X;
scanf("%d", &X);
for (int i = 1; i <= m; ++i) {
int x = 0;
for (int j = i; j <= m; ++j) {
x += b[j];
c[x] = max(c[x], j - i + 1);
}
}
for (int i = 1; i <= 2000 * 2000; ++i) c[i] = max(c[i - 1], c[i]);
int Ans = 0;
for (int i = 1; i <= n; ++i) {
int x = 0;
for (int j = i; j <= n; ++j) {
x += a[j];
int y = X / x;
if (y > 2000 * 2000) y = 2000 * 2000;
Ans = max(Ans, c[y] * (j - i + 1));
}
}
printf("%d\n", Ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
char c = getchar();
int sgn = 1;
while (c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
x *= sgn;
}
template <typename T>
void out(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x >= 10) out(x / 10);
putchar(x % 10 + '0');
}
long long a[2005];
long long b[2005];
long long suma[2005];
long long sumb[2005];
long long mina[2005];
long long minb[2005];
int main() {
int n, m;
read(n), read(m);
for (int i = 1; i <= n; i++) {
read(a[i]);
suma[i] = suma[i - 1] + a[i];
}
for (int i = 1; i <= m; i++) {
read(b[i]);
sumb[i] = sumb[i - 1] + b[i];
}
long long k;
read(k);
memset(mina, 0x3f, sizeof(mina));
memset(minb, 0x3f, sizeof(minb));
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
mina[j - i + 1] = min(mina[j - i + 1], suma[j] - suma[i - 1]);
for (int i = 1; i <= m; i++)
for (int j = i; j <= m; j++)
minb[j - i + 1] = min(minb[j - i + 1], sumb[j] - sumb[i - 1]);
long long s = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (mina[i] * minb[j] <= k) s = max(s, 1LL * i * j);
}
out(s), putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[2005], b[2005], suma[2005], sumb[2005], c[2005];
int n, m, x;
int search(int num) {
int l = 1, r = n;
int mid = (l + r) >> 1;
while (l <= r) {
mid = (l + r) >> 1;
if ((long long)c[mid] * num == x) return mid;
if ((long long)c[mid] * num < x)
l = mid + 1;
else
r = mid - 1;
}
return r;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
suma[i] = suma[i - 1] + a[i];
}
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]);
sumb[i] = sumb[i - 1] + b[i];
}
scanf("%d", &x);
memset(c, 0x3f, sizeof(c));
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++)
c[j - i + 1] = min(c[j - i + 1], suma[j] - suma[i - 1]);
int ans = 0;
for (int i = 1; i <= m; i++)
for (int j = i; j <= m; j++) {
int res = search(sumb[j] - sumb[i - 1]);
ans = max(ans, res * (j - i + 1));
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long Maxn = 2010;
const long long inf = 1ll << 60;
long long a[Maxn], b[Maxn], n, m;
long long le[Maxn];
long long X, ans;
long long _min(long long x, long long y) { return x < y ? x : y; }
long long _max(long long x, long long y) { return x > y ? x : y; }
int main() {
long long i, j, k;
scanf("%I64d%I64d", &n, &m);
for (i = 1; i <= n; i++) scanf("%I64d", &a[i]);
for (i = 1; i <= m; i++) scanf("%I64d", &b[i]);
for (i = 1; i <= m; i++) le[i] = inf;
scanf("%I64d", &X);
for (i = 1; i <= m; i++) {
long long sum = 0;
for (j = i; j >= 1; j--) {
sum += b[j];
le[i - j + 1] = _min(le[i - j + 1], sum);
}
}
for (i = 1; i <= n; i++) {
long long sum = 0;
for (j = i; j >= 1; j--) {
sum += a[j];
if (X / sum < le[1]) break;
long long x = upper_bound(le + 1, le + m + 1, X / sum) - le - 1;
ans = _max(ans, (i - j + 1) * x);
}
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2000;
int n, m;
ll x;
ll a[N + 5];
ll b[N + 5];
ll mina[N + 5];
ll minb[N + 5];
int main() {
std::ios::sync_with_stdio(false);
while (cin >> n >> m) {
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
mina[i] = i * 2000;
}
for (int i = 1; i <= m; i++) {
cin >> b[i];
b[i] += b[i - 1];
minb[i] = i * 2000;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
mina[j - i] = min(mina[j - i], a[j] - a[i]);
}
}
for (int i = 0; i < m; i++) {
for (int j = i + 1; j <= m; j++) {
minb[j - i] = min(minb[j - i], b[j] - b[i]);
}
}
cin >> x;
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (mina[i] * minb[j] <= x) {
ans = max(ans, i * j);
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x;
}
long long n, m, x, a[5005], b[5005], cnt, num[5005], ans, sum[5005], suma[5005],
sumb[5005];
int main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) a[i] = read(), sum[i] = sum[i - 1] + a[i];
for (int i = 1; i <= m; i++) b[i] = read(), num[i] = num[i - 1] + b[i];
x = read();
memset(suma, 0x7f, sizeof(suma));
memset(sumb, 0x7f, sizeof(sumb));
for (int i = 1; i <= n; i++) {
for (int j = 1; j + i - 1 <= n; j++) {
suma[i] = min(suma[i], sum[j + i - 1] - sum[j - 1]);
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j + i - 1 <= m; j++) {
sumb[i] = min(sumb[i], num[j + i - 1] - num[j - 1]);
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (suma[i] * sumb[j] <= x) {
ans = max(ans, i * j);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, int> > c, d;
int main() {
int n, m;
cin >> n >> m;
long long int a[n], b[m];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
long long x;
cin >> x;
for (int i = 0; i < n; i++) {
long long temp = 0;
for (int j = i; j < n; j++) {
temp += a[j];
c.push_back({temp, (j - i + 1)});
}
}
sort(c.begin(), c.end());
for (int i = 0; i < m; i++) {
long long temp = 0;
for (int j = i; j < m; j++) {
temp += b[j];
d.push_back({temp, (j - i + 1)});
}
}
sort(d.begin(), d.end());
int ans[d.size()];
ans[0] = d[0].second;
for (int i = 1; i < d.size(); i++) {
ans[i] = max(ans[i - 1], d[i].second);
}
int ans1 = 0;
int j = d.size() - 1;
for (int i = 0; i < c.size(); i++) {
long long temp = c[i].first;
while (j >= 0 && temp * d[j].first > x) j--;
if (j < 0) continue;
ans1 = max(ans1, ans[j] * c[i].second);
}
cout << ans1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
namespace chtholly {
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) f ^= c == '-';
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return f ? x : -x;
}
template <typename mitsuha>
inline bool read(mitsuha &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c) && ~c; c = getchar()) f ^= c == '-';
if (!~c) return 0;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return x = f ? x : -x, 1;
}
template <typename mitsuha>
inline int write(mitsuha x) {
if (!x) return 0 & putchar(48);
if (x < 0) x = -x, putchar('-');
int bit[20], i, p = 0;
for (; x; x /= 10) bit[++p] = x % 10;
for (i = p; i; --i) putchar(bit[i] + 48);
return 0;
}
inline char fuhao() {
char c = getchar();
for (; isspace(c); c = getchar())
;
return c;
}
} // namespace chtholly
using namespace chtholly;
using namespace std;
const int aoi = 2048, mulu = 4e6;
int a[aoi], b[aoi], dp[mulu | 10];
int main() {
int i, j, n = read(), m = read();
for (i = 1; i <= n; ++i) a[i] = read() + a[i - 1];
for (i = 1; i <= m; ++i) b[i] = read() + b[i - 1];
int x = read(), l = 1, r = 0;
for (i = 1; i <= n; ++i)
for (j = i; j <= n; ++j)
dp[a[j] - a[i - 1]] = max(dp[a[j] - a[i - 1]], j - i + 1);
for (i = 1; i <= mulu; ++i) dp[i] = max(dp[i - 1], dp[i]);
int llx = 0;
for (i = 1; i <= m; ++i) {
for (j = i; j <= m; ++j) {
int tmp = x / (b[j] - b[i - 1]);
llx = max(llx, dp[min(tmp, mulu)] * (j - i + 1));
}
}
write(llx);
}
|
#include <bits/stdc++.h>
using namespace std;
long long sumx[2010], sumy[2010], minx[2010], miny[2010];
long long read() {
int k = 0, f = 1;
char c = getchar();
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = -1;
for (; c >= '0' && c <= '9'; c = getchar()) k = k * 10 + c - 48;
return k * f;
}
int main() {
int n = read(), m = read();
memset(minx, 127, sizeof(minx)), memset(miny, 127, sizeof(miny));
for (int i = 1; i <= n; i++) sumx[i] = sumx[i - 1] + read();
for (int i = 1; i <= m; i++) sumy[i] = sumy[i - 1] + read();
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
minx[i] = min(minx[i], sumx[j] - sumx[j - i]);
}
}
for (int i = 1; i <= m; i++) {
for (int j = i; j <= m; j++) {
miny[i] = min(miny[i], sumy[j] - sumy[j - i]);
}
}
int x = read(), ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (minx[i] * miny[j] <= x) ans = max(ans, i * j);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 5005;
const long long int mod1 = 998244353;
const long long int mod = 1e9 + 7;
struct dat {
long long int l, r, i;
};
bool cmp(dat a, dat b) { return a.r < b.r; }
long long int a[N];
long long int b[N];
long long int s1[N];
long long int s2[N];
long long int n, m, x;
void solve() {
cin >> n >> m;
for (int i = (1); i <= (n); ++i) cin >> a[i];
for (int i = (1); i <= (m); ++i) cin >> b[i];
cin >> x;
for (int i = (1); i <= (n); ++i) s1[i] = a[i] + s1[i - 1];
for (int i = (1); i <= (m); ++i) s2[i] = b[i] + s2[i - 1];
long long int ans = 0;
for (int i = (1); i <= (n); ++i) {
long long int sum = 1e10;
for (int j = (1); j <= (n - i + 1); ++j)
sum = min(sum, s1[j + i - 1] - s1[j - 1]);
if (sum <= x) {
for (int k = 1; k <= m; ++k) {
if (sum * b[k] <= x) {
long long int l = k, r = m + 1;
while (r - l > 1) {
long long int mid = (l + r) / 2;
if ((s2[mid] - s2[k - 1]) * sum <= x)
l = mid;
else
r = mid;
}
ans = max(ans, i * (l - k + 1));
}
}
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.