text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n], b[n];
long long s1 = 0, s2 = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
s1 = s1 + a[i];
}
for (long long i = 0; i < n; i++) {
cin >> b[i];
s2 = s2 + b[i];
}
if (s2 <= s1)
cout << "Yes";
else
cout << "No\n";
return 0;
}
|
#include <bits/stdc++.h>
int main(void) {
int n;
long z1 = 0, z2 = 0;
int i, t;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &t);
z1 += t;
}
for (i = 0; i < n; i++) {
scanf("%d", &t);
z2 += t;
}
if (z1 >= z2)
printf("Yes");
else
printf("No");
return 0;
}
|
#include <bits/stdc++.h>
int n, a, b, x;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &x);
a += x;
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &x);
b += x;
}
if (a < b)
puts("No");
else
puts("Yes");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 100 + 10;
const long long mod = 1e9 + 7;
int x[maxn], y[maxn];
int main() {
int n, sum1 = 0, sum2 = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x[i]);
sum1 += x[i];
}
for (int i = 1; i <= n; i++) {
scanf("%d", &y[i]);
sum2 += y[i];
}
if (sum1 >= sum2) {
printf("Yes\n");
} else
printf("No\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int MAXN = 1e5 + 10;
int main() {
int n, k;
int sum1 = 0, sum2 = 0;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &k);
sum1 += k;
}
for (int i = 0; i < n; ++i) {
scanf("%d", &k);
sum2 += k;
}
if (sum1 >= sum2)
printf("Yes\n");
else
printf("No\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long M = 1e9 + 7;
double pi = acos(-1.0);
long long powerm(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = (res * x) % M;
y = y >> 1;
x = (x * x) % M;
}
return res % M;
}
long long power(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long gcd(long long a, long long b) {
if (b > a) return gcd(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int sm = 0;
for (int i = 0; i < n; i++) {
int p;
cin >> p;
sm += p;
}
for (int i = 0; i < n; i++) {
int p;
cin >> p;
sm -= p;
}
if (sm >= 0)
cout << "Yes";
else
cout << "No";
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int i, n, x = 0, y = 0, k;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &k);
x += k;
}
for (i = 0; i < n; i++) {
scanf("%d", &k);
y += k;
}
if (x < y)
printf("No\n");
else
printf("Yes\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
int sum1 = 0, sum2 = 0;
for (int i = 0; i < n; i++) {
int val;
cin >> val;
sum1 += val;
}
for (int i = 0; i < n; i++) {
int val;
cin >> val;
sum2 += val;
}
if (sum1 < sum2) {
cout << "No" << '\n';
} else {
cout << "Yes" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, s1 = 0, s2 = 0;
int x[51], y[51];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i];
s1 += x[i];
}
for (int i = 1; i <= n; i++) {
cin >> y[i];
s2 += y[i];
}
if (s1 >= s2)
cout << "Yes\n";
else
cout << "No\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, sum = 0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(2);
cin >> N;
for (int i = 0; i < N; i++) {
int x;
cin >> x;
sum += x;
}
for (int i = 0; i < N; i++) {
int x;
cin >> x;
sum -= x;
}
if (sum >= 0)
cout << "Yes\n";
else
cout << "No\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long mod = 1e9 + 7;
const unsigned long long inf = 1e15;
const int N = 300005;
void solve() {
int n;
cin >> n;
int sum1 = 0;
int sum2 = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
sum1 += x;
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
sum2 += x;
}
string ans = "Yes";
if (sum1 < sum2) ans = "No";
cout << ans;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int MAX = 4007;
const int MAX2 = 1000000;
const int MAXD = 20;
const int BASE = 1000000007;
const int MOD = 1000000007;
const int psz = 2000006;
int chToIn(char a) {
int b;
b = a - '0';
return b;
}
int stToIn(string a) {
int b;
b = atoi(a.c_str());
return b;
}
string appendChar(string s, char a) {
s.append(1, a);
return s;
}
int gcd(int a, int b) { return (b == 0 ? a : gcd(b, a % b)); }
int lcm(int a, int b) { return (a * (b / gcd(a, b))); }
string rev(string a) {
int siz = (int)a.size();
string res = "";
for (int i = (siz)-1; i >= (0); --i) {
res += a[i];
}
return res;
}
int main(int argc, char const *argv[]) {
int n;
cin >> n;
vector<int> a, b;
int suma = 0, sumb = 0;
for (int i = 0; i < n; i++) {
int num;
cin >> num;
a.push_back(num);
suma += num;
}
for (int i = 0; i < n; i++) {
int num;
cin >> num;
b.push_back(num);
sumb += num;
}
if (sumb > suma)
puts("No");
else
puts("Yes");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int ar[n], ar1[n];
int s = 0, s1 = 0;
for (int i = 0; i < n; i++) {
cin >> ar[i];
s += ar[i];
}
for (int i = 0; i < n; i++) {
cin >> ar1[i];
s1 += ar1[i];
}
if (s >= s1)
cout << "Yes";
else
cout << "No";
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int sumX = 0, sumY = 0;
int a;
for (int i = 0; i < n; i++) {
scanf("%d", &a);
sumX += a;
}
for (int i = 0; i < n; i++) {
scanf("%d", &a);
sumY += a;
}
if (sumY > sumX)
printf("NO");
else
printf("YES");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct pat {
int x, y;
pat(int x = 0, int y = 0) : x(x), y(y) {}
bool operator<(const pat &p) const { return x == p.x ? y < p.y : x < p.x; }
};
namespace RKK {
const int N = 100011;
int n, qaq;
char str[N];
int s[N];
int nxt[N][26], pre[N][26];
int f[N][26], g[N];
int mp[27];
int dfs(int l, int r, int c, int tp) {
if (l > r) return 0;
if (~mp[c]) return mp[c];
int mex[50] = {0};
for (int i = 0, pl, pr; i < 26; i++) {
pl = nxt[l - 1][i], pr = pre[r + 1][i];
if (pr < l) continue;
int t = g[pl] ^ g[pr];
t ^= tp ? f[pl - 1][c] : dfs(l, pl - 1, i, 0);
t ^= tp ? dfs(pr + 1, r, i, 1) : f[r][i];
mex[t] = 1;
}
for (int i = 0; i < 50; i++)
if (!mex[i]) return mp[c] = i;
return -1;
}
int main() {
scanf("%s", str + 1), n = strlen(str + 1);
for (int i = 1; i <= n; i++) s[i] = str[i] - 'a';
for (int i = 0; i < 26; i++) pre[1][i] = 0;
for (int i = 2; i <= n + 1; i++)
memcpy(pre[i], pre[i - 1], 26 * 4), pre[i][s[i - 1]] = i - 1;
for (int i = 0; i < 26; i++) nxt[n][i] = n + 1;
for (int i = n - 1; ~i; i--)
memcpy(nxt[i], nxt[i + 1], 26 * 4), nxt[i][s[i + 1]] = i + 1;
for (int i = 1; i <= n; i++) {
g[i] = g[pre[i][s[i]]] ^ f[i - 1][s[i]];
memset(mp, 0xff, sizeof(mp));
for (int j = 0; j < 26; j++) f[i][j] = dfs(pre[i + 1][j] + 1, i, j, 1);
}
scanf("%d", &qaq);
for (int rkk = 1, l, r; rkk <= qaq; rkk++) {
scanf("%d%d", &l, &r);
memset(mp, 0xff, sizeof(mp));
puts(dfs(l, r, 26, 0) ? "Alice" : "Bob");
}
return 0;
}
} // namespace RKK
int main() { return RKK::main(); }
|
#include <bits/stdc++.h>
using namespace std;
int pr[30][100010], su[30][100010], ho[30][100010], qi[30][100010], qu[100010],
q, l, x, y;
string s;
int que(int l, int r);
int quepr(int x, int y) {
if (pr[y][x] == -1) pr[y][x] = que(qi[y][x], x);
return pr[y][x];
}
int quesu(int x, int y) {
if (su[y][x] == -1) su[y][x] = que(x, ho[y][x]);
return su[y][x];
}
int que1(int x, int y) {
if (qu[x] == -1) {
qu[x] = que1(qi[y][x], y) ^ quepr(x, y);
}
return qu[x];
}
int que(int l, int r) {
int p = 0;
for (int i = 0; i <= 26; i++) {
if (ho[i][l] >= r) continue;
p = p | (1 << (quepr(r, i) ^ quesu(l, i) ^ que1(ho[i][l], i) ^
que1(qi[i][r], i)));
}
for (int i = 0; i <= 27; i++)
if ((p & (1 << i)) == 0) return i;
}
int main() {
cin >> s;
int l = s.length();
for (int i = 0; i <= 26; i++) {
int la = 0;
for (int j = 0; j <= l + 1; j++) {
qi[i][j] = la;
if (s[j - 1] - 'a' + 1 == i || (j == l + 1 && i == 0)) la = j;
}
}
for (int i = 0; i <= 26; i++) {
int la = l + 1;
for (int j = l + 1; j >= 0; j--) {
ho[i][j] = la;
if (s[j - 1] - 'a' + 1 == i || (j == 0 && i == 0)) la = j;
}
}
for (int i = 0; i <= 26; i++)
for (int j = 0; j <= l + 1; j++) pr[i][j] = su[i][j] = -1;
for (int i = 1; i <= l; i++) qu[i] = -1;
cin >> q;
while (q--) {
cin >> x >> y;
if (que(x - 1, y + 1))
cout << "Alice" << endl;
else
cout << "Bob" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, U = 26;
char s[N];
int n, ap[2][N][U], dp[2][N][U], pre_sum[N];
int q[U];
int F(int l, int r) {
if (l == 0 && r == 4) int yyx = 1;
int s = 0;
for (int c = 0; c <= U - 1; ++c)
if (ap[1][r - 1][c] > l)
s |= 1 << (dp[0][l][c] ^ dp[1][r][c] ^ pre_sum[ap[1][r - 1][c]] ^
pre_sum[ap[0][l + 1][c]]);
int i = 0;
while (s & (1 << i)) ++i;
return i;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) s[i] -= 'a';
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= U - 1; ++j) ap[1][i][j] = ap[1][i - 1][j];
ap[1][i][s[i]] = i;
}
for (int j = 0; j <= U - 1; ++j) ap[0][n + 1][j] = n + 1;
for (int i = n; i >= 1; --i) {
for (int j = 0; j <= U - 1; ++j) ap[0][i][j] = ap[0][i + 1][j];
ap[0][i][s[i]] = i;
}
for (int i = 1; i <= n + 1; ++i) {
for (int j = 0; j <= U - 1; ++j) q[j] = ap[1][i - 1][j];
sort(q, q + U);
int tail = U - 1;
if (i <= n) {
int i0 = ap[1][i - 1][s[i]];
for (int j = i - 1; j >= i0; --j) {
dp[0][j][s[i]] = F(j, i);
if (j && j == q[tail]) {
dp[1][i][s[j]] = dp[0][j][s[i]];
--tail;
}
}
pre_sum[i] = pre_sum[i0] ^ dp[0][i0][s[i]];
}
for (; tail >= 0; --tail) {
int j = q[tail];
if (!j) break;
dp[1][i][s[j]] = F(j, i);
}
}
int m;
cin >> m;
while (m--) {
int l, r;
scanf("%d%d", &l, &r);
puts(F(l - 1, r + 1) ? "Alice" : "Bob");
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long qpow(long long x, long long k, long long mod) {
long long ret = 1;
while (k) {
if (k & 1) {
ret = ret * x;
ret = ret % mod;
}
x = x * x;
x = x % mod;
k = (k >> 1);
}
return ret;
}
const int Maxn = 1e5 + 5;
char s[Maxn];
int n;
int pre[Maxn][26], nxt[Maxn][26];
int sum[Maxn], lsum[Maxn][26], rsum[Maxn][26];
bool flag[26];
int grundy(int l, int r) {
memset(flag, false, sizeof(flag));
for (int i = 0; i < 26; i++) {
int p1 = nxt[l][i], p2 = pre[r][i];
if (p1 > p2) continue;
int val = (rsum[l][i] ^ sum[p2] ^ sum[p1] ^ lsum[r][i]);
flag[val] = true;
}
for (int i = 0; i < 26; i++)
if (!flag[i]) return i;
return 26;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) s[i] -= 'a';
s[0] = s[n + 1] = -1;
vector<pair<int, int> > seg;
for (int j = 0; j < 26; j++) pre[0][j] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) {
pre[i][j] = (j == s[i]) ? i : pre[i - 1][j];
seg.push_back(pair<int, int>(i, -pre[i][j] - 1));
}
}
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] = (j == s[i]) ? i : nxt[i + 1][j];
seg.push_back(pair<int, int>(nxt[i][j] - 1, -i));
}
}
sort((seg).begin(), (seg).end());
seg.resize(unique((seg).begin(), (seg).end()) - seg.begin());
for (auto v : seg) {
int l = -v.second, r = v.first;
int x = grundy(l, r);
if (s[l - 1] >= 0 && s[l - 1] == s[r + 1]) {
sum[r + 1] = (sum[l - 1] ^ x);
}
if (s[l - 1] >= 0 && pre[r][s[l - 1]] == l - 1) {
lsum[r][s[l - 1]] = x;
}
if (s[r + 1] >= 0 && nxt[l][s[r + 1]] == r + 1) {
rsum[l][s[r + 1]] = x;
}
}
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d%d", &l, &r);
if (grundy(l, r))
puts("Alice");
else
puts("Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100, D = 26;
char s[N];
int pr[N][D], nt[N][D], pref[N][D], suf[N][D], sum[N];
bool used[D + 1];
int calc(int l, int r) {
if (l > r) return 0;
fill(used, used + D + 1, 0);
for (int i = 0; i < 26; i++) {
int x = nt[l][i], y = pr[r][i];
if (x <= r) {
used[sum[y] ^ sum[x] ^ suf[l][i] ^ pref[r][i]] = 1;
}
}
int t = 0;
while (used[t]) t++;
return t;
}
int main() {
scanf(" %s", s);
int n = strlen(s);
for (int i = n; i > 0; i--) s[i] = s[i - 1] - 'a';
for (int i = 1; i <= n; i++) {
for (int j = 0; j < D; j++) {
pr[i][j] = pr[i - 1][j];
}
pr[i][s[i]] = i;
}
fill(nt[n + 1], nt[n + 1] + D, n + 1);
for (int i = n; i > 0; i--) {
for (int j = 0; j < D; j++) {
nt[i][j] = nt[i + 1][j];
}
nt[i][s[i]] = i;
}
for (int i = 1; i <= n; i++) {
sum[i] = sum[pr[i - 1][s[i]]] ^ pref[i - 1][s[i]];
for (int j = i - 1; j > pr[i - 1][s[i]]; j--) {
suf[j][s[i]] = calc(j, i - 1);
}
vector<pair<int, int>> v;
for (int j = 0; j < D; j++) {
if (pr[i][j] != i) v.push_back({pr[i][j] + 1, j});
}
sort(v.rbegin(), v.rend());
for (auto p : v) {
pref[i][p.second] = calc(p.first, i);
}
}
int m;
scanf("%d", &m);
while (m--) {
int l, r;
scanf("%d%d", &l, &r);
printf("%s\n", calc(l, r) ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 14, z = 26;
enum CacheType { No, L, R };
int n, nxt[z][maxn];
string s;
vector<int> where[z], pxor[z];
struct Grundy {
int seen;
Grundy() : seen(0) {}
void add(int i) { seen |= 1 << i; }
int get() { return __builtin_ctz(~seen); }
};
struct Cacher {
vector<int> save[2][maxn];
int ask(int l, int r) {
if (save[0][l].size() > r - l && save[0][l][r - l] != -1)
return save[0][l][r - l];
if (save[1][r].size() > r - l && save[1][r][r - l] != -1)
return save[1][r][r - l];
return -1;
}
void cache(int l, int r, CacheType c, int ans) {
if (c == No) return;
if (c == L) {
while (save[0][l].size() <= r - l) save[0][l].push_back(-1);
save[0][l][r - l] = ans;
} else {
while (save[1][r].size() <= r - l) save[1][r].push_back(-1);
save[1][r][r - l] = ans;
}
}
} cacher;
int solve(int l, int r, CacheType c = No) {
if (l == r) return 0;
if (cacher.ask(l, r) != -1) return cacher.ask(l, r);
Grundy g;
for (char c = 0; c < z; c++) {
int s = nxt[c][l];
int e = nxt[c][r];
if (s != e)
g.add(solve(l, where[c][s], R) ^ pxor[c][s] ^ pxor[c][e - 1] ^
solve(where[c][e - 1] + 1, r, L));
}
cacher.cache(l, r, c, g.get());
return g.get();
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> s;
n = s.size();
for (int c = 0; c < z; c++)
for (int i = 1; i <= n; i++)
nxt[c][i] = (s[i - 1] == c + 'a') + nxt[c][i - 1];
fill(pxor, pxor + z, vector<int>(1));
for (int i = 0; i < n; i++) {
if (where[s[i] - 'a'].size())
pxor[s[i] - 'a'].push_back(pxor[s[i] - 'a'].back() ^
solve(where[s[i] - 'a'].back() + 1, i, L));
where[s[i] - 'a'].push_back(i);
}
int m;
cin >> m;
while (m--) {
int l, r;
cin >> l >> r;
l--;
cout << (solve(l, r) ? "Alice" : "Bob") << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
string S;
const int MAX = 100000;
int lnext[26][MAX], rnext[26][MAX];
vector<int> pos[26], xoracc[26];
int pos2num[MAX];
int gl[26][MAX], gr[26][MAX];
set<int> uses;
vector<int> use;
int rec(int l, int r, int lt, int rt, bool pre) {
if (lt >= 0 && gl[lt][l] >= 0) return gl[lt][l];
if (rt >= 0 && gr[rt][r] >= 0) return gr[rt][r];
bitset<27> grundys = 0;
for (auto i : use) {
int l2 = rnext[i][l], r2 = lnext[i][r];
if (l2 > r2) continue;
int ln = pos2num[l2], rn = pos2num[r2];
int g = 0;
if (l < l2) g ^= rec(l, l2 - 1, i, -1, pre);
if (pre) {
for (int j = ln; j < rn; j++)
g ^= rec(pos[i][j] + 1, pos[i][j + 1] - 1, i, i, pre);
} else {
g ^= xoracc[i][rn] ^ xoracc[i][ln];
}
if (r > r2) g ^= rec(r2 + 1, r, -1, i, pre);
if (g < 27) grundys[g] = 1;
}
int ret = 0;
while (grundys[ret]) ret++;
if (lt >= 0) gl[lt][l] = ret;
if (rt >= 0) gr[rt][r] = ret;
return ret;
}
int main() {
long long i, j, k;
cin >> S;
int N = S.size();
for (i = 0; i < N; i++) uses.insert(S[i] - 'a');
for (auto i : uses) {
use.push_back(i);
for (j = 0; j < N; j++) {
gl[i][j] = -1;
gr[i][j] = -1;
}
}
for (auto i : use) {
int pt = -1, num = 0;
for (j = 0; j < N; j++) {
if (S[j] - 'a' == i) {
pos[i].push_back(j);
pos2num[j] = num++;
pt = j;
}
lnext[i][j] = pt;
}
pt = N;
for (j = N - 1; j >= 0; j--) {
if (S[j] - 'a' == i) pt = j;
rnext[i][j] = pt;
}
}
for (auto i : use) {
xoracc[i].push_back(0);
for (j = 0; j < pos[i].size() - 1; j++) {
int g = rec(pos[i][j] + 1, pos[i][j + 1] - 1, i, i, true);
xoracc[i].push_back(xoracc[i].back() ^ g);
}
}
int M;
cin >> M;
for (i = 0; i < M; i++) {
int l, r;
scanf("%d %d", &l, &r);
int grundy = rec(l - 1, r - 1, -1, -1, false);
cout << (grundy ? "Alice" : "Bob") << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, mod = 1e9 + 7;
const long long inf = 1e18;
vector<int> fnd;
vector<int> Aft[maxn], Bef[maxn];
int pre[maxn][26], nxt[maxn][26];
bool is[26], in[27];
struct Fenwick {
int arr[maxn];
Fenwick() { memset(arr, 0, sizeof arr); }
void Add(int ind, int x) {
ind += 3;
while (ind < maxn) {
arr[ind] ^= x;
ind += ind & -ind;
}
}
int Ask(int ind) {
ind += 3;
int ans = 0;
while (ind > 0) {
ans ^= arr[ind];
ind -= ind & -ind;
}
return ans;
}
};
Fenwick fen[26];
inline int Ask(int l, int r, int c) {
int ps = pre[r][c];
assert(ps >= 0);
int ans = fen[c].Ask(ps - 1) ^ fen[c].Ask(l - 1);
if (ps < r) ans ^= Aft[ps][r - ps - 1];
ps = nxt[l][c];
assert(ps <= r);
if (l < ps) ans ^= Bef[ps][ps - l - 1];
return ans;
}
void Unique(string &s) {
string str = "";
for (int i = 0; i < int((s).size()); i++) {
if (str == "" || str.back() != s[i]) str.push_back(s[i]), fnd.push_back(i);
}
s = str;
}
void Find(int &l, int &r) {
l = upper_bound(fnd.begin(), fnd.end(), l) - fnd.begin() - 1;
r = upper_bound(fnd.begin(), fnd.end(), r) - fnd.begin() - 1;
}
int Mex() {
for (int i = 0; i <= 26; i++)
if (in[i] == 0) return i;
assert(0);
}
bool CMP(pair<int, int> a, pair<int, int> b) {
if (a.second - a.first == b.second - b.first) return a < b;
return a.second - a.first < b.second - b.first;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
Unique(s);
for (int i = 0; i < 26; i++)
pre[0][i] = -1, nxt[int((s).size()) - 1][i] = int((s).size());
pre[0][s[0] - 'a'] = 0;
nxt[int((s).size()) - 1][s.back() - 'a'] = int((s).size()) - 1;
for (int i = 1; i < int((s).size()); i++)
for (int j = 0; j < 26; j++)
pre[i][j] = (s[i] - 'a' == j ? i : pre[i - 1][j]);
for (int i = int((s).size()) - 2; i >= 0; i--)
for (int j = 0; j < 26; j++)
nxt[i][j] = (s[i] - 'a' == j ? i : nxt[i + 1][j]);
vector<pair<int, int> > tdo;
for (int l = 0; l < int((s).size()); l++) {
for (int r = l + 1; r < int((s).size()) && s[l] != s[r]; r++) {
tdo.push_back({l + 1, r});
}
}
for (int r = 0; r < int((s).size()); r++) {
for (int l = r - 1; l >= 0 && s[l] != s[r]; l--) {
tdo.push_back({l, r - 1});
}
}
sort(tdo.begin(), tdo.end(), CMP);
tdo.resize(unique(tdo.begin(), tdo.end()) - tdo.begin());
for (pair<int, int> p : tdo) {
memset(is, 0, sizeof is);
memset(in, 0, sizeof in);
for (int i = 0; i < 26; i++) {
int ps = pre[p.second][i];
if (ps < p.first) continue;
in[Ask(p.first, p.second, i)] = is[i] = 1;
}
int num = Mex();
bool bl1 = (p.first != 0 && !is[s[p.first - 1] - 'a']),
bl2 = (p.second != int((s).size()) - 1 && !is[s[p.second + 1] - 'a']);
if (bl1) Aft[p.first - 1].push_back(num);
if (bl2) Bef[p.second + 1].push_back(num);
if (bl1 && bl2 && s[p.first - 1] == s[p.second + 1])
fen[s[p.first - 1] - 'a'].Add(p.first - 1, num);
}
int m;
cin >> m;
while (m--) {
int l, r;
cin >> l >> r;
--l, --r;
Find(l, r);
memset(in, 0, sizeof in);
for (int i = 0; i < 26; i++) {
int ps = pre[r][i];
if (ps < l) continue;
in[Ask(l, r, i)] = 1;
}
if (in[0])
cout << "Alice\n";
else
cout << "Bob\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T read() {
T f = 0, x = 0;
char c = getchar();
while (!isdigit(c)) f = c == '-', c = getchar();
while (isdigit(c)) x = x * 10 + c - 48, c = getchar();
return f ? -x : x;
}
namespace run {
const int N = 1e5 + 9, lim = 27;
char s[N];
int n, m, pre[N][lim], suf[N][lim], preans[N][lim], sufans[N][lim], top;
pair<int, int> st[lim + 1];
vector<int> pos[lim];
int sum[N], vis[258];
int main() {
scanf("%s", s + 1), n = strlen(s + 1) + 1, s[0] = s[n] = 'z' + 1,
m = read<int>();
for (int i = n; i >= 0; i--) {
pos[s[i] - 'a'].push_back(i);
for (int j = 0; j < lim; j++)
if (pos[j].size()) suf[i][j] = pos[j][pos[j].size() - 1];
}
for (int i = 0; i < lim; i++) pos[i].clear();
for (int i = 0; i <= n; i++) {
pos[s[i] - 'a'].push_back(i);
for (int j = 0; j < lim; j++)
if (pos[j].size()) pre[i][j] = pos[j][pos[j].size() - 1];
}
for (int i = n; i >= 1; i--) {
top = 0;
for (int j = 0; j < lim; j++)
if (suf[i][j]) st[++top] = pair<int, int>(suf[i][j], j);
sort(st + 1, st + top + 1);
if (suf[i + 1][s[i] - 'a'] && suf[i + 1][s[i] - 'a'] < n) {
sum[i] = preans[i + 1][s[i] - 'a'];
sum[i] ^= sum[suf[i + 1][s[i] - 'a']];
}
for (int j = 1; j <= top; j++) {
int col = st[j].second, pos = st[j].first;
for (int k = 0; k < lim; k++) vis[k] = 0;
for (int k = 1; k < j; k++) {
int tmp = st[k].second,
res = preans[i][tmp] ^ sum[suf[i][tmp]] ^ sum[pre[pos][tmp]];
if (pre[pos][tmp]) res ^= preans[pre[pos][tmp] + 1][col];
vis[res]++;
}
while (vis[preans[i][col]]) preans[i][col]++;
}
for (int j = 0; j < lim; j++)
if (!suf[i][j]) preans[i][j] = preans[i][lim - 1];
}
for (int i = 0; i <= n; i++) {
top = 0;
for (int j = 0; j < lim; j++)
if (pre[i][j] || j == lim - 1) st[++top] = pair<int, int>(pre[i][j], j);
sort(st + 1, st + top + 1), reverse(st + 1, st + top + 1);
for (int j = 1; j <= top; j++) {
int col = st[j].second, pos = st[j].first;
for (int k = 0; k < lim; k++) vis[k] = 0;
for (int k = 1; k < j; k++) {
int tmp = st[k].second,
res = sufans[i][tmp] ^ sum[pre[i][tmp]] ^ sum[suf[pos][tmp]];
if (suf[pos][tmp] - 1 < n) res ^= sufans[suf[pos][tmp] - 1][col];
vis[res]++;
}
while (vis[sufans[i][col]]) sufans[i][col]++;
}
for (int j = 0; j < lim; j++)
if (!pre[i][j]) sufans[i][j] = sufans[i][lim - 1];
}
for (int t = 1; t <= m; t++) {
int l = read<int>(), r = read<int>();
for (int k = 0; k < lim + 1; k++) vis[k] = 0;
for (int i = 0; i < lim; i++) {
if (suf[l][i] && suf[l][i] <= r) {
int res = preans[l][i] ^ sum[suf[l][i]] ^ sum[pre[r][i]];
if (pre[r][i]) res ^= sufans[r][i];
vis[res]++;
}
}
int ret = 0;
while (vis[ret]) ret++;
if (ret)
puts("Alice");
else
puts("Bob");
}
return 0;
}
} // namespace run
int main() { return run::main(); }
|
#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 u = 0;
for (int i = 0; i < 26; ++i) {
int b = pv[t.second][i];
if (ap[i][b] < t.first) continue;
int a = nx[t.first][i];
u |= 1 << (tl[i][t.first] ^ tr[i][t.second] ^ qz[i][b - 1] ^ qz[i][a - 1]);
}
int g = 0;
while (u & (1 << g)) ++g;
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>
using namespace std;
const int N = 1e5 + 7, M = 30;
unordered_map<int, int> e[N];
char s[N];
int n, q, k, z[M], f[M][N], w[M][N], p1[M][N], p2[M][N];
inline int solve(int l, int r) {
if (l > r) return 0;
bool fl[M];
if (e[l].count(r)) return e[l][r];
memset(fl, 0, sizeof(fl));
for (int x = 1; x <= 26; x++)
if (p1[x][r] >= l) {
int a = p2[x][l], b = p1[x][r];
fl[w[x][b] ^ w[x][a] ^ f[x][l] ^ solve(b + 1, r)] = 1;
}
for (int i = 0; i <= 26; i++)
if (!fl[i]) return e[l][r] = i;
}
inline bool cmp(int a, int b) { return p2[a][k] < p2[b][k]; }
int main() {
scanf("%s", s + 1), n = strlen(s + 1);
int l, r;
for (int i = 1; i <= n; i++) s[i] = s[i] - 'a' + 1;
for (int i = 1; i <= n; i++) {
for (int x = 1; x <= 26; x++) p1[x][i] = p1[x][i - 1];
p1[s[i]][i] = i;
}
for (int i = n; i >= 1; i--) {
for (int x = 1; x <= 26; x++) p2[x][i] = p2[x][i + 1];
p2[s[i]][i] = i;
}
for (int i = n; i >= 1; i--) {
for (int j = 1; j <= 26; j++) w[j][i] = w[j][i + 1], z[j] = j;
k = i;
sort(z + 1, z + 27, cmp);
for (int j = 1; j <= 26; j++) {
int x = z[j];
if (i < p2[x][i] && p2[x][i] <= n) f[x][i] = solve(i, p2[x][i] - 1);
if (p2[x][i] == i) w[x][i] ^= f[x][i + 1];
}
}
cin >> q;
while (q--) {
scanf("%d%d", &l, &r);
if (solve(l, r))
puts("Alice");
else
puts("Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
char c[N];
int pre[N][27], suf[N][27], pf[N][27], sf[N][27], n;
bool jip[N][27], jis[N][27], ji[N][27];
inline int read() {
char c = getchar();
int x = 0, f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
return x * f;
}
inline int solve(int, int, int);
inline int xhz(int l, int r, int i, int dep) {
if (jis[l][i]) return sf[l][i];
sf[l][i] = solve(l, r, dep + 1);
jis[l][i] = 1;
return sf[l][i];
}
inline int xqz(int l, int r, int i, int dep) {
if (jip[r][i]) return pf[r][i];
pf[r][i] = solve(l, r, dep + 1);
jip[r][i] = 1;
return pf[r][i];
}
inline int solve(int l, int r, int dep) {
if (l > r) return 0;
if (l == r) return 1;
memset(ji[dep], 0, sizeof(ji[dep]));
for (int i = 0; i <= 25; i++) {
int zuo = suf[l][i], you = pre[r][i];
if (zuo > r || you < l) continue;
if (you >= zuo) {
int hu = pf[you][i] ^ pf[zuo][i];
if (zuo != l) hu ^= xhz(l, zuo - 1, i, dep);
if (you != r) hu ^= xqz(you + 1, r, i, dep);
ji[dep][hu] = 1;
}
}
for (int i = 0; i <= 26; i++)
if (ji[dep][i] == 0) return i;
}
int main() {
scanf("%s", c + 1);
n = strlen(c + 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 25; j++) pre[i][j] = pre[i - 1][j];
pre[i][c[i] - 'a'] = i;
}
for (int i = 0; i <= 25; i++) suf[n + 1][i] = n + 1;
for (int i = n; i >= 1; i--) {
for (int j = 0; j <= 25; j++) suf[i][j] = suf[i + 1][j];
suf[i][c[i] - 'a'] = i;
}
for (int i = 1; i <= n; i++) {
if (pre[i - 1][c[i] - 'a']) {
int hu = c[i] - 'a';
if (pre[i - 1][hu] + 1 > i - 1)
pf[i][hu] = pf[pre[i - 1][hu]][hu];
else
pf[i][hu] = pf[i - 1][hu] ^ pf[pre[i - 1][hu]][hu];
jip[i][hu] = 1;
}
for (int j = 0; j <= 25; j++) {
if (pre[i][j] == 0 || jip[i][j] == 1) continue;
if (pre[i][j] != i) pf[i][j] = solve(pre[i][j] + 1, i, 0);
jip[i][j] = 1;
}
}
for (int i = n; i >= 1; i--) {
if (suf[i + 1][c[i] - 'a'] != n + 1) {
int hu = c[i] - 'a';
if (suf[i + 1][hu] - 1 < i + 1)
sf[i][hu] = sf[suf[i + 1][hu]][hu];
else
sf[i][hu] = sf[i + 1][hu] ^ sf[suf[i + 1][hu]][hu];
jis[i][hu] = 1;
}
for (int j = 0; j <= 25; j++) {
if (suf[i][j] == n + 1 || jis[i][j] == 1) continue;
if (suf[i][j] != i) sf[i][j] = solve(i, suf[i][j] - 1, 0);
jis[i][j] = 1;
}
}
int q = read();
for (int i = 1, x, y; i <= q; i++) {
x = read();
y = read();
if (solve(x, y, 0))
cout << "Alice\n";
else
cout << "Bob\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << " = " << h << endl;
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << " = " << h << ", ";
_dbg(sdbg + 1, a...);
}
const int maxn = (1e5) + 7;
const int alf = 26;
const int inf = (1e9) + 7;
const long long LLinf = (1e18) + 7;
const long double eps = 1e-9;
const long long mod = 1e9 + 7;
int lewo[maxn][alf];
int prawo[maxn][alf];
int tab[maxn];
int dpl[maxn][alf];
int dpp[maxn][alf];
int prelicz(int l, int p) {
int mask = 0;
for (int i = 0; i < alf; i++) {
int cnt = 0;
int le = prawo[l][i];
int pr = lewo[p][i];
if (le > p) continue;
int cur = le;
while (cur != pr) {
cur = prawo[cur + 1][i];
cnt ^= tab[cur];
}
if (l < le) {
if (dpl[l][i] == -1) dpl[l][i] = prelicz(l, le - 1);
cnt ^= dpl[l][i];
}
if (pr < p) {
if (dpp[p][i] == -1) dpp[p][i] = prelicz(pr + 1, p);
cnt ^= dpp[p][i];
};
if (cnt < alf) mask |= (1 << cnt);
}
for (int i = 0; i <= alf; i++)
if (((1 << i) & mask) == 0) return i;
assert(0);
}
int licz(int l, int p) {
int mask = 0;
for (int i = 0; i < alf; i++) {
int le = prawo[l][i];
int pr = lewo[p][i];
if (le > p) continue;
int cnt = tab[le] ^ tab[pr];
if (l < le) {
if (dpl[l][i] == -1) dpl[l][i] = licz(l, le - 1);
cnt ^= dpl[l][i];
}
if (pr < p) {
if (dpp[p][i] == -1) dpp[p][i] = licz(pr + 1, p);
cnt ^= dpp[p][i];
}
if (cnt < alf) mask |= (1 << cnt);
}
for (int i = 0; i <= alf; i++)
if (((1 << i) & mask) == 0) return i;
assert(0);
}
bool por(pair<int, int> a, pair<int, int> b) {
return a.second - a.first < b.second - b.first;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = ((int)(s).size());
for (int i = 0; i <= n + 2; i++)
for (int j = 0; j < alf; j++) dpl[i][j] = dpp[i][j] = -1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < alf; j++) lewo[i][j] = lewo[i - 1][j];
lewo[i][s[i - 1] - 'a'] = i;
}
for (int i = 0; i < alf; i++) prawo[n + 1][i] = n + 1;
for (int i = n; i >= 0; i--) {
for (int j = 0; j < alf; j++) prawo[i][j] = prawo[i + 1][j];
if (i > 0) prawo[i][s[i - 1] - 'a'] = i;
}
vector<pair<int, int> > V;
for (int i = 0; i < alf; i++) {
int cur = prawo[1][i];
while (cur < n && prawo[cur + 1][i] < n + 1) {
V.push_back({cur, prawo[cur + 1][i]});
cur = prawo[cur + 1][i];
}
}
sort(V.begin(), V.end(), por);
for (auto v : V)
if (v.first + 2 <= v.second) {
int cnt = prelicz(v.first + 1, v.second - 1);
;
tab[v.second] ^= cnt;
}
for (int i = 1; i <= n; i++) {
int le = lewo[i - 1][s[i - 1] - 'a'];
if (le > 0) tab[i] ^= tab[le];
}
int q;
cin >> q;
while (q--) {
int l, p;
cin >> l >> p;
int xd = licz(l, p);
if (xd != 0)
cout << "Alice\n";
else
cout << "Bob\n";
}
return 0;
}
|
#include <bits/stdc++.h>
int N, Q, pre[100002][26], suc[100002][26], a[100002], LM[100002][26],
RM[100002][26];
char _in[100002];
int f[100002], dis[100002];
int p[100002], L;
void F(int x) {
if (f[x] == x) return;
F(f[x]);
dis[x] ^= dis[f[x]];
f[x] = f[f[x]];
}
void connect(int u, int w) {
int v = suc[u + 1][a[u]];
f[v] = u;
dis[v] = w;
}
int ans(int l, int r, int remember) {
if (l == r - 1) return 0;
if (remember == -1 && LM[l][a[r]] != -1) return LM[l][a[r]];
if (remember == 1 && RM[r][a[l]] != -1) return RM[r][a[l]];
bool v[32];
for (int i = 0; i <= 26; i++) v[i] = false;
for (int i = 0; i < 26; i++)
if (suc[l + 1][i] < r) {
int first = suc[l + 1][i], last = pre[r - 1][i];
F(first);
F(last);
v[ans(l, first, -1) ^ dis[first] ^ dis[last] ^ ans(last, r, 1)] = true;
}
int ans = 0;
while (v[ans]) ans++;
if (remember == -1) LM[l][a[r]] = ans;
if (remember == 1) RM[r][a[l]] = ans;
return ans;
}
int main() {
scanf("%s", _in + 1);
while (_in[N + 1]) N++;
for (int i = 1; i <= N; i++) {
std::copy(pre[i - 1], pre[i - 1] + 26, pre[i]);
pre[i][a[i] = _in[i] - 'a'] = i;
}
std::fill(suc[N + 1], suc[N + 1] + 26, N + 1);
for (int i = N; i; i--) {
std::copy(suc[i + 1], suc[i + 1] + 26, suc[i]);
suc[i][a[i]] = i;
}
for (int i = 1; i <= N; i++)
if (suc[i + 1][a[i]] != N + 1) p[++L] = i;
std::sort(p + 1, p + L + 1, [](int x, int y) {
return suc[x + 1][a[x]] - x < suc[y + 1][a[y]] - y;
});
for (int i = 1; i <= N; i++) {
f[i] = i;
dis[i] = 0;
}
for (int i = 0; i <= N + 1; i++) {
std::fill(LM[i], LM[i] + 26, -1);
std::fill(RM[i], RM[i] + 26, -1);
}
for (int i = 1; i <= L; i++)
connect(p[i], ans(p[i], suc[p[i] + 1][a[p[i]]], 0));
for (scanf("%d", &Q); Q--;) {
int l, r;
scanf("%d%d", &l, &r);
puts(ans(l - 1, r + 1, 0) ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(long long a) {
write(a);
puts("");
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
inline unsigned long long rnd() {
return ((unsigned long long)rand() << 30 ^ rand()) << 4 | rand() % 4;
}
const int N = 100005;
int n, ti, tong[N], sum[N], f[N][26], g[N][26], l[N][26], r[N][26];
vector<int> s[26];
vector<int> v[N];
map<int, int> M[N];
char ch[N];
int solve(int L, int R) {
if (L > R) return 0;
if (M[L].count(R)) return M[L][R];
ti++;
for (int i = 0; i < 26; i++)
if (r[L][i] <= R) {
tong[f[L][i] ^ g[R][i] ^ sum[l[R][i]] ^ sum[r[L][i]]] = ti;
}
for (int i = 0;; i++)
if (tong[i] != ti) return M[L][R] = i;
}
signed main() {
scanf("%s", ch + 1);
n = strlen(ch + 1);
for (int i = 1; i <= n; i++) ch[i] -= 'a';
for (int i = 0; i < 26; i++) s[i].push_back(0);
for (int i = 1; i <= n; i++) s[ch[i]].push_back(i);
for (int i = 0; i < 26; i++) s[i].push_back(n + 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) l[i][j] = l[i - 1][j];
l[i][ch[i]] = i;
}
for (int i = 0; i < 26; i++) r[n + 1][i] = n + 1;
for (int i = n; i; i--) {
for (int j = 0; j < 26; j++) r[i][j] = r[i + 1][j];
r[i][ch[i]] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++)
if (ch[i] != j) {
v[i].push_back(l[i][j] + 1);
v[r[i][j] - 1].push_back(i);
}
}
for (int i = 0; i < 26; i++)
for (unsigned j = 1; j < s[i].size(); j++)
v[s[i][j] - 1].push_back(s[i][j - 1] + 1);
for (int i = 1; i <= n; i++) {
sort(v[i].begin(), v[i].end());
v[i].resize(unique(v[i].begin(), v[i].end()) - v[i].begin());
reverse(v[i].begin(), v[i].end());
for (auto j : v[i]) {
solve(j, i);
for (int k = 0; k < 26; k++)
if (l[i][k] + 1 == j) g[i][k] = solve(j, i);
if (r[j][ch[i + 1]] == i + 1) f[j][ch[i + 1]] = solve(j, i);
}
sum[i + 1] = sum[l[i][ch[i + 1]]] ^ solve(l[i][ch[i + 1]] + 1, i);
}
int m = read();
while (m--) {
int L = read(), R = read();
puts(solve(L, R) ? "Alice" : "Bob");
}
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr long long pw(long long a, long long b, long long mod) {
return (!b ? 1
: b & 1 ? a * pw(a * a % mod, b / 2, mod) % mod
: pw(a * a % mod, b / 2, mod));
}
constexpr long long N = 1e5 + 10;
constexpr long long MOD = 1e9 + 7;
constexpr long long INF = 1e18;
constexpr long long SIG = 26;
int n, q, A[N];
int nxt[N][SIG], prv[N][SIG];
int bcw[N][SIG], frw[N][SIG], ps[N];
bitset<2 * SIG> mark;
string s;
vector<int> ord;
void remove(vector<int> &v, int x) {
for (auto it = v.begin(); it != v.end(); it++)
if ((*it) == x) {
v.erase(it);
return;
}
}
inline void initord() {
ord.clear();
for (int i = 0; i < SIG; i++) {
ord.push_back(i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> s >> q;
n = s.size();
for (int i = 0; i < n; i++) {
A[i + 1] = (s[i] - 'a');
}
for (int i = 1; i <= n + 1; i++) {
copy(prv[i - 1], prv[i - 1] + SIG, prv[i]);
prv[i][A[i]] = i;
}
fill(nxt[n + 1], nxt[n + 1] + SIG, n + 1);
for (int i = n; i >= 0; i--) {
copy(nxt[i + 1], nxt[i + 1] + SIG, nxt[i]);
nxt[i][A[i]] = i;
}
initord();
for (int i = 1; i <= n; i++) {
remove(ord, A[i]);
ord.push_back(A[i]);
ps[i] = bcw[i - 1][A[i]] ^ ps[prv[i - 1][A[i]]];
for (int j = SIG - 1; j >= 0; j--) {
int c = ord[j], l = prv[i][c];
mark.reset();
for (int k = SIG - 1; k > j; k--) {
int ct = ord[k];
if (prv[i][ct] <= l) continue;
int f = nxt[l][ct];
int val = bcw[f - 1][c] ^ ps[prv[i][ct]] ^ ps[f] ^ bcw[i][ct];
mark[val] = true;
}
for (int k = 0;; k++)
if (!mark[k]) {
bcw[i][c] = k;
break;
}
}
}
initord();
for (int i = n; i >= 0; i--) {
remove(ord, A[i]);
ord.push_back(A[i]);
for (int j = SIG - 1; j >= 0; j--) {
int c = ord[j], r = nxt[i][c];
mark.reset();
for (int k = SIG - 1; k > j; k--) {
int ct = ord[k];
if (nxt[i][ct] >= r) continue;
int val = frw[i][ct] ^ ps[prv[r][ct]] ^ ps[nxt[i][ct]] ^ bcw[r - 1][ct];
mark[val] = true;
}
for (int k = 0;; k++)
if (!mark[k]) {
frw[i][c] = k;
break;
}
}
}
while (q--) {
int l, r;
cin >> l >> r;
mark.reset();
for (int c = 0; c < SIG; c++)
if (nxt[l][c] <= r) {
int val = frw[l][c] ^ ps[prv[r][c]] ^ ps[nxt[l][c]] ^ bcw[r][c];
mark[val] = true;
}
cout << (mark[0] ? "Alice" : "Bob") << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Imx = 2147483647;
const long long Lbig = 2e18;
const int mod = 1e9 + 7;
struct fastio {
char s[100000];
int it, len;
fastio() { it = len = 0; }
inline char get() {
if (it < len) return s[it++];
it = 0;
len = fread(s, 1, 100000, stdin);
if (len == 0)
return EOF;
else
return s[it++];
}
bool notend() {
char c = get();
while (c == ' ' || c == '\n') c = get();
if (it > 0) it--;
return c != EOF;
}
} _buff;
inline long long getnum() {
long long r = 0;
bool ng = 0;
char c;
c = _buff.get();
while (c != '-' && (c < '0' || c > '9')) c = _buff.get();
if (c == '-') ng = 1, c = _buff.get();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = _buff.get();
return ng ? -r : r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline char getreal() {
char c = _buff.get();
while (c <= 32) c = _buff.get();
return c;
}
long long qpow(long long x, long long k) {
return k == 0 ? 1
: 1ll * qpow(1ll * x * x % mod, k >> 1) * (k & 1 ? x : 1) % mod;
}
const int maxn = 100111;
const int maxa = 27;
char s[maxn];
int n, q;
int go[maxn][maxa], rgo[maxn][maxa];
int dp[2][maxn][maxa], dps[2][maxn][maxa];
void solve(int dp[maxn][maxa], int dps[maxn][maxa]) {
for (int i = 0; i < maxa; i++) go[n + 1][i] = n + 1, rgo[0][i] = 0;
for (int i = n; i >= 0; i--) {
for (int j = 0; j < maxa; j++) {
if (s[i] == 'a' + j)
go[i][j] = i;
else
go[i][j] = go[i + 1][j];
}
}
for (int i = 1; i <= n + 1; i++) {
for (int j = 0; j < maxa; j++) {
if (s[i] == 'a' + j)
rgo[i][j] = i;
else
rgo[i][j] = rgo[i - 1][j];
}
}
for (int i = n; i >= 1; i--) {
vector<pair<int, int> > v;
for (int j = 0; j < maxa; j++) v.push_back(make_pair(go[i][j], j));
sort(v.begin(), v.end());
for (int t = 0; t < maxa; t++) {
int j = v[t].second;
int r = go[i][j] - 1;
bool f[32] = {};
dp[i][j] = dps[i][j] = 0;
for (int k = 0; k < maxa; k++) {
if (go[i][k] > r) continue;
int p = rgo[r][k];
int cur = dps[i][k] ^ dps[p][k] ^ dp[p + 1][j];
f[cur] = 1;
}
while (f[dp[i][j]]) dp[i][j]++;
dps[i][j] = dp[i][j] ^ (go[i][j] + 1 <= n ? dps[go[i][j] + 1][j] : 0);
}
}
}
int query(int l, int r) {
bool f[32] = {};
for (int i = 0; i < maxa; i++) {
if (go[l][i] > r) continue;
int p = rgo[r][i];
int cur = dps[0][l][i] ^ dps[0][p][i] ^ dp[1][n - r + 1][i];
f[cur] = 1;
}
int ret = 0;
while (f[ret]) ret++;
return ret;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
s[0] = s[n + 1] = 'a' + maxa - 1;
reverse(s + 1, s + n + 1);
solve(dp[1], dps[1]);
reverse(s + 1, s + n + 1);
solve(dp[0], dps[0]);
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d%d", &l, &r);
if (query(l, r) > 0)
puts("Alice");
else
puts("Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using std::cout;
const char endl = '\n';
const int nmax = 100050;
template <class T>
inline std::ostream &operator<(std::ostream &out, const T &t) {
return out << t;
}
inline int read() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int ret = 0;
while (c >= '0' && c <= '9') {
ret = ret * 10 + c - '0';
c = getchar();
}
return ret;
}
int n;
char a[nmax];
int pre[nmax][26], suf[nmax][26];
int f[nmax][26], g[nmax], cache[27];
int calc(int l, int r, int c, bool right) {
if (l > r) return 0;
if (~cache[c]) return cache[c];
int ret = 0;
for (int j = 0; j < 26; ++j) {
const int ll = suf[l][j], rr = pre[r][j];
if (rr < l) continue;
int pos = g[ll] ^ g[rr];
if (right)
pos ^= calc(l, ll - 1, j, 1) ^ f[r][j];
else
pos ^= f[ll - 1][c] ^ calc(rr + 1, r, j, 0);
ret |= 1 << pos;
}
return cache[c] = __builtin_ctz(~ret);
}
inline void init() {
for (int i = 1; i <= n; ++i) {
memcpy(pre[i], pre[i - 1], sizeof(pre[0]));
pre[i][a[i]] = i;
}
for (int j = 0; j < 26; ++j) suf[n + 1][j] = n + 1;
for (int i = n; i; --i) {
memcpy(suf[i], suf[i + 1], sizeof(suf[0]));
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(cache, -1, sizeof(cache));
for (int j = 0; j < 26; ++j) f[i][j] = calc(pre[i][j] + 1, i, j, 0);
}
}
int main() {
char c = getchar();
while (isspace(c)) c = getchar();
while (!isspace(c)) {
a[++n] = c - 'a';
c = getchar();
}
init();
for (int m = read(); m; --m) {
const int l = read(), r = read();
memset(cache, -1, sizeof(cache));
if (calc(l, r, 26, 1))
cout < "Alice\n";
else
cout < "Bob\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 101000;
const int MAXM = 101000;
const int CH = 26;
int N, M, s[MAXN];
char sraw[MAXN];
int L[MAXN][CH], R[MAXN][CH];
int pfx[MAXN][CH], sfx[MAXN][CH], psm[MAXN];
void initLR() {
for (int i = 0; i < CH; i++) L[0][i] = 0, L[N][i] = N;
for (int i = 1; i < N; i++) {
for (int j = 0; j < CH; j++) L[i][j] = L[i - 1][j];
L[i][s[i]] = i;
}
for (int i = 0; i < CH; i++) R[N][i] = N, R[0][i] = 0;
for (int i = N - 1; i > 0; i--) {
for (int j = 0; j < CH; j++) R[i][j] = R[i + 1][j];
R[i][s[i]] = i;
}
}
void initPFX() {
int o[CH], t;
bool u[CH + 1];
psm[0] = 0;
for (int i = 0; i < CH; i++) pfx[0][i] = 0;
for (int i = 1; i < N; i++) {
psm[i] = psm[L[i - 1][s[i]]] xor pfx[i - 1][s[i]];
for (int j = 0; j < CH; j++) o[j] = j;
sort(o, o + CH,
[&](const int& a, const int& b) { return L[i][a] > L[i][b]; });
for (int j = 0; j < CH; j++) {
for (int k = 0; k <= CH; k++) u[k] = false;
for (int k = 0; k < j; k++) {
if (L[i][o[k]] == 0) continue;
assert(L[i][o[j]] < L[i][o[k]]);
if ((t = pfx[R[L[i - 1][o[j]]][o[k]] - 1][o[j]] xor psm[L[i][o[k]]] xor
psm[R[L[i - 1][o[j]] + 1][o[k]]] xor pfx[i][o[k]]) < CH)
u[t] = true;
}
int ans = 0;
while (u[ans]) ans++;
pfx[i][o[j]] = ans;
}
}
}
void initSFX() {
int o[CH], t;
bool u[CH + 1];
for (int i = 0; i < CH; i++) sfx[N][i] = 0;
for (int i = N - 1; i > 0; i--) {
for (int j = 0; j < CH; j++) o[j] = j;
sort(o, o + CH,
[&](const int& a, const int& b) { return R[i][a] < R[i][b]; });
for (int j = 0; j < CH; j++) {
for (int k = 0; k <= CH; k++) u[k] = false;
for (int k = 0; k < j; k++) {
if (R[i][o[k]] == N) continue;
assert(R[i][o[k]] < R[i][o[j]]);
if ((t = sfx[i][o[k]] xor psm[L[R[i + 1][o[j]] - 1][o[k]]] xor
psm[R[i][o[k]]] xor sfx[L[R[i + 1][o[j]]][o[k]] + 1][o[j]]) <
CH)
u[t] = true;
}
int ans = 0;
while (u[ans]) ans++;
sfx[i][o[j]] = ans;
}
}
}
int main() {
scanf(" %s", sraw);
s[0] = -1;
for (N = 1; sraw[N - 1] != '\0'; N++) {
assert(N < MAXN - 10);
s[N] = static_cast<int>(sraw[N - 1]) - 97;
}
s[N] = -1;
initLR();
initPFX();
initSFX();
scanf("%d", &M);
int t;
for (int i = 0; i < M; i++) {
int a, b;
scanf("%d%d", &a, &b);
assert(1 <= a and a <= b and b < N);
bool u = false;
for (int c = 0; c < CH; c++) {
if (R[a][c] > b) continue;
t = sfx[a][c] xor psm[L[b][c]] xor psm[R[a][c]] xor pfx[b][c];
if (!t) u = true;
}
if (u)
printf("Alice\n");
else
printf("Bob\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005, mod = 19260817;
char str[MAXN];
int n, m;
int chl[26][MAXN], chr[26][MAXN];
int T[26];
struct node {
long long to;
int key;
int next;
} edge[MAXN * 50];
int head[mod], top = 0;
inline long long encode(int L, int R) { return (long long)L * 233333 + R; }
void modify(int L, int R, int dt) {
long long num = encode(L, R);
++top, edge[top] = (node){num, dt, head[num % mod]}, head[num % mod] = top;
}
inline int query(int L, int R) {
long long num = encode(L, R);
for (int i = head[num % mod]; i; i = edge[i].next) {
if (edge[i].to == num) return edge[i].key;
}
return -1;
}
int block[26][MAXN];
short lg[1048577];
inline short lowbit(long long x) {
short cnt = 0;
if ((x & (1048575)) == 1048575) cnt += 20, x >>= 20;
if ((x & (1048575)) == 1048575) cnt += 20, x >>= 20;
return cnt + lg[x];
}
int dfs(int L, int R, int flag = 0) {
if (L > R) return 0;
int t;
if ((t = query(L, R)) != -1) return t;
long long bit = 0;
if (!flag) {
for (int i = 0; i < 26; i++) {
int cur = L, sg = 0;
if (chl[i][cur] > R) continue;
while (cur <= R) {
int nxt = chl[i][cur];
if (nxt <= R) {
sg ^= dfs(cur, nxt - 1, flag);
cur = nxt + 1;
} else {
sg ^= dfs(cur, R, flag);
break;
}
}
bit |= 1ll << sg;
}
} else {
for (register int i = 0; i < 26; i++) {
if (chl[i][L] > R) continue;
register int opl = chl[i][L], opr = chr[i][R];
register int sg = block[i][opr] ^ block[i][opl] ^ dfs(L, opl - 1, flag) ^
dfs(opr + 1, R, flag);
bit |= 1ll << sg;
}
}
for (int j = 0;; j++)
if (!(bit >> j & 1)) {
modify(L, R, j);
return j;
}
}
inline int read() {
int a = 0, c;
do c = getchar();
while (!isdigit(c));
while (isdigit(c)) {
a = a * 10 + c - '0';
c = getchar();
}
return a;
}
void init() {
lg[0] = 0;
for (int i = 1; i < 1048576; i++) lg[i] = (!(i & 1)) ? 0 : lg[i >> 1] + 1;
memset(T, 127 / 3, sizeof T);
scanf("%s", str + 1), n = strlen(str + 1);
for (int i = n; i >= 1; i--) {
T[str[i] - 'a'] = i;
for (int j = 0; j < 26; j++) chl[j][i] = T[j];
}
memset(T, 127 / 3, sizeof T);
for (int i = 1; i <= n; i++) {
T[str[i] - 'a'] = i;
for (int j = 0; j < 26; j++) chr[j][i] = T[j];
}
dfs(1, n);
for (int i = 0; i < 26; i++) {
int pre = 0;
for (int j = 1; j <= n; j++)
if (str[j] - 'a' == i) {
block[i][j] = dfs(pre + 1, j - 1) ^ block[i][pre];
pre = j;
}
}
}
void work() {
int m, l, r;
m = read();
while (m--) {
l = read(), r = read();
int flag = dfs(l, r, 1);
if (flag)
puts("Alice");
else
puts("Bob");
}
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 14, z = 26;
enum CacheType { No, L, R };
int n, nxt[z][maxn];
string s;
vector<int> where[z], pxor[z];
struct Grundy {
int seen;
Grundy() : seen(0) {}
void add(int i) { seen |= 1 << i; }
int get() { return __builtin_ctz(~seen); }
};
struct Cacher {
vector<int> save[2][maxn];
int ask(int l, int r) {
if (save[0][l].size() > r - l && save[0][l][r - l] != -1)
return save[0][l][r - l];
if (save[1][r].size() > r - l && save[1][r][r - l] != -1)
return save[1][r][r - l];
return -1;
}
void cache(int l, int r, CacheType c, int ans) {
if (c == No) return;
if (c == L) {
while (save[0][l].size() <= r - l) save[0][l].push_back(-1);
save[0][l][r - l] = ans;
} else {
while (save[1][r].size() <= r - l) save[1][r].push_back(-1);
save[1][r][r - l] = ans;
}
}
} cacher;
bool finito;
int solve(int l, int r, CacheType c = No) {
if (l == r) return 0;
if (cacher.ask(l, r) != -1) return cacher.ask(l, r);
Grundy g;
for (char c = 0; c < z; c++) {
int s = nxt[c][l];
int e = nxt[c][r];
if (s != e)
g.add(solve(l, where[c][s], R) ^ pxor[c][s] ^ pxor[c][e - 1] ^
solve(where[c][e - 1] + 1, r, L));
}
cacher.cache(l, r, c, g.get());
return g.get();
}
int query(int l, int r) {
Grundy g;
for (char c = 0; c < z; c++) {
int s = nxt[c][l];
int e = nxt[c][r];
if (s != e) {
g.add(solve(l, where[c][s], R) ^ pxor[c][s] ^ pxor[c][e - 1] ^
solve(where[c][e - 1] + 1, r, L));
}
}
return g.get();
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> s;
n = s.size();
for (int c = 0; c < z; c++) {
for (int i = 1; i <= n; i++)
nxt[c][i] = (s[i - 1] == c + 'a') + nxt[c][i - 1];
}
fill(pxor, pxor + z, vector<int>(1));
for (int i = 0; i < n; i++) {
if (where[s[i] - 'a'].size())
pxor[s[i] - 'a'].push_back(pxor[s[i] - 'a'].back() ^
solve(where[s[i] - 'a'].back() + 1, i, L));
where[s[i] - 'a'].push_back(i);
}
int m;
cin >> m;
while (m--) {
int l, r;
cin >> l >> r;
l--;
cout << (solve(l, r) ? "Alice" : "Bob") << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int abc = 26, maxn = 1e5 + 5;
string s;
int n, q;
int pv[abc][maxn], nx[abc][maxn];
int pf[abc][maxn];
int g[maxn];
int mex(int x) { return __builtin_ctz((1 << abc) - 1 - x); }
bool querymode = false;
int memo[abc + 1];
int query(int l, int r, int lst) {
if (r < l) return 0;
if (memo[lst] != -1) return memo[lst];
int ans = 0;
for (int c = 0; c < abc; c++) {
int cl = nx[c][l], cr = pv[c][r];
if (cl > r || cr < l) continue;
int x = g[cr] ^ g[cl];
if (querymode)
x ^= query(l, cl - 1, c) ^ pf[c][r];
else
x ^= pf[lst][cl - 1] ^ query(cr + 1, r, c);
ans |= (1 << x);
}
return memo[lst] = mex(ans);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> s;
n = s.size();
vector<int> v(n + 1);
for (int i = 1; i <= n; i++) v[i] = s[i - 1] - 'a';
for (int j = 0; j < abc; j++) pv[j][0] = 0, nx[j][n + 1] = n + 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < abc; j++) pv[j][i] = pv[j][i - 1];
pv[v[i]][i] = i;
}
for (int i = n; i >= 1; i--) {
for (int j = 0; j < abc; j++) nx[j][i] = nx[j][i + 1];
nx[v[i]][i] = i;
}
for (int i = 1; i <= n; i++) {
g[i] = g[pv[v[i]][i - 1]] ^ pf[v[i]][i - 1];
fill(memo, memo + abc + 1, -1);
for (int j = 0; j < abc; j++) pf[j][i] = query(pv[j][i] + 1, i, j);
}
querymode = true;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
fill(memo, memo + abc + 1, -1);
if (query(l, r, abc))
cout << "Alice\n";
else
cout << "Bob\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long qpow(long long x, long long k, long long mod) {
long long ret = 1;
while (k) {
if (k & 1) {
ret = ret * x;
ret = ret % mod;
}
x = x * x;
x = x % mod;
k = (k >> 1);
}
return ret;
}
const int Maxn = 1e5 + 5;
char s[Maxn];
int n;
int pre[Maxn][26], nxt[Maxn][26];
int sum[Maxn], lsum[Maxn][26], rsum[Maxn][26];
bool flag[26];
int grundy(int l, int r) {
memset(flag, false, sizeof(flag));
for (int i = 0; i < 26; i++) {
int p1 = nxt[l][i], p2 = pre[r][i];
if (p1 > p2) continue;
int val = (rsum[l][i] ^ sum[p2] ^ sum[p1] ^ lsum[r][i]);
flag[val] = true;
}
for (int i = 0; i < 26; i++)
if (!flag[i]) return i;
return 26;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) s[i] -= 'a';
s[0] = s[n + 1] = -1;
set<pair<int, int> > seg;
for (int j = 0; j < 26; j++) pre[0][j] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) {
pre[i][j] = (j == s[i]) ? i : pre[i - 1][j];
seg.insert(pair<int, int>(i, -pre[i][j] - 1));
}
}
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] = (j == s[i]) ? i : nxt[i + 1][j];
seg.insert(pair<int, int>(nxt[i][j] - 1, -i));
}
}
for (auto v : seg) {
int l = -v.second, r = v.first;
int x = grundy(l, r);
if (s[l - 1] >= 0 && s[l - 1] == s[r + 1]) {
sum[r + 1] = (sum[l - 1] ^ x);
}
if (s[l - 1] >= 0 && pre[r][s[l - 1]] == l - 1) {
lsum[r][s[l - 1]] = x;
}
if (s[r + 1] >= 0 && nxt[l][s[r + 1]] == r + 1) {
rsum[l][s[r + 1]] = x;
}
}
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d%d", &l, &r);
if (grundy(l, r))
puts("Alice");
else
puts("Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long qpow(long long x, long long k, long long mod) {
long long ret = 1;
while (k) {
if (k & 1) {
ret = ret * x;
ret = ret % mod;
}
x = x * x;
x = x % mod;
k = (k >> 1);
}
return ret;
}
const int Maxn = 1e5 + 5;
char s[Maxn];
int n;
int pre[Maxn][26], nxt[Maxn][26];
int sum[Maxn], lsum[Maxn][26], rsum[Maxn][26];
bool flag[26];
int grundy(int l, int r) {
memset(flag, false, sizeof(flag));
for (int i = 0; i < 26; i++) {
int p1 = nxt[l][i], p2 = pre[r][i];
if (p1 > p2) continue;
int val = (rsum[l][i] ^ sum[p2] ^ sum[p1] ^ lsum[r][i]);
flag[val] = true;
}
for (int i = 0; i < 26; i++)
if (!flag[i]) return i;
return 26;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) s[i] -= 'a';
s[0] = s[n + 1] = -1;
vector<pair<int, int> > seg;
for (int j = 0; j < 26; j++) pre[0][j] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) {
pre[i][j] = (j == s[i]) ? i : pre[i - 1][j];
seg.push_back(pair<int, int>(i, -pre[i][j] - 1));
}
}
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] = (j == s[i]) ? i : nxt[i + 1][j];
seg.push_back(pair<int, int>(nxt[i][j] - 1, -i));
}
}
sort((seg).begin(), (seg).end());
seg.resize(unique((seg).begin(), (seg).end()) - seg.begin());
for (auto v : seg) {
int l = -v.second, r = v.first;
int x = grundy(l, r);
if (s[l - 1] >= 0 && s[r + 1] >= 0 && s[l - 1] == s[r + 1]) {
sum[r + 1] = (sum[l - 1] ^ x);
}
if (s[l - 1] >= 0 && pre[r][s[l - 1]] == l - 1) {
lsum[r][s[l - 1]] = x;
}
if (s[r + 1] >= 0 && nxt[l][s[r + 1]] == r + 1) {
rsum[l][s[r + 1]] = x;
}
}
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d%d", &l, &r);
if (grundy(l, r))
puts("Alice");
else
puts("Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int Q, n, a[100005];
int pprev[100005][26], pnext[100005][26];
int pref[100005];
int dpprev[100005][26], dpnext[100005][26];
int solveRange(int l, int r) {
if (l > r) {
return 0;
}
int mex = 0;
for (int d = 0; d < 26; d++) {
if (pnext[l][d] > r) {
continue;
}
int x = pnext[l][d];
int y = pprev[r][d];
int val = dpnext[l][d] ^ dpprev[r][d] ^ pref[y] ^ pref[x];
if (val < 26) {
mex |= (1 << val);
}
}
int ret = 0;
while (mex & (1 << ret)) {
ret++;
}
return ret;
}
int main() {
cin >> s;
n = s.size();
for (int i = 0; i < n; i++) {
a[i + 1] = s[i] - 'a';
}
for (int j = 0; j < 26; j++) {
pprev[0][j] = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) {
pprev[i][j] = pprev[i - 1][j];
if (a[i] == j) {
pprev[i][j] = i;
}
}
}
for (int j = 0; j < 26; j++) {
pnext[n + 1][j] = n + 1;
}
for (int i = n; i > 0; i--) {
for (int j = 0; j < 26; j++) {
pnext[i][j] = pnext[i + 1][j];
if (a[i] == j) {
pnext[i][j] = i;
}
}
}
for (int i = 1; i <= n; i++) {
int p = pprev[i - 1][a[i]];
if (p) {
pref[i] = pref[p] ^ dpprev[i - 1][a[i]];
} else {
pref[i] = 0;
}
for (int j = i; j > p; j--) {
dpnext[j][a[i]] = solveRange(j, i - 1);
}
vector<pair<int, int> > lindex;
for (int d = 0; d < 26; d++)
if (pprev[i][d]) {
lindex.push_back(make_pair(i - pprev[i][d], d));
}
sort(lindex.begin(), lindex.end());
for (auto it : lindex) {
int d = it.second;
dpprev[i][d] = solveRange(pprev[i][d] + 1, i);
}
}
scanf("%d", &Q);
while (Q--) {
int l, r;
scanf("%d %d", &l, &r);
if (solveRange(l, r)) {
printf("Alice\n");
} else {
printf("Bob\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int f[maxn][26], g[maxn][26], h[maxn][26], pre[maxn][26], suf[maxn][26], n, m;
char str[maxn];
pair<int, int> pla[30];
int calc(int l, int r) {
if (l > r) return 0;
int t = 0;
for (int i = 0; i < 26; i++) {
int nl = suf[l][i], nr = pre[r][i];
if (nl >= l && nr <= r && nr >= l)
t |= 1 << (f[nr][i] ^ f[nl][i] ^ g[l][i] ^ h[r][i]);
}
return __builtin_ctz(~t);
}
int main() {
scanf("%s", str + 1);
n = strlen(str + 1);
for (int i = 1; i <= n; i++) {
str[i] -= 'a';
for (int j = 0; j < 26; j++) pre[i][j] = pre[i - 1][j];
pre[i][str[i]] = i;
}
for (int i = n; i > 0; i--) {
for (int j = 0; j < 26; j++) suf[i][j] = suf[i + 1][j];
suf[i][str[i]] = i;
}
for (int i = 1; i <= n; i++) {
int c = str[i], l = pre[i - 1][c];
for (int j = i - 1; j > l; j--) g[j][c] = calc(j, i - 1);
if (l > 0) f[i][c] = f[l][c] ^ calc(l + 1, i - 1);
int cnt = 0;
for (int j = 0; j < 26; j++)
if (pre[i][j] && j != c) pla[cnt++] = pair<int, int>(pre[i][j], j);
sort(pla, pla + cnt, greater<pair<int, int> >());
for (int j = 0; j < cnt; j++)
h[i][pla[j].second] = calc(pre[i][pla[j].second] + 1, i);
}
scanf("%d", &m);
while (m--) {
int l, r;
scanf("%d%d", &l, &r);
int t = calc(l, r);
puts(t ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
char str[100005];
std::array<int, 27> next[100005];
std::array<int, 27> prev[100005];
std::array<int, 27> nextgrundy[100005];
std::array<int, 27> prevgrundy[100005];
int prefix[100005];
int N;
int query(int L, int R);
int getnextgrundy(int i, int c) {
return (nextgrundy[i][c] != -1) ? nextgrundy[i][c]
: (nextgrundy[i][c] = query(i, next[i][c]));
}
int getprevgrundy(int i, int c) {
return (prevgrundy[i][c] != -1) ? prevgrundy[i][c]
: (prevgrundy[i][c] = query(prev[i][c], i));
}
int getprefix(int i) {
return (prefix[i] != -1) ? prefix[i]
: (prefix[i] = getprefix(prev[i][str[i]]) ^
getprevgrundy(i, str[i]));
}
int query(int L, int R) {
unsigned int mask = 0;
for (int c = 0; c < 27; c++) {
if (next[L][c] >= R) continue;
mask |= (1ULL << (getnextgrundy(L, c) ^ getprevgrundy(R, c) ^
getprefix(next[L][c]) ^ getprefix(prev[R][c])));
}
for (int k = 0; k < 27; k++) {
if ((mask & (1 << k)) == 0) {
return k;
}
}
assert(0);
}
int main() {
scanf("%s", str + 1);
N = strlen(str + 1);
for (int i = 1; i <= N; i++) {
str[i] -= 'a';
}
str[0] = str[N + 1] = 26;
for (int i = 1; i <= N + 1; i++) {
prev[i] = prev[i - 1];
prev[i][str[i - 1]] = i - 1;
}
std::fill(next[N + 1].begin(), next[N + 1].end(), N + 1);
for (int i = N; i >= 0; i--) {
next[i] = next[i + 1];
next[i][str[i + 1]] = i + 1;
}
for (int i = 0; i <= N + 1; i++) {
nextgrundy[i].fill(-1);
prevgrundy[i].fill(-1);
}
for (int i = 0; i <= N + 1; i++) {
prefix[i] = -1;
}
prefix[0] = 0;
int M;
scanf("%d", &M);
while (M-- > 0) {
int L, R;
scanf("%d %d", &L, &R);
if (query(L - 1, R + 1)) {
printf("Alice\n");
} else {
printf("Bob\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ne[100010][27], pre[100010][27], f[100010][27], tmp[27], g[100010];
char s[100010];
int calc(int l, int r, int co, int flag) {
if (tmp[co] != -1) return tmp[co];
int st = 0, mex = 0;
for (int i = 0; i < 26; i++) {
int ll = ne[l][i], rr = pre[r][i];
if (ll < r)
st |= 1 << ((flag ? f[l][i] : calc(l, ll, i, 0)) ^ (g[ll] ^ g[rr]) ^
(flag ? calc(rr + 1, r, i, 1) : f[rr + 1][co]));
}
while (st >> mex & 1) mex++;
tmp[co] = mex;
return mex;
}
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
tmp[s[i] - 'a'] = i;
for (int j = 0; j < 26; j++) pre[i + 1][j] = tmp[j];
}
for (int i = 0; i < 26; i++) ne[n + 1][i] = tmp[i] = n + 1;
for (int i = n; i >= 1; i--) {
tmp[s[i] - 'a'] = i;
for (int j = 0; j < 26; j++) ne[i][j] = tmp[j];
}
for (int i = n; i >= 1; i--) {
g[i] = f[i + 1][s[i] - 'a'] ^ g[ne[i + 1][s[i] - 'a']];
for (int j = 0; j < 26; j++) tmp[j] = -1;
for (int j = 0; j < 26; j++) f[i][j] = calc(i, ne[i][j], j, 0);
}
int m;
scanf("%d", &m);
while (m--) {
int l, r;
scanf("%d%d", &l, &r);
for (int j = 0; j <= 26; j++) tmp[j] = -1;
if (calc(l, r + 1, 26, 1))
puts("Alice");
else
puts("Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return b < a ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int oo = 0x3f3f3f3f;
const int maxn = 100100;
int n;
int a[maxn + 5];
int pre[maxn + 5][27];
int nxt[maxn + 5][27];
int cnt[27][maxn + 5];
int sg_sum[27][maxn + 5];
int sg_pre[maxn + 5][27];
int sg_suf[maxn + 5][27];
int main() {
{
static char s[maxn + 5];
scanf("%s", s);
n = strlen(s);
for (int i = (0), i_end_ = (n); i < i_end_; ++i) a[i] = s[i] - 'a';
}
memset(pre, -1, sizeof pre);
for (int i = (0), i_end_ = (n); i < i_end_; ++i) {
for (int j = (0), j_end_ = (26); j < j_end_; ++j) pre[i + 1][j] = pre[i][j];
pre[i + 1][a[i]] = i;
}
for (int i = (0), i_end_ = (26); i < i_end_; ++i) nxt[n][i] = n;
for (int i = n - 1; i >= 0; --i) {
for (int j = (0), j_end_ = (26); j < j_end_; ++j) nxt[i][j] = nxt[i + 1][j];
nxt[i][a[i]] = i;
}
static int lst[27];
memset(lst, -1, sizeof lst);
for (int i = (0), i_end_ = (n); i < i_end_; ++i) {
for (int j = (0), j_end_ = (26); j < j_end_; ++j) {
sg_sum[j][i + 1] ^= sg_sum[j][i];
cnt[j][i + 1] += cnt[j][i];
}
++cnt[a[i]][i + 1];
lst[a[i]] = i;
int pos[27];
for (int j = (0), j_end_ = (26); j < j_end_; ++j) pos[j] = j;
sort(pos, pos + 26,
[&](int first, int second) { return lst[first] > lst[second]; });
for (int _j = (0), _j_end_ = (26); _j < _j_end_; ++_j) {
int j = pos[_j];
if (lst[j] == i)
sg_pre[i + 1][j] = 0;
else {
int from = lst[j] + 1, to = i + 1;
bool vis[27] = {0};
for (int k = (0), k_end_ = (26); k < k_end_; ++k) {
if (cnt[k][to] - cnt[k][from]) {
int tmp = sg_pre[i + 1][k];
tmp ^= sg_sum[k][pre[to][k]] ^ sg_sum[k][nxt[from][k]];
tmp ^= sg_pre[nxt[from][k]][j];
vis[tmp] = 1;
}
}
sg_pre[i + 1][j] = 0;
while (vis[sg_pre[i + 1][j]]) ++sg_pre[i + 1][j];
}
if (i + 1 == n || j == a[i + 1]) sg_sum[j][i + 1] ^= sg_pre[i + 1][j];
}
}
for (int i = (0), i_end_ = (26); i < i_end_; ++i) lst[i] = n;
for (int i = n - 1; i >= 0; --i) {
lst[a[i]] = i;
int pos[27];
for (int j = (0), j_end_ = (26); j < j_end_; ++j) pos[j] = j;
sort(pos, pos + 26,
[&](int first, int second) { return lst[first] < lst[second]; });
for (int _j = (0), _j_end_ = (26); _j < _j_end_; ++_j) {
int j = pos[_j];
if (lst[j] == i)
sg_suf[i][j] = 0;
else {
int from = i, to = lst[j];
bool vis[27] = {0};
for (int k = (0), k_end_ = (26); k < k_end_; ++k)
if (cnt[k][to] - cnt[k][from]) {
int tmp = sg_suf[i][k];
tmp ^= sg_sum[k][pre[to][k]] ^ sg_sum[k][nxt[from][k]];
tmp ^= sg_suf[pre[to][k] + 1][j];
vis[tmp] = 1;
}
sg_suf[i][j] = 0;
while (vis[sg_suf[i][j]]) ++sg_suf[i][j];
}
}
}
int qn;
scanf("%d", &qn);
for (int i = (0), i_end_ = (qn); i < i_end_; ++i) {
int l, r;
scanf("%d%d", &l, &r), --l;
bool ret = 0;
for (int j = (0), j_end_ = (26); j < j_end_; ++j)
if (cnt[j][r] - cnt[j][l]) {
int tmp = sg_suf[l][j];
tmp ^= sg_sum[j][pre[r][j]] ^ sg_sum[j][nxt[l][j]];
tmp ^= sg_pre[r][j];
if (!tmp) ret = 1;
}
puts(ret ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int limit = 100005;
void add(int pos, int val, int sx[limit]) {
for (; pos < limit; pos += pos & -pos) sx[pos] ^= val;
}
int xbefore(int pos, int sx[limit]) {
int x = 0;
for (; pos; pos -= pos & -pos) x ^= sx[pos];
return x;
}
int n;
int s[limit];
int cases;
int tiempo;
int posle[26][limit];
int posri[26][limit];
int precomputed[2][limit][26];
int sx[26][limit];
struct elem {
int side, pos, car;
elem() {}
elem(int side, int pos, int car) : side(side), pos(pos), car(car) {}
};
int getposri(const elem &e) {
int pos = e.pos;
int c = e.car;
return posri[c][pos];
}
int getposle(const elem &e) {
int pos = e.pos;
int c = e.car;
return posle[c][pos];
}
int size(const elem &e) {
if (e.side) return e.pos - getposle(e);
return getposri(e) - e.pos;
}
bool operator<(const elem &e1, const elem &e2) { return size(e1) < size(e2); }
vector<elem> lista[limit];
void add(elem e) { lista[size(e)].push_back(e); }
int tiempocompute;
int seencompute[limit];
int compute(int l, int r) {
if (l > r) return 0;
if (l == r) return 1;
tiempocompute++;
for (int c = 0; c < 26; c++) {
if (posri[c][l] <= r) {
int pl = posri[c][l];
int pr = posle[c][r];
int solact = 0;
if (l < pl) solact ^= precomputed[0][l][c];
if (pr < r) solact ^= precomputed[1][r][c];
solact ^= xbefore(pr, sx[c]) ^ xbefore(pl, sx[c]);
seencompute[solact] = tiempocompute;
}
}
int sol = 0;
while (seencompute[sol] == tiempocompute) sol++;
return sol;
}
void precompute(elem e) {
int side = e.side;
int pos = e.pos;
int car = e.car;
int &precom = precomputed[side][pos][car];
if (e.side == 0) {
precom = compute(pos, posri[car][pos] - 1);
if (pos == 1 or s[pos - 1] == car) add(posri[car][pos], precom, sx[car]);
} else {
precom = compute(posle[car][pos] + 1, pos);
}
}
char ss[limit];
int main() {
ios::sync_with_stdio(false);
scanf("%s", ss);
scanf("%d", &cases);
n = strlen(ss);
for (int i = 1; i <= n; i++) s[i] = ss[i - 1] - 'a';
for (int C = 0; C < 26; C++) posri[C][n + 1] = n + 1;
for (int C = 0; C < 26; C++) {
for (int i = 1; i <= n; i++) posle[C][i] = s[i] == C ? i : posle[C][i - 1];
for (int i = n; i >= 1; i--) posri[C][i] = s[i] == C ? i : posri[C][i + 1];
}
for (int i = 1; i <= n; i++) {
for (int C = 0; C < 26; C++) {
add(elem(0, i, C));
add(elem(1, i, C));
}
}
for (int j = 0; j < limit; j++) {
vector<elem> &v = lista[j];
for (int i = 0; i < int(v.size()); i++) precompute(v[i]);
}
for (int cas = 0; cas < cases; cas++) {
int l, r;
scanf("%d%d", &l, &r);
if (compute(l, r))
printf("Alice\n");
else
printf("Bob\n");
}
}
|
#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];
vector<int> stx[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;
}
inline int txorf(int j, int l, int r) { return stx[j][r + 1] ^ stx[j][l]; }
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, bool fastx = 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 = fastx ? txorf(i, first, second - 1) : 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);
}
for (int i = 0; i < (int)(26); i++) {
stx[i].resize(pos[i].size() + 1);
stx[i][0] = 0;
for (int j = 0; j < (int)(pos[i].size()); j++) {
stx[i][j + 1] = stx[i][j] ^ tx[i][zx[i] + j];
}
}
for (int i = 0; i < (int)(m); i++) {
puts(solve0(b[i][0], b[i][1], false, true) ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1E5 + 77;
const int cL = 26;
int m_abs(int v) { return v > 0 ? v : -v; }
int LP[cL][maxn], RP[cL][maxn];
unsigned char LV[2][cL][maxn], LVC[2][cL][maxn][cL], SV[cL][maxn];
bool sgv[cL + 3];
int calc(int l, int r) {
int ret = 0;
memset(sgv, 0, sizeof(sgv));
for (int c = 0; c < cL; ++c) {
int pl = RP[c][l], pr = LP[c][r];
if (pl > pr) continue;
int x = SV[c][pr] ^ SV[c][pl];
if (pl != l) x ^= LV[0][c][l];
if (pr != r) x ^= LV[1][c][r];
sgv[x] = true;
}
while (sgv[ret]) ++ret;
return ret;
}
struct PQuery {
int l, r, c;
PQuery(int l, int r, int c) : l(l), r(r), c(c) {}
};
std::vector<PQuery> PQ[maxn];
char S[maxn];
int L;
void __pre() {
for (int i = 0; i < cL; ++i) {
for (int j = 1; j <= L; ++j) {
if (S[j] == 'a' + i)
LP[i][j] = j;
else {
LP[i][j] = LP[i][j - 1];
PQ[j - LP[i][j]].push_back(PQuery(LP[i][j] + 1, j, i + 1));
}
}
}
for (int i = 0; i < cL; ++i) {
RP[i][L + 1] = L + 1;
for (int j = L; j; --j) {
if (S[j] == 'a' + i)
RP[i][j] = j;
else {
RP[i][j] = RP[i][j + 1];
PQ[RP[i][j] - j].push_back(PQuery(j, RP[i][j] - 1, -i - 1));
}
}
}
for (int i = 1; i <= L; ++i) {
for (auto pq : PQ[i]) {
int l = pq.l, r = pq.r, c = m_abs(pq.c) - 1, tl = pq.c > 0, v = 0;
memset(sgv, 0, sizeof(sgv));
for (int j = 0; j < cL; ++j) {
int m;
if (tl)
m = LP[j][r];
else
m = RP[j][l];
if (m < l || m > r) continue;
int x;
if (tl) {
x = LV[tl][j][r];
if (LP[j][m - 1] >= l) {
x ^= LVC[tl][c][m - 1][j];
} else {
x ^= LV[0][j][l];
}
} else {
x = LV[tl][j][l];
if (RP[j][m + 1] <= r) {
x ^= LVC[tl][c][m + 1][j];
} else {
x ^= LV[1][j][r];
}
}
LVC[tl][c][tl ? r : l][j] = x;
sgv[x] = true;
}
while (sgv[v]) ++v;
LV[tl][c][tl ? r : l] = v;
}
PQ[i].clear();
}
for (int i = 0; i < cL; ++i) {
for (int j = 1; j <= L; ++j)
if (S[j] == 'a' + i) {
SV[i][j] = LV[1][i][j - 1] ^ SV[i][LP[i][j - 1]];
}
}
}
int M;
int main() {
scanf("%s", S + 1);
L = strlen(S + 1);
__pre();
scanf("%d", &M);
while (M--) {
int l, r;
scanf("%d%d", &l, &r);
printf("%s\n", calc(l, r) ? "Alice" : "Bob");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 100010;
string S;
int N, Q;
vector<int> P[26];
int L[26][MN], R[26][MN];
struct Info {
int l, r, id;
bool operator<(const Info &i) const { return l < i.l; }
};
vector<Info> seg[MN];
vector<vector<int> > pref[26], suff[26];
int dp1[MN * 200], dp2[MN][26];
int solve2(int idx, int c) {
if (dp2[idx][c] != -1) {
return dp2[idx][c];
}
dp2[0][c] = (P[c][0] - 1 >= 0) ? dp1[pref[c][0][P[c][0] - 1]] : 0;
if (idx == 0) return dp2[0][c];
int p = 0;
for (int i = idx; i >= 0; i--) {
if (dp2[i][c] != -1) {
p = i;
break;
}
}
for (int i = p + 1; i <= idx; i++) {
dp2[i][c] =
dp2[i - 1][c] ^ ((P[c][i] - P[c][i - 1] - 2) >= 0
? dp1[pref[c][i][P[c][i] - P[c][i - 1] - 2]]
: 0);
}
return dp2[idx][c];
}
int solve1(int l, int r) {
vector<int> chk(26, 0);
for (int i = 0; i < 26; i++) {
int a = R[i][l];
int b = L[i][r];
if (a > b) continue;
int tmp1 = 0;
if (P[i][a] - l - 1 < 0)
tmp1 = 0;
else if ((int)suff[i][a].size() > P[i][a] - l - 1) {
tmp1 = dp1[suff[i][a][P[i][a] - l - 1]];
} else {
tmp1 = dp1[pref[i][a][P[i][a] - l - 1]];
}
int tmp2 =
(r - P[i][b] - 1 >= 0) ? dp1[pref[i][b + 1][r - P[i][b] - 1]] : 0;
int Xor = tmp1 ^ tmp2 ^ solve2(a, i) ^ solve2(b, i);
if (Xor < 26) chk[Xor] = 1;
}
for (int i = 0; i < 26; i++)
if (!chk[i]) return i;
return 26;
}
int main() {
cin >> S;
N = S.size();
for (int i = 0; i < S.size(); i++) {
P[S[i] - 'a'].push_back(i);
}
for (int i = 0; i < 26; i++) {
int la = -1;
for (int j = 0; j < S.size(); j++) {
if (S[j] - 'a' == i) la++;
L[i][j] = la;
}
la = P[i].size();
for (int j = (int)S.size() - 1; j >= 0; j--) {
if (S[j] - 'a' == i) la--;
R[i][j] = la;
}
}
int cnt = 0;
for (int i = 0; i < 26; i++) {
int st = 0;
pref[i] = suff[i] = vector<vector<int> >(P[i].size() + 1);
for (int j = 0; j < P[i].size(); j++) {
if (P[i][j] - st) {
for (int k = st; k < P[i][j]; k++) {
seg[k].push_back({st, k, cnt});
pref[i][j].push_back(cnt);
cnt++;
}
for (int k = P[i][j] - 1; k > st; k--) {
seg[P[i][j] - 1].push_back({k, P[i][j] - 1, cnt});
suff[i][j].push_back(cnt);
cnt++;
}
}
st = P[i][j] + 1;
}
if (N - st) {
for (int k = st; k < N; k++) {
seg[k].push_back({st, k, cnt});
pref[i][P[i].size()].push_back(cnt);
cnt++;
}
for (int k = N - 1; k > st; k--) {
seg[N - 1].push_back({k, N - 1, cnt});
suff[i][P[i].size()].push_back(cnt);
cnt++;
}
}
}
memset(dp2, -1, sizeof(dp2));
for (int len = 0; len < N; len++) {
sort(seg[len].begin(), seg[len].end());
for (int x = (int)seg[len].size() - 1; x >= 0; x--) {
int l = seg[len][x].l;
int r = seg[len][x].r;
int n = seg[len][x].id;
dp1[n] = solve1(l, r);
}
}
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
int l, r;
scanf("%d %d", &l, &r);
l--;
r--;
if (solve1(l, r))
printf("Alice\n");
else
printf("Bob\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - 48;
x *= f;
}
char s[100010];
int prsum[30][100010], xtonx[30][100010], prtox[30][100010];
int nx[30][100010], pr[30][100010];
int n, la[30];
int qy(int l, int r);
int qnx(int x, int op) {
if (xtonx[op][x] == -1) xtonx[op][x] = qy(x, nx[op][x]);
return xtonx[op][x];
}
int qpr(int x, int op) {
if (prtox[op][x] == -1) prtox[op][x] = qy(pr[op][x], x);
return prtox[op][x];
}
int ask(int x, int op) {
if (prsum[op][x] == -1) prsum[op][x] = ask(pr[op][x], op) ^ qpr(x, op);
return prsum[op][x];
}
int qy(int l, int r) {
if (r - l <= 1) return 0;
int rt = 0;
for (int i = 0; i < 26; ++i) {
if (nx[i][l] >= r) continue;
rt |= (1 << (qnx(l, i) ^ qpr(r, i) ^ ask(nx[i][l], i) ^ ask(pr[i][r], i)));
}
for (int i = 0; i < 27; ++i)
if ((rt & (1 << i)) == 0) return i;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
s[0] = 'a', s[n + 1] = 'a';
for (int i = 1; i <= n + 1; ++i) {
for (int j = 0; j < 26; ++j) pr[j][i] = la[j];
la[s[i] - 'a'] = i;
}
for (int j = 0; j < 26; ++j) la[j] = n + 1;
for (int i = n; i >= 0; --i) {
for (int j = 0; j < 26; ++j) nx[j][i] = la[j];
la[s[i] - 'a'] = i;
}
memset(prsum, -1, sizeof(prsum));
memset(xtonx, -1, sizeof(xtonx));
memset(prtox, -1, sizeof(prtox));
for (int j = 0; j < 26; ++j) prsum[j][0] = 0;
int q;
read(q);
while (q--) {
int l, r;
read(l);
read(r);
if (qy(l - 1, r + 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;
const int N = 100005;
int n, m, sum[N], pre[N][26], suf[N][26], pref[N][26], suff[N][26];
bool visit[40];
char s[N];
int solve(int l, int r) {
if (l > r) {
return 0;
}
for (int i = 0; i <= 26; ++i) {
visit[i] = false;
}
for (int i = 0; i < 26; ++i) {
if (suf[l][i] <= r) {
int x = suf[l][i], y = pre[r][i];
visit[suff[l][i] ^ pref[r][i] ^ sum[y] ^ sum[x]] = true;
}
}
for (int i = 0;; ++i) {
if (!visit[i]) {
return i;
}
}
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 26; ++j) {
pre[i][j] = pre[i - 1][j];
}
pre[i][s[i] - 'a'] = i;
}
for (int i = 0; i < 26; ++i) {
suf[n + 1][i] = n + 1;
}
for (int i = n; i; --i) {
for (int j = 0; j < 26; ++j) {
suf[i][j] = suf[i + 1][j];
}
suf[i][s[i] - 'a'] = i;
}
for (int i = 1; i <= n; ++i) {
sum[i] = sum[pre[i - 1][s[i] - 'a']];
if (pre[i - 1][s[i] - 'a']) {
sum[i] ^= pref[i - 1][s[i] - 'a'];
}
for (int j = i; j > pre[i - 1][s[i] - 'a']; --j) {
suff[j][s[i] - 'a'] = solve(j, i - 1);
}
vector<pair<int, int> > all;
for (int j = 0; j < 26; ++j) {
if (pre[i][j]) {
all.emplace_back(pre[i][j], j);
}
}
sort(all.begin(), all.end());
reverse(all.begin(), all.end());
for (int j = 0; j < all.size(); ++j) {
int c = all[j].second;
pref[i][c] = solve(pre[i][c] + 1, i);
}
}
scanf("%d", &m);
while (m--) {
int l, r;
scanf("%d %d", &l, &r);
puts(solve(l, r) ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 123456;
const int M = 30;
unordered_map<int, int> sg[N];
int pre[N][M], suf[N][M];
int L[N][M], R[N][M];
int f[N], key[N], w[N], n, q, l, r;
char s[N];
vector<pair<int, int>> rg[N];
void add(int l, int r) { rg[r - l].push_back(make_pair(l, r)); }
int find(int x) {
if (f[x] == x)
return x;
else {
int y = f[x];
int z = find(f[x]);
key[x] ^= key[y];
f[x] = z;
return z;
}
}
int findkey(int x) {
find(x);
return key[x];
}
int query(int l, int r, int ty = 0);
int queryL(int l, int sig) {
if (L[l][sig] != -1)
return L[l][sig];
else
return L[l][sig] = query(l, suf[l + 1][sig]);
}
int queryR(int r, int sig) {
if (R[r][sig] != -1)
return R[r][sig];
else
return R[r][sig] = query(pre[r - 1][sig], r);
}
int query(int l, int r, int ty) {
if (sg[l].count(r)) return sg[l][r];
if (l + 1 == r) {
sg[l][r] = 0;
if (ty) return 0;
if (w[l] == w[r]) {
assert(find(l) != find(r));
f[r] = l;
key[r] = 0;
}
return 0;
}
int s = 0;
for (int sig = 0; sig < 26; sig++) {
if (suf[l + 1][sig] < r) {
int val = queryL(l, sig) ^ queryR(r, sig) ^ findkey(suf[l + 1][sig]) ^
findkey(pre[r - 1][sig]);
assert(find(suf[l + 1][sig]) == find(pre[r - 1][sig]));
s |= (1 << val);
}
}
int a = 0;
while (s & (1 << a)) a++;
sg[l][r] = a;
if (ty) return a;
if (w[l] == w[r]) {
assert(find(l) != find(r));
f[r] = l;
key[r] = a;
}
return a;
}
int main() {
memset(L, -1, sizeof(L));
memset(R, -1, sizeof(R));
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) w[i] = s[i] - 'a';
w[0] = -1;
w[n + 1] = -2;
for (int i = 0; i <= n + 1; i++) f[i] = i;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) pre[i][j] = pre[i - 1][j];
pre[i][w[i]] = i;
for (int j = 0; j < 26; j++) add(pre[i][j], i + 1);
}
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][w[i]] = i;
for (int j = 0; j < 26; j++) add(i - 1, suf[i][j]);
}
for (int d = 1; d <= n + 1; d++) {
for (auto seg : rg[d]) {
query(seg.first, seg.second);
}
}
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d%d", &l, &r);
puts(query(l - 1, r + 1, 1) ? "Alice" : "Bob");
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXLEN = 100000;
const int MAXQ = 100000;
const int ALPH = 26;
const int MAXVAL = 31;
char s[MAXLEN + 1];
int slen;
int nq;
int ql[MAXQ], qr[MAXQ], qans[MAXQ];
int nxt[MAXLEN + 1][ALPH];
int prv[MAXLEN + 1][ALPH];
vector<int> need[MAXLEN];
vector<int> dp[MAXLEN];
int fstval[MAXLEN];
int suffval[MAXLEN + 1];
int nxtval[MAXLEN + 1][ALPH];
int prvval[MAXLEN + 1][ALPH];
int mark[MAXVAL + 1], curmark;
void solve() {
for (int k = (0); k < (ALPH); ++k) {
nxt[slen][k] = slen;
for (int i = slen - 1; i >= 0; --i)
nxt[i][k] = s[i] == 'a' + k ? i : nxt[i + 1][k];
}
for (int k = (0); k < (ALPH); ++k) {
prv[0][k] = -1;
for (int i = (0); i < (slen); ++i)
prv[i + 1][k] = s[i] == 'a' + k ? i : prv[i][k];
}
for (int i = (0); i < (slen); ++i) need[i].clear();
for (int i = (0); i < (nq); ++i) need[ql[i]].push_back(qr[i]);
for (int i = (0); i < (slen); ++i)
for (int k = (0); k < (ALPH); ++k)
if (nxt[i][k] != i) need[i].push_back(nxt[i][k] - 1);
for (int i = (1); i <= (slen); ++i)
for (int k = (0); k < (ALPH); ++k)
if (prv[i][k] != -1 && prv[i][k] != i - 1)
need[prv[i][k] + 1].push_back(i - 1);
for (int i = (0); i < (slen); ++i) {
sort(need[i].begin(), need[i].end());
need[i].erase(unique(need[i].begin(), need[i].end()), need[i].end());
}
for (int i = (0); i < (slen); ++i) fstval[i] = suffval[i] = -1;
suffval[slen] = 0;
for (int i = (0); i <= (slen); ++i)
for (int k = (0); k < (ALPH); ++k) nxtval[i][k] = prvval[i][k] = -1;
memset(mark, -1, sizeof(mark));
curmark = -1;
for (int l = slen - 1; l >= 0; --l) {
fstval[l] =
nxt[l + 1][s[l] - 'a'] == slen ? suffval[l + 1]
: s[l + 1] == s[l]
? fstval[l + 1]
: (nxtval[l + 1][s[l] - 'a'] ^ fstval[nxt[l + 1][s[l] - 'a']]);
dp[l].resize(((int)(need[l]).size()));
for (int i = (0); i < (((int)(need[l]).size())); ++i) {
int r = need[l][i];
++curmark;
for (int k = (0); k < (ALPH); ++k) {
if (nxt[l][k] > r) continue;
int L = nxt[l][k], R = prv[r + 1][k];
assert(l <= L && L <= R && R <= r && s[L] == 'a' + k &&
s[R] == 'a' + k);
int kval = fstval[L] ^ fstval[R];
if (L != l) {
assert(nxtval[l][k] != -1);
kval ^= nxtval[l][k];
}
if (R != r) {
assert(prvval[r + 1][k] != -1);
kval ^= prvval[r + 1][k];
}
mark[kval] = curmark;
}
int curval = 0;
while (mark[curval] == curmark) ++curval;
dp[l][i] = curval;
if (r + 1 < slen && nxt[l][s[r + 1] - 'a'] == r + 1)
nxtval[l][s[r + 1] - 'a'] = curval;
if (l - 1 >= 0 && prv[r + 1][s[l - 1] - 'a'] == l - 1)
prvval[r + 1][s[l - 1] - 'a'] = curval;
if (r + 1 == slen) suffval[l] = curval;
}
}
for (int i = (0); i < (nq); ++i) {
int l = ql[i], r = qr[i];
int idx = lower_bound(need[l].begin(), need[l].end(), r) - need[l].begin();
assert(idx < ((int)(need[l]).size()) && need[l][idx] == r);
qans[i] = dp[l][idx];
}
}
void run() {
scanf("%s", s);
slen = strlen(s);
scanf("%d", &nq);
for (int i = (0); i < (nq); ++i)
scanf("%d%d", &ql[i], &qr[i]), --ql[i], --qr[i];
solve();
for (int i = (0); i < (nq); ++i)
printf("%s\n", qans[i] != 0 ? "Alice" : "Bob");
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, len;
};
char s[100010];
int n, m, pre[100010][30], nxt[100010][30];
int f[100010][30], fl[100010][30], fr[100010][30];
vector<node> v;
vector<int> g;
bool cmp(node x, node y) { return x.len < y.len; }
inline int mex(int mask) {
for (int i = 0; i < 26; i++) {
if (!(mask & (1 << i))) {
return i;
}
}
return 26;
}
int work1(int i, int j) {
int mask = 0;
for (int k = 0; k < 26; k++) {
if (nxt[i][k] > j) {
continue;
}
int l = nxt[i][k];
int r = pre[j][k];
int h = nxt[l + 1][k], now = 0;
while (h <= r) {
now ^= f[h][k];
h = nxt[h + 1][k];
}
if (i < l) {
if (fr[i][k] == -1) {
fr[i][k] = work1(i, l - 1);
}
now ^= fr[i][k];
}
if (j > r) {
if (fl[j][k] == -1) {
fl[j][k] = work1(r + 1, j);
}
now ^= fl[j][k];
}
if (now < 26) {
mask |= (1 << now);
}
}
return mex(mask);
}
int work2(int i, int j) {
int mask = 0;
for (int k = 0; k < 26; k++) {
if (nxt[i][k] > j) {
continue;
}
int l = nxt[i][k];
int r = pre[j][k];
int now = f[l][k] ^ f[r][k];
if (i < l) {
if (fr[i][k] == -1) {
fr[i][k] = work2(i, l - 1);
}
now ^= fr[i][k];
}
if (j > r) {
if (fl[j][k] == -1) {
fl[j][k] = work2(r + 1, j);
}
now ^= fl[j][k];
}
if (now < 26) {
mask |= (1 << now);
}
}
return mex(mask);
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 0; i < 26; i++) {
pre[0][i] = 0;
nxt[n + 1][i] = n + 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) {
pre[i][j] = pre[i - 1][j];
}
pre[i][s[i] - 'a'] = i;
}
for (int i = n; i; i--) {
for (int j = 0; j < 26; j++) {
nxt[i][j] = nxt[i + 1][j];
}
nxt[i][s[i] - 'a'] = i;
}
for (int i = 0; i < 26; i++) {
g.clear();
for (int j = 1; j <= n; j++) {
if (s[j] == 'a' + i) {
g.push_back(j);
}
}
for (int j = 1; j < g.size(); j++) {
v.push_back((node){g[j - 1], g[j], g[j] - g[j - 1] + 1});
}
}
sort(v.begin(), v.end(), cmp);
memset(fl, -1, sizeof(fl));
memset(fr, -1, sizeof(fr));
for (int i = 0; i < v.size(); i++) {
int l = v[i].l;
int r = v[i].r;
if (l + 1 >= r) {
continue;
}
f[r][s[r] - 'a'] = work1(l + 1, r - 1);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) {
f[i][j] ^= f[i - 1][j];
}
}
scanf("%d", &m);
while (m--) {
int l, r;
scanf("%d%d", &l, &r);
if (work2(l, r)) {
puts("Alice");
} else {
puts("Bob");
}
}
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>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
const int mod = 1e9 + 7;
const long double Pi = acos(-1.0);
using ll = long long;
using ii = pair<int, int>;
const int N = 1e5 + 5;
string str;
int n;
int prv[N][26], nxt[N][26];
int grundy[N], dp[N][26];
int mem[27];
int solve(int l, int r, int c, bool f) {
if (l > r) return 0;
if (~mem[c]) return mem[c];
int mask = 0;
for (int i = 0; i < 26; i++) {
int a = nxt[l][i], b = prv[r][i];
if (b >= l) {
int val = grundy[b] ^ grundy[a];
if (f) {
val ^= dp[r][i] ^ solve(l, a - 1, i, 1);
} else {
val ^= dp[a - 1][c] ^ solve(b + 1, r, i, 0);
}
mask |= (1 << val);
}
}
mem[c] = 26;
for (int i = 0; i < 26; i++)
if (mask >> i & 1 ^ 1) {
mem[c] = i;
break;
}
return mem[c];
}
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> str;
int n = str.size();
str = "#" + str;
for (int i = 1; i <= n; i++) {
str[i] -= 'a';
for (int j = 0; j < 26; j++) {
prv[i][j] = prv[i - 1][j];
}
prv[i][str[i]] = i;
}
for (int i = 0; i < 26; i++) nxt[n + 1][i] = 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][str[i]] = i;
}
for (int i = 1; i <= n; i++) {
grundy[i] = grundy[prv[i - 1][str[i]]] ^ dp[i - 1][str[i]];
memset(mem, -1, sizeof mem);
for (int j = 0; j < 26; j++) dp[i][j] = solve(prv[i][j] + 1, i, j, 0);
}
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
memset(mem, -1, sizeof mem);
cout << (solve(l, r, 26, 1) ? "Alice\n" : "Bob\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2,unroll-loops")
using namespace std;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 100010, SGM = 26;
int n, m, k, u, v, x, y, t, l, r, shit;
int A[MAXN], mark[MAXN], pref[MAXN];
int dp[MAXN][SGM], pd[MAXN][SGM];
int prv[MAXN][SGM], nxt[MAXN][SGM];
pair<int, int> P[SGM];
string S;
int Get(int l, int r) {
if (l > r) return 0;
shit++;
for (int c = 0; c < SGM; c++)
if (l <= prv[r][c]) {
int L = nxt[l][c], R = prv[r][c];
int g = pd[l][c] ^ dp[r][c];
g ^= pref[R] ^ pref[L];
mark[g] = shit;
}
int res = 0;
while (mark[res] == shit) res++;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> S;
n = S.size();
for (int i = 1; i <= n; i++) A[i] = S[i - 1] - 'a';
A[0] = A[n + 1] = -1;
for (int i = 1; i <= n; i++) {
memcpy(prv[i], prv[i - 1], sizeof(prv[i]));
prv[i][A[i]] = i;
}
fill(nxt[n + 1], nxt[n + 1] + SGM, n + 1);
for (int i = n; i; i--) {
memcpy(nxt[i], nxt[i + 1], sizeof(nxt[i]));
nxt[i][A[i]] = i;
}
for (int r = 1; r <= n; r++) {
int last = prv[r - 1][A[r]];
pref[r] = pref[last] ^ dp[r - 1][A[r]];
for (int i = 0; i < SGM; i++) P[i] = {prv[r][i], i};
sort(P, P + SGM);
for (int i = last + 1; i < r; i++) pd[i][A[r]] = Get(i, r - 1);
for (int i = SGM - 2; ~i; i--) dp[r][P[i].second] = Get(P[i].first + 1, r);
}
cin >> m;
while (m--) {
cin >> l >> r;
cout << (Get(l, r) ? "Alice" : "Bob") << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 239;
const int alf = 26;
int n, q;
string s;
int posr[alf][M], posl[alf][M], dpl[alf][M], dpr[alf][M], z[alf][M];
int k, kols[alf], id[M];
inline int gett_slow(int l, int r) {
int mask = 0;
for (int x = 0; x < alf; x++) {
if (posr[x][l] > r) continue;
int lf = posr[x][l];
int rf = posl[x][r];
int now = 0;
for (int i = id[lf]; i < id[rf]; i++) now ^= z[x][i + 1];
if (l < lf) {
if (dpr[x][l] == -1) dpr[x][l] = gett_slow(l, lf - 1);
now ^= dpr[x][l];
}
if (rf < r) {
if (dpl[x][r] == -1) dpl[x][r] = gett_slow(rf + 1, r);
now ^= dpl[x][r];
}
if (now < alf) mask |= (1 << now);
}
for (int i = 0; i < alf; i++)
if (((mask >> i) & 1) == 0) return i;
return alf;
}
inline int gett_fast(int l, int r) {
int mask = 0;
for (int x = 0; x < alf; x++) {
if (posr[x][l] > r) continue;
int lf = posr[x][l];
int rf = posl[x][r];
int now = (z[x][id[lf]] ^ z[x][id[rf]]);
if (l < lf) {
if (dpr[x][l] == -1) dpr[x][l] = gett_fast(l, lf - 1);
now ^= dpr[x][l];
}
if (rf < r) {
if (dpl[x][r] == -1) dpl[x][r] = gett_fast(rf + 1, r);
now ^= dpl[x][r];
}
if (now < alf) mask |= (1 << now);
}
for (int i = 0; i < alf; i++)
if (((mask >> i) & 1) == 0) return i;
return alf;
}
int main() {
ios::sync_with_stdio(0);
cin >> s;
n = (int)s.size();
for (int i = 0; i < n; i++) {
id[i] = kols[s[i] - 'a'];
kols[s[i] - 'a']++;
}
for (int i = 0; i < alf; i++) posr[i][n] = n;
for (int i = n - 1; i >= 0; i--) {
for (int x = 0; x < alf; x++) posr[x][i] = posr[x][i + 1];
posr[s[i] - 'a'][i] = i;
}
for (int i = 0; i < alf; i++) posl[i][0] = -1;
posl[s[0] - 'a'][0] = 0;
for (int i = 1; i < n; i++) {
for (int x = 0; x < alf; x++) posl[x][i] = posl[x][i - 1];
posl[s[i] - 'a'][i] = i;
}
memset(dpl, -1, sizeof(dpl));
memset(dpr, -1, sizeof(dpr));
memset(z, 0, sizeof(z));
vector<tuple<int, int, int> > seg;
for (int x = 0; x < alf; x++) {
vector<int> pos;
for (int i = 0; i < n; i++)
if (s[i] - 'a' == x) pos.push_back(i);
for (int t = 0; t < (int)pos.size() - 1; t++)
seg.push_back(make_tuple(pos[t + 1] - pos[t] - 1, pos[t], pos[t + 1]));
}
sort(seg.begin(), seg.end());
for (tuple<int, int, int> t : seg) {
int l = get<1>(t);
int r = get<2>(t);
if (r == l + 1) continue;
int x = gett_slow(l + 1, r - 1);
z[s[r] - 'a'][id[r]] = x;
}
for (int x = 0; x < alf; x++)
for (int i = 1; i < kols[x]; i++) z[x][i] ^= z[x][i - 1];
cin >> q;
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
l--, r--;
cout << (gett_fast(l, r) == 0 ? "Bob\n" : "Alice\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) f = ch ^ 45, ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return f ? x : -x;
}
char ch[100010];
int n, a[100010], pre[100010][26], suf[100010][26];
int f[100010][26], g[100010], 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 = read();
for (int i = 1; i <= q; i++) {
int l = read(), r = read();
memset(mem, -1, sizeof(mem));
if (calc(l, r, 26, 1))
puts("Alice");
else
puts("Bob");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXSIZE = 10000020;
int bufpos;
char buf[MAXSIZE];
void init() {
buf[fread(buf, 1, MAXSIZE, stdin)] = '\0';
bufpos = 0;
}
int readint() {
int val = 0;
for (; !isdigit(buf[bufpos]); bufpos++)
;
for (; isdigit(buf[bufpos]); bufpos++) val = val * 10 + buf[bufpos] - '0';
return val;
}
char readchar() {
for (; isspace(buf[bufpos]); bufpos++)
;
return buf[bufpos++];
}
int readstr(char* s) {
int cur = 0;
for (; isspace(buf[bufpos]); bufpos++)
;
for (; !isspace(buf[bufpos]); bufpos++) s[cur++] = buf[bufpos];
s[cur] = '\0';
return cur;
}
const int maxn = 100005;
int pre[maxn][26], suf[maxn][26];
struct block {
int n, sz, cnt;
int a[maxn], np[maxn];
int sum[maxn];
int st[433], bs[433];
void init(int n) {
if (n <= 0) return;
this->n = n;
st[1] = 1;
sz = sqrt(n) + 0.5;
cnt = (n - 1) / sz + 1;
for (int i = 1; i <= n; i++) np[i] = (i - 1) / sz + 1;
st[1] = 1;
for (int i = 2; i <= cnt; i++) st[i] = st[i - 1] + sz;
st[cnt + 1] = n + 1;
}
void add(int p, int v) {
int u = np[p];
for (int i = u; i <= cnt; i++) bs[i] ^= v;
for (int i = p; i < st[u + 1]; i++) {
sum[i] ^= v;
}
}
inline int query(int r) { return r ? (sum[r] ^ bs[np[r] - 1]) : 0; }
} b[26];
int p[maxn][26], id[maxn], cur[26];
int nxt[maxn][26], lst[maxn][26];
char s[maxn];
struct seg {
int l, r, c;
bool operator<(const seg& rhs) const { return r - l < rhs.r - rhs.l; }
} a[maxn * 53], w[maxn * 53];
int sum[maxn];
int query(int l, int r) {
if (l == r) return 1;
unsigned ans = 0;
for (int i = 0; i < 26; i++) {
if (nxt[l][i] == nxt[r + 1][i] || nxt[l][i] == cur[i] + 1) continue;
int now = suf[l][i] ^ pre[r][i] ^ b[i].query(lst[r][i] - 1) ^
b[i].query(nxt[l][i] - 1);
ans |= 1U << now;
}
for (int i = 0; i < 26; i++)
if (!(ans >> i & 1)) return i;
return 26;
}
int main() {
init();
int n = readstr(s + 1);
for (int i = 1; i <= n; i++) p[id[i] = ++cur[s[i] - 'a']][s[i] - 'a'] = i;
int cnt = 0;
for (int i = 0; i < 26; i++) {
int now = 1;
for (int j = 1; j <= n; j++) {
nxt[j][i] = now;
if (s[j] == i + 'a')
now++;
else if (now <= cur[i])
a[++cnt] = (seg){j, p[now][i] - 1, i};
}
now = cur[i];
for (int j = n; j; j--) {
lst[j][i] = now;
if (s[j] == i + 'a')
now--;
else if (now && (now == cur[i] || j != p[now + 1][i] - 1))
a[++cnt] = (seg){p[now][i] + 1, j, i};
}
}
for (int i = 0; i < 26; i++) b[i].init(cur[i] - 1);
for (int i = 1; i <= cnt; i++) sum[a[i].r - a[i].l + 1]++;
for (int i = 1; i <= n; i++) sum[i] += sum[i - 1];
for (int i = 1; i <= cnt; i++) w[sum[a[i].r - a[i].l + 1]--] = a[i];
for (int i = 1; i <= cnt; i++) {
int now = query(w[i].l, w[i].r);
bool fl = s[w[i].l - 1] == w[i].c + 'a', fr = s[w[i].r + 1] == w[i].c + 'a';
if (fl) pre[w[i].r][w[i].c] = now;
if (fr) suf[w[i].l][w[i].c] = now;
if (fl && fr) {
b[w[i].c].add(id[w[i].l - 1], now);
}
}
int m = readint();
while (m--) {
int l = readint(), r = readint();
puts(query(l, r) ? "Alice" : "Bob");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m, ne[N][26], la[N][26], g[N];
char s[N];
bool vis[N][26];
inline bool& Vis(int l, int r) { return vis[l][s[r + 1] - 'a']; }
int f[N][26];
inline int& F(int l, int r) { return f[l][s[r + 1] - 'a']; }
int ask_l, ask_r, rm[N << 1];
stack<int> sta;
inline int Calc(int l, int r) {
if (l > r) return 0;
if (l > 1 && r < n && ne[l][s[l - 1] - 'a'] > r &&
la[r][s[r + 1] - 'a'] < l) {
if (Vis(l, r)) return F(l, r);
Vis(l, r) = 1;
int mask = 0;
for (int i = 0; i < 26; ++i)
if (ne[l][i] <= r) {
int sg = 0, pos = l;
while (ne[pos][i] <= r) {
sg ^= Calc(pos, ne[pos][i] - 1);
pos = ne[pos][i] + 1;
}
sg ^= Calc(pos, r);
if (sg < 26) mask |= 1 << sg;
}
for (int i = 0; i <= 26; ++i)
if ((mask >> i & 1) == 0) return F(l, r) = i;
} else {
int mask = 0, id;
if (l == ask_l) {
id = r;
} else if (r == ask_r) {
id = l + n + 1;
} else
assert(0);
if (rm[id] != -1) return rm[id];
sta.push(id);
for (int i = 0; i < 26; ++i)
if (ne[l][i] <= r) {
int x = ne[l][i], y = la[r][i];
int sg = Calc(l, x - 1) ^ Calc(y + 1, r) ^ g[y] ^ g[x];
if (sg < 26) mask |= 1 << sg;
}
for (int i = 0; i <= 26; ++i)
if ((mask >> i & 1) == 0) return rm[id] = i;
}
assert(0);
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 0; i < 26; ++i) ne[n + 1][i] = n + 1;
for (int i = n; i; --i) {
memcpy(ne[i], ne[i + 1], sizeof ne[i]);
ne[i][s[i] - 'a'] = i;
}
for (int i = 0; i < 26; ++i) la[0][i] = 0;
for (int i = 1; i <= n; ++i) {
memcpy(la[i], la[i - 1], sizeof la[i]);
la[i][s[i] - 'a'] = i;
}
for (int i = 1; i <= n; ++i) {
int d = s[i] - 'a';
if (la[i - 1][d]) g[i] = g[la[i - 1][d]] ^ Calc(la[i - 1][d] + 1, i - 1);
}
scanf("%d", &m);
memset(rm, -1, sizeof rm);
for (int i = 1, x, y; i <= m; ++i) {
scanf("%d%d", &x, &y);
ask_l = x;
ask_r = y;
puts(Calc(x, y) ? "Alice" : "Bob");
while (!sta.empty()) rm[sta.top()] = -1, sta.pop();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int A = 26;
string s;
int first_occ[A][N][2];
int occ_id[N];
vector<int> pos[A];
vector<int> acc_grundy[A];
int memo[N][A][2];
int cnt_iter;
set<pair<int, int>> vis;
int solve(int l, int r) {
if (r < l) return 0;
bool maximal_right =
(r + 1 != s.size() && first_occ[s[r + 1] - 'a'][l][0] == r + 1);
bool maximal_left = (l != 0 && first_occ[s[l - 1] - 'a'][r][1] == l - 1);
if (maximal_right && memo[l][s[r + 1] - 'a'][0] != -1) {
return memo[l][s[r + 1] - 'a'][0];
} else if (maximal_left && memo[r][s[l - 1] - 'a'][1] != -1) {
return memo[r][s[l - 1] - 'a'][1];
}
++cnt_iter;
int mex = 0;
for (int ch = 0; ch < A; ++ch) {
if (pos[ch].empty()) continue;
int first_occ_from_left = first_occ[ch][l][0];
int first_occ_from_right = first_occ[ch][r][1];
if (first_occ_from_left > r) continue;
int res = 0;
if (acc_grundy[ch].size() != pos[ch].size()) {
for (int i = occ_id[first_occ_from_left];
i < occ_id[first_occ_from_right]; ++i) {
++cnt_iter;
res ^= solve(pos[ch][i] + 1, pos[ch][i + 1] - 1);
}
} else {
res = acc_grundy[ch][occ_id[first_occ_from_left]] ^
acc_grundy[ch][occ_id[first_occ_from_right]];
}
res ^= solve(l, first_occ_from_left - 1);
res ^= solve(first_occ_from_right + 1, r);
mex |= (1 << res);
}
int res = 0;
while ((mex >> res) & 1) {
++res;
}
if (maximal_right) {
memo[l][s[r + 1] - 'a'][0] = res;
}
if (maximal_left) {
memo[r][s[l - 1] - 'a'][1] = res;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> s;
memset(memo, -1, sizeof memo);
for (int i = 0; i < s.size(); ++i) {
int ch = s[i] - 'a';
occ_id[i] = pos[ch].size();
pos[ch].push_back(i);
}
for (int ch = 0; ch < A; ++ch) {
int lst = N;
for (int i = s.size() - 1; i >= 0; --i) {
if (s[i] - 'a' == ch) {
lst = i;
}
first_occ[ch][i][0] = lst;
}
}
for (int ch = 0; ch < A; ++ch) {
int lst = -1;
for (int i = 0; i < s.size(); ++i) {
if (s[i] - 'a' == ch) {
lst = i;
}
first_occ[ch][i][1] = lst;
}
}
for (int ch = 0; ch < A; ++ch) {
if (pos[ch].empty()) continue;
acc_grundy[ch].push_back(0);
for (int i = 0; i + 1 < pos[ch].size(); ++i) {
int res = solve(pos[ch][i] + 1, pos[ch][i + 1] - 1);
acc_grundy[ch].push_back(acc_grundy[ch].back() ^ res);
}
}
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
--l, --r;
cout << (solve(l, r) != 0 ? "Alice" : "Bob") << '\n';
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC target("avx,sse2,sse3,sse4,mmx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
using namespace std;
const int N = 100010;
char s[N];
int m, n, f[N][26], L[N][26], rec[N], suff[N][26], pref[N][26];
int mex(int x) {
int ret = 0;
while (x & (1 << ret)) ++ret;
return ret;
}
int calc(int l, int r) {
if (l > r) return 0;
int g = 0;
for (int j = 0; j < 26; ++j) {
int fi = f[l][j];
int la = L[r][j];
if (fi <= r) {
int cc = rec[fi] ^ rec[la] ^ suff[l][j] ^ pref[r][j];
g |= 1 << cc;
}
}
return mex(g);
}
int main() {
ios::sync_with_stdio(0);
cin >> (s + 1);
n = strlen(s + 1);
for (int j = 0; j < 26; ++j) {
for (int i = 1; i <= n; ++i) L[i][j] = (s[i] == j + 'a' ? i : L[i - 1][j]);
f[n + 1][j] = n + 1;
for (int i = n; i >= 1; --i) f[i][j] = (s[i] == j + 'a' ? i : f[i + 1][j]);
}
for (int i = 1; i <= n; ++i) {
rec[i] = rec[L[i - 1][s[i] - 'a']] ^ pref[i - 1][s[i] - 'a'];
for (int j = i; j > L[i - 1][s[i] - 'a']; --j)
suff[j][s[i] - 'a'] = calc(j, i - 1);
vector<pair<int, int> > ans;
for (int j = 0; j < 26; ++j)
if (L[i][j]) ans.emplace_back(L[i][j], j);
sort(ans.rbegin(), ans.rend());
for (int j = 0; j < ans.size(); ++j) {
int c = ans[j].second;
pref[i][c] = calc(L[i][c] + 1, i);
}
}
cin >> m;
for (int i = 1; i <= m; ++i) {
int l, r;
cin >> l >> r;
cout << (calc(l, r) ? "Alice" : "Bob") << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int f = 1, ans = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
ans = ans * 10 + c - '0';
c = getchar();
}
return f * ans;
}
const int MAXN = 1e5 + 11;
char S[MAXN];
int N, f[MAXN][26], F[MAXN][26], g[MAXN], pre[MAXN][26], suf[MAXN][26],
Vis[MAXN], Q;
int calc(int L, int R) {
if (L > R) return 0;
int sta[28];
sta[0] = 0;
for (int c = 0; c < 26; c++) {
int l = suf[L][c], r = pre[R][c];
if (l > r) continue;
int res = g[r] ^ g[l];
if (L <= l - 1) res ^= f[l - 1][S[L - 1] - 'a'];
if (r + 1 <= R) {
if (f[R][S[r] - 'a'] != -1)
res ^= f[R][S[r] - 'a'];
else {
int x = calc(r + 1, R);
res ^= x;
f[R][S[r] - 'a'] = x;
}
}
sta[++sta[0]] = res;
}
for (int i = 1; i <= sta[0]; i++) Vis[sta[i]] = 1;
int ps = 0;
while (Vis[ps]) ++ps;
for (int i = 1; i <= sta[0]; i++) Vis[sta[i]] = 0;
sta[0] = 0;
return ps;
}
int Solve(int L, int R) {
if (L > R) return 0;
int sta[28];
sta[0] = 0;
for (int c = 0; c < 26; c++) {
int l = suf[L][c], r = pre[R][c];
if (l > r) continue;
int res = g[r] ^ g[l];
if (L <= l - 1) {
if (F[L][c] == -1) {
int x = Solve(L, l - 1);
F[L][c] = x;
}
res ^= F[L][c];
}
if (r + 1 <= R) res ^= f[R][S[r] - 'a'];
sta[++sta[0]] = res;
}
for (int i = 1; i <= sta[0]; i++) Vis[sta[i]] = 1;
int ps = 0;
while (Vis[ps]) ++ps;
for (int i = 1; i <= sta[0]; i++) Vis[sta[i]] = 0;
sta[0] = 0;
return ps;
}
int main() {
scanf("%s", S + 1);
N = strlen(S + 1);
Q = read();
for (int i = 1; i <= N; i++) {
for (int j = 0; j < 26; j++) pre[i][j] = pre[i - 1][j];
pre[i][S[i] - 'a'] = i;
}
for (int i = 0; i < 26; i++) suf[N + 1][i] = 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][S[i] - 'a'] = i;
}
S[0] = 'a';
memset(f, -1, sizeof(f));
for (int i = 1; i <= N; i++) {
g[i] = g[pre[i - 1][S[i] - 'a']] ^ f[i - 1][S[i] - 'a'];
for (int j = 0; j < 26; j++) {
if (f[i][j] != -1) continue;
f[i][j] = calc(pre[i][j] + 1, i);
}
}
memset(F, -1, sizeof(F));
while (Q--) {
int l = read(), r = read();
if (Solve(l, r))
printf("Alice\n");
else
printf("Bob\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int dpr[100005][27], dpl[100005][27];
int posr[100005][27], posl[100005][27];
int tr[100005];
char s[100005];
void getr() {
int now[27] = {0};
for (int i = 1; i <= n; i++) {
now[s[i] - 'a'] = i;
for (int j = 0; j < 26; j++) posr[i][j] = now[j];
}
bool vis[32];
int ep[32];
for (int i = n; i >= 1; i--) {
int id = s[i] - 'a';
for (int i = 0; i < 26; i++) ep[i] = 0;
for (int j = i + 1; j <= n; j++) {
if (s[i] == s[j]) break;
for (int f = 0; f < 32; f++) vis[f] = 0;
for (int f = 0; f < 26; f++) {
if (posr[j][f] > i && posr[j][f] <= j) {
int k = 0;
k ^= dpr[j][f];
k ^= ep[f];
vis[k] = 1;
}
}
for (int f = 0; f < 26; f++)
if (!vis[f]) {
dpr[j][id] = f;
break;
}
if (j < n) {
int nid = s[j + 1] - 'a';
ep[nid] ^= posr[j][nid] > i ? dpr[j][nid] : dpr[j][id];
}
}
}
}
void getl() {
int now[27];
for (int i = 0; i < 27; i++) now[i] = n + 1;
for (int i = n; i >= 1; i--) {
now[s[i] - 'a'] = i;
for (int j = 0; j < 26; j++) posl[i][j] = now[j];
}
bool vis[32];
int ep[32];
for (int i = 1; i <= n; i++) {
int id = s[i] - 'a';
for (int i = 0; i < 26; i++) ep[i] = 0;
for (int j = i - 1; j >= 1; j--) {
if (s[i] == s[j]) break;
bool flag = 0;
if (j == 5 && i == 6) flag = 1;
for (int f = 0; f < 32; f++) vis[f] = 0;
for (int f = 0; f < 26; f++) {
if (posl[j][f] < i && posl[j][f] >= j) {
int k = 0;
k ^= dpl[j][f];
k ^= ep[f];
vis[k] = 1;
}
}
for (int f = 0; f < 26; f++)
if (!vis[f]) {
dpl[j][id] = f;
break;
}
if (j > 1) {
int nid = s[j - 1] - 'a';
ep[nid] ^= posl[j][nid] < i ? dpl[j][nid] : dpl[j][id];
}
}
}
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
getr();
getl();
for (int i = 1; i <= n; i++) {
int id = s[i] - 'a';
tr[i] = tr[posr[i - 1][id]] ^ dpr[i - 1][id];
}
int m;
for (scanf("%d", &m); m--;) {
int l, r;
scanf("%d %d", &l, &r);
bool flag = 0;
for (int i = 0; i < 26; i++) {
if (posr[r][i] >= l) {
int k = 0;
k ^= tr[posr[r][i]];
k ^= tr[posl[l][i]];
k ^= dpr[r][i];
k ^= dpl[l][i];
if (k == 0) {
flag = 1;
break;
}
}
}
if (flag)
puts("Alice");
else
puts("Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e5 + 5, ALP = 27;
int n, m, pre[MN][ALP], suf[MN][ALP], f[MN][ALP], g[MN][ALP], h[MN][ALP];
pair<int, int> pos[MN];
char str[MN];
inline int calc(int l, int r) {
if (l > r) return 0;
int ret = 0;
for (int i = 0; i < 26; ++i) {
int nl = suf[l][i], nr = pre[r][i];
if (nl >= l && nr <= r && nr >= l)
ret |= 1 << (f[nr][i] ^ f[nl][i] ^ g[l][i] ^ h[r][i]);
}
return __builtin_ctz(~ret);
}
int main() {
scanf("%s", str + 1);
n = strlen(str + 1);
for (int i = 1; i <= n; ++i) {
str[i] -= 'a';
for (int j = 0; j < 26; ++j) pre[i][j] = pre[i - 1][j];
pre[i][str[i]] = i;
}
for (int i = n; i >= 1; --i) {
for (int j = 0; j < 26; ++j) suf[i][j] = suf[i + 1][j];
suf[i][str[i]] = i;
}
for (int i = 1; i <= n; ++i) {
int c = str[i], l = pre[i - 1][c];
for (int j = i - 1; j > l; --j) g[j][c] = calc(j, i - 1);
if (l > 0) f[i][c] = f[l][c] ^ calc(l + 1, i - 1);
int cnt = 0;
for (int j = 0; j < 26; ++j)
if (pre[i][j] && j != c) pos[cnt++] = make_pair(pre[i][j], j);
sort(pos, pos + cnt, greater<pair<int, int> >());
for (int j = 0; j < cnt; ++j)
h[i][pos[j].second] = calc(pre[i][pos[j].second] + 1, i);
}
scanf("%d", &m);
while (m--) {
int l, r;
scanf("%d%d", &l, &r);
if (calc(l, r))
puts("Alice");
else
puts("Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[100010];
int f[100010][26 + 2], pre[100010][26], suf[100010][26], g[100010], n;
int ans[26 + 2];
int dfs(int l, int r, int c, int fl) {
if (l > r) return 0;
if (ans[c] != -1) return ans[c];
int u = 0;
for (int i = 0; i < 26; i++) {
int L = suf[l][i], R = pre[r][i];
if (R < l) continue;
int s = g[L] ^ g[R];
if (!fl)
s ^= f[L - 1][c] ^ dfs(R + 1, r, i, 0);
else
s ^= dfs(l, L - 1, i, 1) ^ f[r][i];
u |= 1 << s;
}
return ans[c] = __builtin_ctz(~u);
}
int main() {
scanf("%s", str + 1);
n = strlen(str + 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) pre[i][j] = pre[i - 1][j];
pre[i][str[i] - 'a'] = i;
}
for (int i = 0; i < 26; i++) suf[n + 1][i] = 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][str[i] - 'a'] = i;
}
for (int i = 1; i <= n; i++) {
int c = str[i] - 'a';
g[i] = f[i - 1][c] ^ g[pre[i - 1][c]];
memset(ans, -1, sizeof(ans));
for (int j = 0; j < 26; j++) f[i][j] = dfs(pre[i][j] + 1, i, j, 0);
}
int m;
scanf("%d", &m);
while (m-- > 0) {
int l, r;
scanf("%d%d", &l, &r);
memset(ans, -1, sizeof(ans));
if (dfs(l, r, 26, 1))
puts("Alice");
else
puts("Bob");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, m, lpos[26][maxn], rpos[26][maxn], c[26][maxn], MaxL[maxn], g[maxn][26],
h[maxn][26];
char s[maxn];
pair<int, int> Q[maxn];
vector<pair<int, int> > q;
map<int, int> f[maxn];
bool vis[26];
inline int lowbit(int first) { return first & -first; }
inline void add(int op, int pos, int val) {
for (int i = pos; i <= n; i += lowbit(i)) c[op][i] ^= val;
}
inline int get(int op, int l, int r) {
int sum = 0;
for (int i = r; i > 0; i -= lowbit(i)) sum ^= c[op][i];
for (int i = l - 1; i > 0; i -= lowbit(i)) sum ^= c[op][i];
return sum;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
scanf("%d", &m);
for (int i = (1), _end_ = (n); i <= _end_; ++i) {
f[i][i] = 0;
q.push_back(pair<int, int>(i, i));
MaxL[i] = i;
}
for (int i = (1), _end_ = (m); i <= _end_; ++i) {
scanf("%d%d", &Q[i].first, &Q[i].second);
MaxL[Q[i].second] = min(MaxL[Q[i].second], Q[i].first);
if (!f[Q[i].first].count(Q[i].second)) {
q.push_back(Q[i]);
f[Q[i].first][Q[i].second] = 0;
}
}
for (int i = (0), _end_ = (25); i <= _end_; ++i) rpos[i][n + 1] = n + 1;
for (int i = n; i >= 1; --i) {
f[i][i - 1] = 0;
for (int j = (0), _end_ = (25); j <= _end_; ++j)
rpos[j][i] = rpos[j][i + 1];
rpos[s[i] - 'a'][i] = i;
for (int j = (0), _end_ = (25); j <= _end_; ++j)
if (rpos[j][i] <= n && !f[i].count(rpos[j][i] - 1)) {
f[i][rpos[j][i] - 1] = 0;
q.push_back(pair<int, int>(i, rpos[j][i] - 1));
}
}
for (int i = (1), _end_ = (n); i <= _end_; ++i) {
for (int j = (0), _end_ = (25); j <= _end_; ++j)
lpos[j][i] = lpos[j][i - 1];
lpos[s[i] - 'a'][i] = i;
for (int j = (0), _end_ = (25); j <= _end_; ++j)
if (lpos[j][i] >= MaxL[i] && lpos[j][i] && !f[lpos[j][i] + 1].count(i)) {
f[lpos[j][i] + 1][i] = 0;
q.push_back(pair<int, int>(lpos[j][i] + 1, i));
}
}
sort(q.begin(), q.end(), [](pair<int, int> a, pair<int, int> b) {
return a.first > b.first ||
(a.first == b.first && a.second - a.first < b.second - b.first);
});
for (auto it : q) {
if (it.first > it.second) continue;
for (int i = (0), _end_ = (25); i <= _end_; ++i) vis[i] = false;
for (int i = (0), _end_ = (25); i <= _end_; ++i) {
int r = rpos[i][it.first], l = lpos[i][it.second];
if (r > it.second) continue;
int first = g[it.first][i];
if (r < l) first ^= get(i, r, l - 1);
first ^= h[it.second][i];
vis[first] = true;
}
for (int i = (0), _end_ = (25); i <= _end_; ++i)
if (!vis[i]) {
f[it.first][it.second] = i;
break;
}
if (it.second < n &&
rpos[s[it.second + 1] - 'a'][it.first] == it.second + 1)
g[it.first][s[it.second + 1] - 'a'] = f[it.first][it.second];
if (it.first > 1 && lpos[s[it.first - 1] - 'a'][it.second] == it.first - 1)
h[it.second][s[it.first - 1] - 'a'] = f[it.first][it.second];
int c = s[it.first - 1] - 'a', pos = rpos[c][it.first];
if (it.first > 1 && s[it.first - 1] == s[it.second + 1] &&
rpos[c][it.first] == it.second + 1)
add(s[it.first - 1] - 'a', it.first - 1, f[it.first][it.second]);
}
for (int i = (1), _end_ = (m); i <= _end_; ++i)
if (f[Q[i].first][Q[i].second] > 0)
puts("Alice");
else
puts("Bob");
return 0;
}
|
#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");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, m, lpos[26][maxn], rpos[26][maxn], c[26][maxn], MaxL[maxn], g[maxn][26],
h[maxn][26];
char s[maxn];
pair<int, int> Q[maxn];
vector<pair<int, int> > q;
map<int, int> f[maxn];
bool vis[26];
inline int lowbit(int first) { return first & -first; }
inline void add(int op, int pos, int val) {
for (int i = pos; i <= n; i += lowbit(i)) c[op][i] ^= val;
}
inline int get(int op, int l, int r) {
int sum = 0;
for (int i = r; i > 0; i -= lowbit(i)) sum ^= c[op][i];
for (int i = l - 1; i > 0; i -= lowbit(i)) sum ^= c[op][i];
return sum;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
scanf("%d", &m);
for (int i = (1), _end_ = (n); i <= _end_; ++i) {
f[i][i] = 0;
q.push_back(pair<int, int>(i, i));
MaxL[i] = i;
}
for (int i = (1), _end_ = (m); i <= _end_; ++i) {
scanf("%d%d", &Q[i].first, &Q[i].second);
MaxL[Q[i].second] = min(MaxL[Q[i].second], Q[i].first);
if (!f[Q[i].first].count(Q[i].second)) {
q.push_back(Q[i]);
f[Q[i].first][Q[i].second] = 0;
}
}
for (int i = (0), _end_ = (25); i <= _end_; ++i) rpos[i][n + 1] = n + 1;
for (int i = n; i >= 1; --i) {
f[i][i - 1] = 0;
for (int j = (0), _end_ = (25); j <= _end_; ++j)
rpos[j][i] = rpos[j][i + 1];
rpos[s[i] - 'a'][i] = i;
for (int j = (0), _end_ = (25); j <= _end_; ++j)
if (rpos[j][i] <= n && !f[i].count(rpos[j][i] - 1)) {
f[i][rpos[j][i] - 1] = 0;
q.push_back(pair<int, int>(i, rpos[j][i] - 1));
}
}
for (int i = (1), _end_ = (n); i <= _end_; ++i) {
for (int j = (0), _end_ = (25); j <= _end_; ++j)
lpos[j][i] = lpos[j][i - 1];
lpos[s[i] - 'a'][i] = i;
for (int j = (0), _end_ = (25); j <= _end_; ++j)
if (lpos[j][i] >= MaxL[i] && lpos[j][i] && !f[lpos[j][i] + 1].count(i)) {
f[lpos[j][i] + 1][i] = 0;
q.push_back(pair<int, int>(lpos[j][i] + 1, i));
}
}
sort(q.begin(), q.end(), [](pair<int, int> a, pair<int, int> b) {
return a.first > b.first ||
(a.first == b.first && a.second - a.first < b.second - b.first);
});
for (auto it : q) {
if (it.first > it.second) continue;
for (int i = (0), _end_ = (25); i <= _end_; ++i) vis[i] = false;
for (int i = (0), _end_ = (25); i <= _end_; ++i) {
int r = rpos[i][it.first], l = lpos[i][it.second];
if (r > it.second) continue;
int first = g[it.first][i];
if (r < l) first ^= get(i, r, l - 1);
first ^= h[it.second][i];
vis[first] = true;
}
for (int i = (0), _end_ = (25); i <= _end_; ++i)
if (!vis[i]) {
f[it.first][it.second] = i;
break;
}
if (it.second < n &&
rpos[s[it.second + 1] - 'a'][it.first] == it.second + 1)
g[it.first][s[it.second + 1] - 'a'] = f[it.first][it.second];
if (it.first > 1 && lpos[s[it.first - 1] - 'a'][it.second] == it.first - 1)
h[it.second][s[it.first - 1] - 'a'] = f[it.first][it.second];
int c = s[it.first - 1] - 'a', pos = rpos[c][it.first];
if (it.first > 1 && s[it.first - 1] == s[it.second + 1] &&
rpos[c][it.first] == it.second + 1)
add(s[it.first - 1] - 'a', it.first - 1, f[it.first][it.second]);
}
for (int i = (1), _end_ = (m); i <= _end_; ++i)
if (f[Q[i].first][Q[i].second] > 0)
puts("Alice");
else
puts("Bob");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
inline int read() {
char ch;
while ((ch = getchar()) < '0' || ch > '9')
;
int res = ch - '0';
while ((ch = getchar()) >= '0' && ch <= '9') res = res * 10 + ch - '0';
return res;
}
int n, Q, mem[27], pre[N][27], suf[N][27];
int f[N][27], g[N];
char s[N];
int mex(int x) { return __builtin_ctz(~x); }
int solve(int l, int r, int c, int op) {
if (l > r) return 0;
if (mem[c] != -1) return mem[c];
int res = 0;
for (int i = 0; i < 26; i++) {
int tl = suf[l][i], tr = pre[r][i];
if (tr >= l)
res |=
1 << (g[tr] ^ g[tl] ^ (op ? solve(l, tl - 1, i, 1) : f[tl - 1][c]) ^
(op ? f[r][i] : solve(tr + 1, r, i, 0)));
}
return mem[c] = mex(res);
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) s[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][s[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][s[i]] = i;
}
for (int i = 1; i <= n; i++) {
memset(mem, -1, sizeof(mem));
g[i] = f[i - 1][s[i]] ^ g[pre[i - 1][s[i]]];
for (int j = 0; j < 26; j++) f[i][j] = solve(pre[i][j] + 1, i, j, 0);
}
Q = read();
while (Q--) {
int l = read(), r = read();
memset(mem, -1, sizeof(mem));
if (solve(l, r, 26, 1))
printf("Alice\n");
else
printf("Bob\n");
}
return 0;
}
|
#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 + 1];
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] ^ 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] ^ sans[r][i];
if (!res) {
flag = true;
break;
}
}
}
puts(flag ? "Alice" : "Bob");
}
return 0;
}
|
#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], nn;
char c[N];
struct B {
int a[N + 999], b[999];
inline void mdy(int x, int v) {
int y = --x >> 8, i;
for (i = x & 255; i < 256; ++i) a[y << 8 | i] ^= v;
for (i = y; i <= nn; ++i) b[i] ^= v;
}
inline int ask(int x) {
int y = --x >> 8;
return a[x] ^ (y ? b[y - 1] : 0);
}
} b[26];
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 : b[i].ask(z) ^ b[i].ask(y))];
for (i = 0; buc[i]; ++i)
;
return i;
}
int main() {
scanf("%s%d", c + 1, &m);
n = strlen(c + 1);
nn = n - 1 >> 8;
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])
b[c[a[i].l] - 'a'].mdy(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;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXLEN = 100000;
const int MAXQ = 100000;
const int ALPH = 26;
const int MAXVAL = 31;
char s[MAXLEN + 1];
int slen;
int nq;
int ql[MAXQ], qr[MAXQ], qans[MAXQ];
int nxt[MAXLEN + 1][ALPH];
int prv[MAXLEN + 1][ALPH];
vector<int> need[MAXLEN];
vector<int> dp[MAXLEN];
int fstval[MAXLEN];
int suffval[MAXLEN + 1];
int nxtval[MAXLEN + 1][ALPH];
int prvval[MAXLEN + 1][ALPH];
int mark[MAXVAL + 1], curmark;
void solve() {
for (int k = (0); k < (ALPH); ++k) {
nxt[slen][k] = slen;
for (int i = slen - 1; i >= 0; --i)
nxt[i][k] = s[i] == 'a' + k ? i : nxt[i + 1][k];
}
for (int k = (0); k < (ALPH); ++k) {
prv[0][k] = -1;
for (int i = (0); i < (slen); ++i)
prv[i + 1][k] = s[i] == 'a' + k ? i : prv[i][k];
}
for (int i = (0); i < (slen); ++i) need[i].clear();
for (int i = (0); i < (nq); ++i) need[ql[i]].push_back(qr[i]);
for (int i = (0); i < (slen); ++i)
for (int k = (0); k < (ALPH); ++k)
if (nxt[i][k] != i) need[i].push_back(nxt[i][k] - 1);
for (int i = (1); i <= (slen); ++i)
for (int k = (0); k < (ALPH); ++k)
if (prv[i][k] != -1) need[prv[i][k] + 1].push_back(i - 1);
for (int i = (0); i < (slen); ++i) {
sort(need[i].begin(), need[i].end());
need[i].erase(unique(need[i].begin(), need[i].end()), need[i].end());
}
for (int i = (0); i < (slen); ++i) fstval[i] = suffval[i] = -1;
suffval[slen] = 0;
for (int i = (0); i <= (slen); ++i)
for (int k = (0); k < (ALPH); ++k) nxtval[i][k] = prvval[i][k] = -1;
memset(mark, -1, sizeof(mark));
curmark = -1;
for (int l = slen - 1; l >= 0; --l) {
fstval[l] =
nxt[l + 1][s[l] - 'a'] == slen ? suffval[l + 1]
: s[l + 1] == s[l]
? fstval[l + 1]
: (nxtval[l + 1][s[l] - 'a'] ^ fstval[nxt[l + 1][s[l] - 'a']]);
dp[l].resize(((int)(need[l]).size()));
for (int i = (0); i < (((int)(need[l]).size())); ++i) {
int r = need[l][i];
++curmark;
for (int k = (0); k < (ALPH); ++k) {
if (nxt[l][k] > r) continue;
int L = nxt[l][k], R = prv[r + 1][k];
assert(l <= L && L <= R && R <= r && s[L] == 'a' + k &&
s[R] == 'a' + k);
int kval = fstval[L] ^ fstval[R];
if (L != l) {
assert(nxtval[l][k] != -1);
kval ^= nxtval[l][k];
}
if (R != r) {
assert(prvval[r + 1][k] != -1);
kval ^= prvval[r + 1][k];
}
mark[kval] = curmark;
}
int curval = 0;
while (mark[curval] == curmark) ++curval;
dp[l][i] = curval;
if (r + 1 < slen && nxt[l][s[r + 1] - 'a'] == r + 1)
nxtval[l][s[r + 1] - 'a'] = curval;
if (l - 1 >= 0 && prv[r + 1][s[l - 1] - 'a'] == l - 1)
prvval[r + 1][s[l - 1] - 'a'] = curval;
if (r + 1 == slen) suffval[l] = curval;
}
}
for (int i = (0); i < (nq); ++i) {
int l = ql[i], r = qr[i];
int idx = lower_bound(need[l].begin(), need[l].end(), r) - need[l].begin();
assert(idx < ((int)(need[l]).size()) && need[l][idx] == r);
qans[i] = dp[l][idx];
}
}
void run() {
scanf("%s", s);
slen = strlen(s);
scanf("%d", &nq);
for (int i = (0); i < (nq); ++i)
scanf("%d%d", &ql[i], &qr[i]), --ql[i], --qr[i];
solve();
for (int i = (0); i < (nq); ++i)
printf("%s\n", qans[i] != 0 ? "Alice" : "Bob");
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int get() {
char ch;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
if (ch == '-') {
int s = 0;
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return -s;
}
int s = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return s;
}
const int N = 1e5 + 5;
int n, m;
char s[N];
struct section {
int l, r, c, id;
section(const int l_ = 0, const int r_ = 0, const int c_ = 0,
const int id_ = 0) {
l = l_;
r = r_;
c = c_;
id = id_;
}
} sec[N * 52], tmp[N * 52];
int k;
int pc[N][26], nc[N][26];
int pv[N][26], nv[N][26], pre[N];
int w[50];
int cnt[N];
bool bz[30];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
w[s[i] - 'a'] = i;
for (int c = 0; c <= 25; c++) pc[i][c] = w[c];
}
for (int i = 0; i <= 25; i++) w[i] = n + 1;
for (int i = n; i >= 1; i--) {
w[s[i] - 'a'] = i;
for (int c = 0; c <= 25; c++) nc[i][c] = w[c];
}
for (int i = 1; i <= n; i++)
for (int c = 0; c <= 25; c++) {
cnt[i - pc[i][c]]++;
cnt[nc[i][c] - i]++;
}
for (int i = 1; i <= n; i++) cnt[i] += cnt[i - 1];
for (int i = 1; i <= n; i++) {
for (int c = 0; c <= 25; c++) {
tmp[cnt[i - pc[i][c]]--] = section(pc[i][c] + 1, i, c, i);
tmp[cnt[nc[i][c] - i]--] = section(i, nc[i][c] - 1, c, -i);
k += 2;
}
}
for (int i = 0; i <= n; i++) cnt[i] = 0;
for (int i = 1; i <= k; i++) cnt[tmp[i].r]++;
for (int i = 1; i <= n; i++) cnt[i] += cnt[i - 1];
for (int i = k; i >= 1; i--) sec[cnt[tmp[i].r]--] = tmp[i];
for (int i = 1; i <= k; i++) {
section u = sec[i];
int l = u.l, r = u.r;
for (int c = 0; c <= 26; c++) bz[c] = 0;
if (l <= r)
for (int c = 0; c <= 25; c++) {
int L = nc[l][c], R = pc[r][c];
if (L && R <= n && L <= R) {
int tmp = pre[R] ^ pre[L] ^ pv[r][c] ^ nv[l][c];
if (tmp <= 26) bz[tmp] = 1;
}
}
int ret = 0;
while (bz[ret]) ret++;
if (u.id > 0) {
pv[r][u.c] = ret;
if (r < n && s[r + 1] - 'a' == u.c) pre[r + 1] = pre[pc[r][u.c]] ^ ret;
} else
nv[l][u.c] = ret;
}
m = get();
for (int cas = 1; cas <= m; cas++) {
int l = get(), r = get();
for (int c = 0; c <= 26; c++) bz[c] = 0;
for (int c = 0; c <= 25; c++) {
int L = nc[l][c], R = pc[r][c];
if (L <= R) {
int tmp = pre[R] ^ pre[L] ^ pv[r][c] ^ nv[l][c];
if (tmp <= 26) bz[tmp] = 1;
}
}
if (bz[0])
printf("Alice\n");
else
printf("Bob\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long qpow(long long x, long long k, long long mod) {
long long ret = 1;
while (k) {
if (k & 1) {
ret = ret * x;
ret = ret % mod;
}
x = x * x;
x = x % mod;
k = (k >> 1);
}
return ret;
}
const int Maxn = 1e5 + 5;
char s[Maxn];
int n;
int pre[Maxn][26], nxt[Maxn][26];
int sum[Maxn], lsum[Maxn][26], rsum[Maxn][26];
bool flag[26];
int grundy(int l, int r) {
if (l > r) return 0;
memset(flag, false, sizeof(flag));
for (int i = 0; i < 26; i++) {
int p1 = nxt[l][i], p2 = pre[r][i];
if (p1 > p2) continue;
int val = (rsum[l][i] ^ sum[p2] ^ sum[p1] ^ lsum[r][i]);
flag[val] = true;
}
for (int i = 0; i < 26; i++)
if (!flag[i]) return i;
return 26;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) s[i] -= 'a';
s[0] = s[n + 1] = -1;
vector<pair<int, int> > seg;
for (int j = 0; j < 26; j++) pre[0][j] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) {
pre[i][j] = (j == s[i]) ? i : pre[i - 1][j];
seg.push_back(pair<int, int>(i, -pre[i][j] - 1));
}
}
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] = (j == s[i]) ? i : nxt[i + 1][j];
seg.push_back(pair<int, int>(nxt[i][j] - 1, -i));
}
}
sort((seg).begin(), (seg).end());
seg.resize(unique((seg).begin(), (seg).end()) - seg.begin());
for (auto v : seg) {
int l = -v.second, r = v.first;
int x = grundy(l, r);
if (s[l - 1] >= 0 && s[r + 1] >= 0 && s[l - 1] == s[r + 1]) {
sum[r + 1] = (sum[l - 1] ^ x);
}
if (s[l - 1] >= 0 && pre[r][s[l - 1]] == l - 1) {
lsum[r][s[l - 1]] = x;
}
if (s[r + 1] >= 0 && nxt[l][s[r + 1]] == r + 1) {
rsum[l][s[r + 1]] = x;
}
}
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d%d", &l, &r);
if (grundy(l, r))
puts("Alice");
else
puts("Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
const int SINF = 0x7fffffff;
const long long LINF = 0x3fffffffffffffff;
const long long SLINF = 0x7fffffffffffffff;
const int MAXN = 100007;
const int BASE = 26;
int n, q;
char s[MAXN];
int cl[MAXN][BASE], cr[MAXN][BASE], prv[BASE];
int dp[2][MAXN][BASE];
int ps[MAXN][BASE], rps[MAXN][BASE];
bool used[BASE + 1];
int ord[BASE];
int ql, qr;
void init();
void input();
void inputq();
void work();
int main() {
init();
input();
work();
}
void init() { ios::sync_with_stdio(false); }
void input() {
scanf("%s", s + 1);
scanf("%d", &q);
}
void inputq() { scanf("%d%d", &ql, &qr); }
void work() {
n = strlen(s + 1);
memset(prv, 0, sizeof(prv));
for (int i = 1; i <= n; ++i) {
prv[s[i] - 'a'] = i;
for (int j = 0; j < BASE; ++j) cl[i][j] = prv[j];
}
for (int i = 0; i < BASE; ++i) prv[i] = n + 1;
for (int i = n; i > 0; --i) {
prv[s[i] - 'a'] = i;
for (int j = 0; j < BASE; ++j) cr[i][j] = prv[j];
}
int cp, cc, pl, pr;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < BASE; ++j) ps[i][j] = ps[i - 1][j];
ps[i][s[i] - 'a'] ^= dp[0][i - 1][s[i] - 'a'];
for (int j = 0; j < BASE; ++j) ord[j] = j;
sort(ord, ord + BASE, [&](int x, int y) { return cl[i][x] > cl[i][y]; });
for (int _j = 0; _j < BASE; ++_j) {
int j = ord[_j];
memset(used, false, sizeof(used));
for (int _k = 0; _k < _j; ++_k) {
int k = ord[_k];
if (cl[i][k] > cl[i][j]) {
cp = cl[i][j];
pl = cr[cp + 1][k];
pr = cl[i][k];
cc = dp[0][i][k] ^ ps[pr][k] ^ ps[pl][k] ^ dp[0][pl - 1][j];
used[cc] = true;
}
}
for (int k = 0; k <= BASE; ++k) {
if (!used[k]) {
dp[0][i][j] = k;
break;
}
}
}
}
for (int i = n; i > 0; --i) {
for (int j = 0; j < BASE; ++j) rps[i][j] = rps[i + 1][j];
rps[i][s[i] - 'a'] ^= dp[1][i + 1][s[i] - 'a'];
for (int j = 0; j < BASE; ++j) ord[j] = j;
sort(ord, ord + BASE, [&](int x, int y) { return cr[i][x] < cr[i][y]; });
for (int _j = 0; _j < BASE; ++_j) {
int j = ord[_j];
dp[1][i][j] = 0;
memset(used, false, sizeof(used));
for (int _k = 0; _k < _j; ++_k) {
int k = ord[_k];
if (cr[i][k] < cr[i][j]) {
cp = cr[i][j];
pr = cl[cp - 1][k];
pl = cr[i][k];
cc = dp[1][i][k] ^ rps[pl][k] ^ rps[pr][k] ^ dp[1][pr + 1][j];
used[cc] = true;
}
}
for (int k = 0; k <= BASE; ++k) {
if (!used[k]) {
dp[1][i][j] = k;
break;
}
}
}
}
bool flag;
for (int _q = 0; _q < q; ++_q) {
inputq();
flag = false;
for (int i = 0; i < BASE; ++i) {
pl = cr[ql][i], pr = cl[qr][i];
if (pr >= ql) {
cc = ps[pr][i] ^ ps[pl][i] ^ dp[0][qr][i] ^ dp[1][ql][i];
if (!cc) {
flag = true;
break;
}
}
}
printf(flag ? "Alice\n" : "Bob\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
const int ALPHA = 26;
int N, Q;
string S;
int cnext[MAXN][ALPHA];
int cprev[MAXN][ALPHA];
int pref[MAXN][ALPHA];
int suff[MAXN][ALPHA];
int pxor[MAXN];
int ssolve(int l, int r) {
if (l > r) return 0;
int mask = 0;
for (int i = 0; i < ALPHA; i++) {
int cfirst = cnext[l][i], clast = cprev[r][i];
if (cfirst > r) continue;
if (pref[l][i] == -1) pref[l][i] = ssolve(l, cfirst - 1);
if (suff[r][i] == -1) suff[r][i] = ssolve(clast + 1, r);
int res = pxor[cfirst] ^ pxor[clast] ^ pref[l][i] ^ suff[r][i];
mask |= (1 << res);
}
int ans = 0;
while (mask & (1 << ans)) ans++;
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> S;
N = S.length();
for (int i = 0; i < N; i++)
for (int j = 0; j < ALPHA; j++) pref[i][j] = suff[i][j] = -1;
for (int i = 0; i < ALPHA; i++) {
cnext[N - 1][i] = N;
cprev[0][i] = -1;
}
for (int i = 0; i < N; i++) {
if (i > 0)
for (int j = 0; j < ALPHA; j++) cprev[i][j] = cprev[i - 1][j];
cprev[i][S[i] - 'a'] = i;
}
for (int i = N - 1; i >= 0; i--) {
if (i < N - 1)
for (int j = 0; j < ALPHA; j++) cnext[i][j] = cnext[i + 1][j];
cnext[i][S[i] - 'a'] = i;
}
for (int i = 1; i < N; i++) {
int ploc = cprev[i - 1][S[i] - 'a'];
if (ploc >= 0) pxor[i] = pxor[ploc] ^ ssolve(ploc + 1, i - 1);
}
cin >> Q;
for (int i = 0; i < Q; i++) {
int l, r;
cin >> l >> r;
l--, r--;
if (ssolve(l, r))
cout << "Alice\n";
else
cout << "Bob\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 5;
int n, q;
int sum[N];
int pre[26][N], suf[26][N];
int pref[26][N], suff[26][N];
bool vis[27];
char s[N];
int solve(int l, int r) {
for (int c = 0; c <= 26; c++) {
vis[c] = false;
}
for (int c = 0; c < 26; c++) {
if (suf[c][l] <= r) {
int x = suf[c][l], y = pre[c][r];
vis[suff[c][l] ^ sum[x] ^ sum[y] ^ pref[c][r]] = true;
}
}
for (int i = 0;; i++) {
if (!vis[i]) {
return i;
}
}
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
for (int c = 0; c < 26; c++) {
pre[c][i] = pre[c][i - 1];
}
pre[s[i] - 'a'][i] = i;
}
for (int c = 0; c < 26; c++) {
suf[c][n + 1] = n + 1;
}
for (int i = n; i >= 1; i--) {
for (int c = 0; c < 26; c++) {
suf[c][i] = suf[c][i + 1];
}
suf[s[i] - 'a'][i] = i;
}
for (int i = 1; i <= n; i++) {
int cc = s[i] - 'a';
if (pre[cc][i - 1]) {
sum[i] = sum[pre[cc][i - 1]] ^ pref[cc][i - 1];
}
for (int j = i - 1; j > pre[cc][i - 1]; j--) {
suff[cc][j] = solve(j, i - 1);
}
vector<pair<int, int>> todo;
for (int c = 0; c < 26; c++) {
if (pre[c][i]) {
todo.push_back(make_pair(pre[c][i], c));
}
}
sort(todo.begin(), todo.end(), greater<pair<int, int>>());
for (auto p : todo) {
int c = p.second;
if (pre[c][i] + 1 <= i) {
pref[c][i] = solve(pre[c][i] + 1, i);
}
}
}
scanf("%d", &q);
while (q--) {
int l, r;
scanf("%d %d", &l, &r);
printf("%s\n", solve(l, r) ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100100], vs[100];
int lstp[100], a[100];
int Q, g[100100], f[100100][30], nxt[100100][30], pre[100100][30], n, dp[50];
int cal(int l, int r, int c, int tg) {
if (l > r) return 0;
if (~dp[c]) return dp[c];
int st = 0;
for (int i = 0; i < 26; ++i) {
int _l = nxt[l][i], _r = pre[r][i];
if (_l < r)
st |= 1 << ((tg ? f[l][i] : cal(l, _l, i, 0)) ^ g[_l] ^ g[_r] ^
(!tg ? f[_r + 1][c] : cal(_r + 1, r, i, 1)));
}
return dp[c] = __builtin_ctz(~st);
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int j = n + 1; j >= 0; --j)
for (int i = 0; i < 26; ++i)
nxt[j][i] = (s[j] == 'a' + i || j > n ? j : nxt[j + 1][i]);
for (int j = 0; j <= n + 1; ++j)
for (int i = 0; i < 26; ++i)
pre[j][i] = (s[j] == 'a' + i || j < 1 ? j : pre[j - 1][i]);
for (int i = n; i >= 1; --i) {
memset(dp, -1, sizeof(dp));
g[i] = f[i + 1][s[i] - 'a'] ^ g[nxt[i + 1][s[i] - 'a']];
for (int j = 0; j < 26; ++j) f[i][j] = cal(i, nxt[i][j], j, 0);
}
scanf("%d", &Q);
for (int i = 1, l, r; i <= Q; ++i) {
scanf("%d%d", &l, &r);
memset(dp, -1, sizeof(dp));
if (cal(l, r + 1, 26, 1))
puts("Alice");
else
puts("Bob");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, pre[N][27], suf[N][27], pf[N][27], sf[N][27];
bool jip[N][27], jis[N][27], ji[N][27];
char c[N];
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f == 1 ? x : -x;
}
inline int solve(int, int, int);
inline int xhz(int l, int r, int dep, int i) {
if (jis[l][i]) return sf[l][i];
sf[l][i] = solve(l, r, dep + 1);
jis[l][i] = 1;
return sf[l][i];
}
inline int xqz(int l, int r, int dep, int i) {
if (jip[r][i]) return pf[r][i];
pf[r][i] = solve(l, r, dep + 1);
jip[r][i] = 1;
return pf[r][i];
}
inline int solve(int l, int r, int dep) {
if (l > r) return 0;
if (l == r) return 1;
memset(ji[dep], 0, sizeof(ji[dep]));
for (int i = 0; i <= 25; i++) {
int zuo = suf[l][i], you = pre[r][i];
if (zuo > you) continue;
int ans = pf[you][i] ^ pf[zuo][i];
if (zuo != l) ans ^= xhz(l, zuo - 1, dep, i);
if (you != r) ans ^= xqz(you + 1, r, dep, i);
ji[dep][ans] = 1;
}
for (int i = 0; i <= 26; i++)
if (ji[dep][i] == 0) return i;
return 26;
}
int main() {
scanf("%s", c + 1);
n = strlen(c + 1);
for (int i = 0; i <= 25; i++) suf[n + 1][i] = n + 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 25; j++) pre[i][j] = pre[i - 1][j];
pre[i][c[i] - 'a'] = i;
}
for (int i = n; i >= 1; i--) {
for (int j = 0; j <= 25; j++) suf[i][j] = suf[i + 1][j];
suf[i][c[i] - 'a'] = i;
}
for (int i = 1; i <= n; i++) {
if (pre[i - 1][c[i] - 'a']) {
int hu = c[i] - 'a';
if (pre[i - 1][hu] + 1 > i - 1)
pf[i][hu] = pf[pre[i - 1][hu]][hu];
else
pf[i][hu] = pf[i - 1][hu] ^ pf[pre[i - 1][hu]][hu];
jip[i][hu] = 1;
}
for (int j = 0; j <= 25; j++) {
if (jip[i][j] || pre[i][j] == 0) continue;
pf[i][j] = solve(pre[i][j] + 1, i, 0);
jip[i][j] = 1;
}
}
for (int i = n; i >= 1; i--) {
if (suf[i + 1][c[i] - 'a'] != n + 1) {
int hu = c[i] - 'a';
if (suf[i + 1][hu] - 1 < i + 1)
sf[i][hu] = sf[suf[i + 1][hu]][hu];
else
sf[i][hu] = sf[i + 1][hu] ^ sf[suf[i + 1][hu]][hu];
jis[i][hu] = 1;
}
for (int j = 0; j <= 25; j++) {
if (jis[i][j] || suf[i][j] == n + 1) continue;
sf[i][j] = solve(i, suf[i][j] - 1, 0);
jis[i][j] = 1;
}
}
int q = read();
for (int i = 1, x, y; i <= q; i++) {
x = read();
y = read();
if (solve(x, y, 0))
cout << "Alice\n";
else
cout << "Bob\n";
}
return (0 - 0);
}
|
#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<int> vp[100011];
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[i].push_back(ed - 1);
}
for (int j = 0; j < 26; j++) {
int st = prv[i][j];
if (st == 0 or st == i) continue;
vp[st + 1].push_back(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[l + 1].push_back(r - 1);
}
}
for (int i = 1; i <= n; i++) {
sort(vp[i].begin(), vp[i].end());
vp[i].erase(unique(vp[i].begin(), vp[i].end()), vp[i].end());
}
for (int i = n; i >= 1; i--) {
for (int j = 0; j < ((int)vp[i].size()); j++) {
int l = i, r = vp[i][j];
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;
const int N = 100005;
char s[N];
int n, a[N], pre[N][26], suf[N][26];
int f[N][26], g[N], mem[27];
inline int mex(int st) { return __builtin_ctz(~st); }
int calc(int l, int r, int c, int fl) {
if (l > r) return 0;
if (~mem[c]) return mem[c];
int st = 0;
for (int j = 0; j < 26; j++) {
int ll = suf[l][j], rr = pre[r][j];
if (rr >= l)
st |= 1 << (g[rr] ^ g[ll] ^ (!fl ? f[ll - 1][c] : calc(l, ll - 1, j, 1)) ^
(fl ? f[r][j] : calc(rr + 1, r, j, 0)));
}
return mem[c] = mex(st);
}
int main() {
ios::sync_with_stdio(false);
cin >> (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 < 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 > 0; --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;
while (q--) {
int l, r;
cin >> l >> r;
memset(mem, -1, sizeof(mem));
if (calc(l, r, 26, 1))
puts("Alice");
else
puts("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 = 100005;
int n, m, lst[26], pre[N][26], nxt[N][26], sgl[N][26], sgr[N][26], sum[N];
char s[N];
int sol(int l, int r) {
int num = 0;
for (int i = (0); i <= (25); ++i) {
if (nxt[l - 1][i] <= r) {
num |= 1 << (sgr[l][i] ^ sgl[r][i] ^ sum[pre[r + 1][i]] ^
sum[nxt[l - 1][i]]);
}
}
for (int i = (0); i <= (26); ++i)
if (~num >> i & 1) return i;
assert(0);
return 0;
}
int main() {
scanf("%s%d", s + 1, &m), n = strlen(s + 1);
for (int i = (1); i <= (n); ++i)
memcpy(pre[i], lst, sizeof(lst)), lst[s[i] - 'a'] = i;
memcpy(pre[n + 1], lst, sizeof(lst));
fill(lst, lst + 26, n + 1);
for (int i = (n); i >= (1); --i)
memcpy(nxt[i], lst, sizeof(lst)), lst[s[i] - 'a'] = i;
memcpy(nxt[0], lst, sizeof(lst));
for (int i = (1); i <= (n); ++i) {
sum[i] = sum[pre[i][s[i] - 'a']] ^ sgl[i - 1][s[i] - 'a'];
vector<pair<int, int> > ned;
for (int j = (0); j <= (25); ++j)
if (s[i] - 'a' != j && pre[i][j]) ned.emplace_back(pre[i][j] + 1, 0);
if (i != n)
for (int j = (pre[i + 1][s[i + 1] - 'a'] + 1); j <= (i); ++j)
ned.emplace_back(j, 1);
sort(ned.rbegin(), ned.rend());
for (auto x : ned) {
int cur = sol(x.first, i);
if (x.second == 1)
sgr[x.first][s[i + 1] - 'a'] = cur;
else if (x.first - 1)
sgl[i][s[x.first - 1] - 'a'] = cur;
}
}
for (int i = (1); i <= (m); ++i) {
int l, r;
scanf("%d%d", &l, &r);
printf("%s\n", sol(l, r) ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
const int M = 32;
int n, q, res;
char st[N];
int pre[N][M], nxt[N][M], prf[N][M], nxf[N][M];
int num[M], val[N], o[M];
int main() {
scanf("%s", st + 1);
n = strlen(st + 1);
for (int j = 0; j < 26; ++j) pre[1][j] = 0;
for (int i = 2; i <= n + 1; ++i) {
for (int j = 0; j < 26; ++j) pre[i][j] = pre[i - 1][j];
pre[i][st[i - 1] - 'a'] = i - 1;
}
for (int j = 0; j < 26; ++j) nxt[n][j] = n + 1;
for (int i = n - 1; ~i; --i) {
for (int j = 0; j < 26; ++j) nxt[i][j] = nxt[i + 1][j];
nxt[i][st[i + 1] - 'a'] = i + 1;
}
for (int i = 2; i <= n + 1; ++i) {
for (int j = 0; j < 26; ++j) o[j] = j;
sort(o, o + 26, [=](int a, int b) { return pre[i][a] > pre[i][b]; });
for (int j = 0; j < 26; ++j) {
for (int k = 0; k < 32; ++k) num[k] = 0;
for (int k = 0; k < j; ++k)
if (pre[i][o[k]])
num[prf[i][o[k]] ^ val[pre[i][o[k]]] ^ val[nxt[pre[i][o[j]]][o[k]]] ^
prf[nxt[pre[i][o[j]]][o[k]]][o[j]]] = 1;
int p = 0;
while (num[p]) p++;
prf[i][o[j]] = p;
}
val[i] = val[pre[i][st[i] - 'a']] ^ prf[i][st[i] - 'a'];
}
for (int i = n - 1; ~i; --i) {
for (int j = 0; j < 26; ++j) o[j] = j;
sort(o, o + 26, [=](int a, int b) { return nxt[i][a] < nxt[i][b]; });
for (int j = 0; j < 26; ++j) {
for (int k = 0; k < 32; ++k) num[k] = 0;
for (int k = 0; k < j; ++k)
if (nxt[i][o[k]] != n + 1)
num[prf[nxt[i][o[j]]][o[k]] ^ val[pre[nxt[i][o[j]]][o[k]]] ^
val[nxt[i][o[k]]] ^ nxf[i][o[k]]] = 1;
int p = 0;
while (num[p]) p++;
nxf[i][o[j]] = p;
}
}
scanf("%d", &q);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
for (int j = 0; j < 32; ++j) num[j] = 0;
for (int j = 0; j < 26; ++j)
if (l <= pre[r + 1][j])
num[prf[r + 1][j] ^ val[pre[r + 1][j]] ^ val[nxt[l - 1][j]] ^
nxf[l - 1][j]] = 1;
int p = 0;
while (num[p]) p++;
if (p)
puts("Alice");
else
puts("Bob");
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
template <class T, int size>
struct fenwick {
T a[size];
void set(int pos, const T& val) {
while (pos < size) {
a[pos] ^= val;
pos += pos & -pos;
}
}
T sum(int pos) {
T ret = T();
while (pos > 0) {
ret ^= a[pos];
pos -= pos & -pos;
}
return ret;
}
int get(int l, int r) { return sum(r) ^ sum(l - 1); }
};
fenwick<uint8_t, 100005> drvo[27];
int n;
string s;
int levi_pos[100005][27], desni_pos[100005][27];
int pos[27][100005], sz[27];
int t[27];
int mex(int mask) { return __builtin_ctz(~mask); }
struct hash_node {
unsigned long long hash;
int val;
};
struct my_hash_table {
hash_node a[16777216 / 2 + 10000];
void set(unsigned long long hash, int val) {
int pos = hash & 0x7fffff;
while (a[pos].hash) pos++;
a[pos].hash = hash;
a[pos].val = val;
}
int get(unsigned long long hash) {
int pos = hash & 0x7fffff;
while (a[pos].hash && a[pos].hash != hash) pos++;
if (a[pos].hash == 0) return -1;
return a[pos].val;
}
} ans_cache;
set<int> unsolved[27];
int resi(int l, int r) {
unsigned long long hash = (l * 44312566316561ull + r * 23982987381143481ull);
{
auto it = ans_cache.get(hash);
if (it != -1) return it;
}
int mex_mask = 0;
for (int x = 0; x < 26; x++) {
int xl = desni_pos[l][x];
int xr = levi_pos[r][x];
if (xl > xr) continue;
int unutra_val = 0;
while (xl < xr) {
auto it = unsolved[x].lower_bound(xl + 1);
if (it != unsolved[x].end() && *it <= xr) {
int ql = *it;
int qr = desni_pos[ql][x] - 1;
int ans;
if (ql <= qr) {
ans = resi(ql, qr);
} else {
ans = 0;
}
drvo[x].set(ql, ans);
unsolved[x].erase(it);
} else {
unutra_val ^= drvo[x].get(xl + 1, xr);
break;
}
}
if (xl > l) unutra_val ^= resi(l, xl - 1);
if (xr < r) unutra_val ^= resi(xr + 1, r);
mex_mask |= 1 << (int)unutra_val;
}
int mmm = mex(mex_mask);
ans_cache.set(hash, mmm);
return mmm;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> s;
n = s.size();
s = string("{") + s + string("{");
fill(t, t + 27, -123123123);
for (int i = 0; i <= n + 1; i++) {
t[s[i] - 'a'] = i;
copy(t, t + 27, levi_pos[i]);
}
fill(t, t + 27, 123123123);
for (int i = n + 1; i >= 0; i--) {
t[s[i] - 'a'] = i;
copy(t, t + 27, desni_pos[i]);
}
for (int i = 1; i <= n; i++) {
int x = s[i] - 'a';
pos[x][sz[x]++] = i;
}
for (int x = 0; x < 26; x++) {
for (int i = 0; i < sz[x] - 1; i++) {
int xl = pos[x][i] + 1;
unsolved[x].insert(xl);
}
}
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
cout << (resi(l, r) ? "Alice\n" : "Bob\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long Inf = 1e18;
const int N = 1e5 + 10;
const int mod = 0;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
template <typename T>
bool chkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
};
template <typename T>
bool chkmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
};
int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
int sub(int a, int b) { return a - b < 0 ? a - b + mod : a - b; }
void inc(int &a, int b) { a = (a + b >= mod ? a + b - mod : a + b); }
void dec(int &a, int b) { a = (a - b < 0 ? a - b + mod : a - b); }
int n, m, pre[N][26], nxt[N][26], sum[N], psum[N][26], ssum[N][26];
char s[N];
pair<int, int> st[N];
int top = 0;
bool vis[30];
int sg(int l, int r) {
if (l > r) return 0;
memset(vis, 0, sizeof(vis));
for (int i = 0; i < 26; i++)
if (nxt[l][i] <= r) {
int x = nxt[l][i], y = pre[r][i];
vis[ssum[l][i] ^ psum[r][i] ^ sum[y] ^ sum[x]] = 1;
}
for (int i = 0;; i++)
if (!vis[i]) return i;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
cin >> m;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 26; j++) pre[i][j] = pre[i - 1][j];
pre[i][s[i] - 'a'] = i;
}
for (int i = 0; i < 26; i++) nxt[n + 1][i] = n + 1;
for (int i = n; i; i--) {
for (int j = 0; j < 26; j++) nxt[i][j] = nxt[i + 1][j];
nxt[i][s[i] - 'a'] = i;
}
for (int i = 1; i <= n; i++) {
if (pre[i - 1][s[i] - 'a'])
sum[i] = sum[pre[i - 1][s[i] - 'a']] ^ psum[i - 1][s[i] - 'a'];
for (int j = i - 1; j > pre[i - 1][s[i] - 'a']; j--)
ssum[j][s[i] - 'a'] = sg(j, i - 1);
top = 0;
for (int j = 0; j < 26; j++) st[++top] = make_pair(pre[i][j], j);
sort(st + 1, st + top + 1, greater<pair<int, int> >());
for (int j = 1; j <= top; j++)
psum[i][st[j].second] = sg(st[j].first + 1, i);
}
for (int i = 1, l, r; i <= m; i++) {
l = gi(), r = gi();
puts(sg(l, r) ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, sum[N], pre[N][26], suf[N][26], pref[N][26], suff[N][26];
bool visit[40];
char s[N];
int solve(int l, int r) {
if (l > r) {
return 0;
}
for (int i = 0; i <= 26; ++i) {
visit[i] = false;
}
for (int i = 0; i < 26; ++i) {
if (suf[l][i] <= r) {
int x = suf[l][i], y = pre[r][i];
visit[suff[l][i] ^ pref[r][i] ^ sum[y] ^ sum[x]] = true;
}
}
for (int i = 0;; ++i) {
if (!visit[i]) {
return i;
}
}
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 26; ++j) {
pre[i][j] = pre[i - 1][j];
}
pre[i][s[i] - 'a'] = i;
}
for (int i = 0; i < 26; ++i) {
suf[n + 1][i] = n + 1;
}
for (int i = n; i; --i) {
for (int j = 0; j < 26; ++j) {
suf[i][j] = suf[i + 1][j];
}
suf[i][s[i] - 'a'] = i;
}
for (int i = 1; i <= n; ++i) {
if (pre[i - 1][s[i] - 'a']) {
sum[i] = sum[pre[i - 1][s[i] - 'a']] ^ pref[i - 1][s[i] - 'a'];
}
for (int j = i; j > pre[i - 1][s[i] - 'a']; --j) {
suff[j][s[i] - 'a'] = solve(j, i - 1);
}
vector<pair<int, int>> all;
for (int j = 0; j < 26; ++j) {
if (pre[i][j]) {
all.emplace_back(pre[i][j], j);
}
}
sort(all.begin(), all.end());
reverse(all.begin(), all.end());
for (int j = 0; j < all.size(); ++j) {
int c = all[j].second;
pref[i][c] = solve(pre[i][c] + 1, i);
}
}
scanf("%d", &m);
while (m--) {
int l, r;
scanf("%d %d", &l, &r);
puts(solve(l, r) ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = int(1e5) + 100;
char st[maxn];
int pv[maxn][30], nx[maxn][30];
int prefix[maxn][30], suffix[maxn][30];
int SG[maxn][30];
int idx[30], now[30], tmp[30];
bool flag[30];
bool cmp1(int x, int y) { return now[x] < now[y]; }
bool cmp2(int x, int y) { return now[x] > now[y]; }
int mex(int *a, int n) {
for (int i = 0; i <= 26; ++i) flag[i] = false;
for (int i = 0; i < n; ++i) flag[a[i]] = true;
for (int i = 0; i <= 26; ++i)
if (!flag[i]) return i;
}
void solve() {
int len = strlen(st + 1);
for (int i = 0; i < 26; ++i) pv[0][i] = 0;
for (int i = 1; i <= len; ++i) {
for (int j = 0; j < 26; ++j) pv[i][j] = pv[i - 1][j];
pv[i][st[i] - 'a'] = i;
}
for (int i = 0; i < 26; ++i) nx[len + 1][i] = len + 1;
for (int i = len; i; --i) {
for (int j = 0; j < 26; ++j) nx[i][j] = nx[i + 1][j];
nx[i][st[i] - 'a'] = i;
}
for (int i = 0; i < 26; ++i) nx[0][i] = nx[1][i], pv[len + 1][i] = pv[len][i];
for (int i = len; i; --i) {
for (int j = 0; j < 26; ++j) idx[j] = j, now[j] = nx[i][j];
sort(idx, idx + 26, cmp1);
for (int j = 0; j < 26; ++j) {
int cur = idx[j];
int bound = now[cur];
int cnt = 0;
for (int k = 0; k < j; ++k)
if (nx[i][idx[k]] < bound) {
int last = pv[bound][idx[k]] + 1;
tmp[cnt++] = suffix[i][idx[k]] ^ suffix[last][idx[k]] ^ SG[last][cur];
}
SG[i][cur] = mex(tmp, cnt);
suffix[i][cur] = SG[i][cur] ^ suffix[bound + 1][cur];
}
}
for (int i = 1; i <= len; ++i) {
for (int j = 0; j < 26; ++j) idx[j] = j, now[j] = pv[i][j];
sort(idx, idx + 26, cmp2);
for (int j = 0; j < 26; ++j) {
int cur = idx[j];
int bound = now[cur];
int cnt = 0;
for (int k = 0; k < j; ++k)
if (pv[i][idx[k]] > bound) {
int last = nx[bound][idx[k]] - 1;
tmp[cnt++] = prefix[i][idx[k]] ^ prefix[last][idx[k]] ^ SG[last][cur];
}
SG[i][cur] = mex(tmp, cnt);
prefix[i][cur] =
SG[i][cur] ^ (bound - 1 < 0 ? 0 : prefix[bound - 1][cur]);
}
}
int casesum;
scanf("%d", &casesum);
while (casesum--) {
int L, R;
scanf("%d%d", &L, &R);
int cnt = 0;
for (int i = 0; i < 26; ++i)
if (nx[L][i] <= R)
tmp[cnt++] = suffix[L][i] ^ suffix[pv[R][i] + 1][i] ^ SG[R][i];
if (mex(tmp, cnt))
puts("Alice");
else
puts("Bob");
}
}
int main() {
scanf("%s", st + 1);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
const int A = 32;
int sum[N], prefix[N][A], suffix[N][A];
int prv[N][A], nxt[N][A];
int solve(int, int);
int get_suffix(int i, int c) {
if (suffix[i][c] == -1) {
suffix[i][c] = solve(prv[i][c] + 1, i);
}
return suffix[i][c];
}
int get_prefix(int i, int c) {
if (prefix[i][c] == -1) {
prefix[i][c] = solve(i, nxt[i][c] - 1);
}
return prefix[i][c];
}
int solve(int l, int r) {
if (l > r) {
return 0;
}
unsigned int mask = 0;
for (int i = 0; i < A; ++i) {
if (nxt[l][i] <= r) {
int grundy = sum[nxt[l][i]] ^ sum[prv[r][i]];
grundy ^= get_prefix(l, i) ^ get_suffix(r, i);
mask |= 1u << grundy;
}
}
int mex = 0;
while (mask % 2 == 1) {
mask /= 2;
++mex;
}
return mex;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
int n = s.size();
for (int i = 0; i < n; ++i) {
for (int j = 0; j < A; ++j) {
prv[i][j] = (i == 0) ? -1 : prv[i - 1][j];
prefix[i][j] = -1;
}
prv[i][s[i] - 'a'] = i;
}
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < A; ++j) {
nxt[i][j] = (i == n - 1) ? n : nxt[i + 1][j];
suffix[i][j] = -1;
}
nxt[i][s[i] - 'a'] = i;
}
for (int i = 1; i < n; ++i) {
int j = prv[i - 1][s[i] - 'a'];
if (j >= 0) {
sum[i] = sum[j] ^ solve(j + 1, i - 1);
}
}
int m;
cin >> m;
while (m--) {
int l, r;
cin >> l >> r;
cout << (solve(l - 1, r - 1) > 0 ? "Alice" : "Bob") << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100001];
vector<pair<int, int> > key;
bool comp(pair<int, int> a, pair<int, int> b) {
if (a.second == b.second)
return a.first > b.first;
else
return a.second < b.second;
}
int ll[100000][26], rr[100000][26], pp[26];
int pre[26][100000];
int dp[100000][26], dp2[100000][26];
int findAns(int l, int r, int ls, int rs) {
if (l > r) return 0;
if (ls && (dp[r][s[l - 1] - 'a'] != -1)) return dp[r][s[l - 1] - 'a'];
if (rs && (dp2[l][s[r + 1] - 'a'] != -1)) return dp2[l][s[r + 1] - 'a'];
int i;
unsigned int seen = 0;
for (i = 0; i < 26; i++) {
if (((i == s[l] - 'a') ? l : rr[l][i]) <= r) {
int rrr = (i == s[l] - 'a') ? l : rr[l][i];
int lll = (i == s[r] - 'a') ? r : ll[r][i];
int x = findAns(l, rrr - 1, ls, 1) ^ findAns(lll + 1, r, 1, rs);
if (lll != rrr) x ^= pre[i][lll] ^ pre[i][rr[rrr][i] - 1];
seen |= (1U << x);
}
}
int ans = 0;
while (seen & (1U << ans)) ans++;
if (ls) dp[r][s[l - 1] - 'a'] = ans;
if (rs) dp2[l][s[r + 1] - 'a'] = ans;
return ans;
}
int main() {
int i;
int m, l, r;
scanf("%s %d", s, &m);
int j, n = strlen(s);
fill(pp, pp + 26, -1);
for (i = 0; i < n; i++) {
for (j = 0; j < 26; j++) ll[i][j] = pp[j];
pp[s[i] - 'a'] = i;
}
fill(pp, pp + 26, n);
for (i = n - 1; i >= 0; i--) {
for (j = 0; j < 26; j++) rr[i][j] = pp[j];
pp[s[i] - 'a'] = i;
}
for (i = 0; i < n; i++) {
if ((rr[i][s[i] - 'a'] > i + 1) && (rr[i][s[i] - 'a'] < n))
key.push_back(make_pair(i + 1, rr[i][s[i] - 'a'] - 1));
}
sort(key.begin(), key.end(), comp);
int x = 0;
memset(dp, -1, sizeof(dp));
memset(dp2, -1, sizeof(dp2));
for (i = 0; i < key.size(); i++) {
while (x < key[i].second + 1) {
for (j = 0; j < 26; j++) pre[j][x + 1] = pre[j][x];
x++;
}
pre[s[key[i].second + 1] - 'a'][key[i].second + 1] ^=
findAns(key[i].first, key[i].second, 1, 1);
}
while (x < n - 1) {
for (j = 0; j < 26; j++) pre[j][x + 1] = pre[j][x];
x++;
}
for (i = 0; i < m; i++) {
scanf("%d %d", &l, &r);
l--, r--;
printf((findAns(l, r, 0, 0) > 0) ? "Alice\n" : "Bob\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e5 + 10;
int fw[Max][26];
int bw[Max][26];
int gs[Max][26];
int ge[Max][26];
int n;
int A[Max];
int mex(vector<int> vec);
void CalcGS(int i, int c);
void CalcGE(int i, int c);
int mex(vector<int> vec) {
sort(vec.begin(), vec.end());
if (vec[0] > 0) return 0;
for (int i = 1; i < vec.size(); i++)
if (vec[i] > vec[i - 1] + 1) return vec[i - 1] + 1;
return vec.back() + 1;
}
int G(int l, int r) {
if (l >= r) return 0;
if ((r - l) == 1 || (r - l) == 2 && A[l + 1] == A[r + 1]) return 1;
l++, r--;
for (int ch = 0; ch < 26; ch++) {
if (A[l] == ch && A[r] == ch) {
CalcGS(l + 1, ch);
CalcGS(r + 1, ch);
} else if (A[r] == ch) {
CalcGS(l, ch);
CalcGS(r + 1, ch);
} else if (A[l] == ch) {
int lCh = bw[r][ch];
CalcGS(l + 1, ch);
CalcGS(lCh + 1, ch);
CalcGE(r, ch);
} else {
int lCh = bw[r][ch];
if (lCh < l) continue;
CalcGS(l, ch);
CalcGS(lCh + 1, ch);
CalcGE(r, ch);
}
}
vector<int> vec;
for (int ch = 0; ch < 26; ch++) {
int g = 0;
if (A[l] == ch && A[r] == ch) {
g = gs[l + 1][ch] ^ gs[r + 1][ch];
} else if (A[r] == ch) {
g = gs[l][ch] ^ gs[r + 1][ch];
} else if (A[l] == ch) {
int lCh = bw[r][ch];
g = gs[l + 1][ch] ^ gs[lCh + 1][ch] ^ ge[r][ch];
} else {
int lCh = bw[r][ch];
if (lCh < l) continue;
g = gs[l][ch] ^ gs[lCh + 1][ch] ^ ge[r][ch];
}
vec.push_back(g);
}
return mex(vec);
}
void CalcGE(int i, int c) {
if (ge[i][c] >= 0) return;
if (A[i] == c) {
ge[i][c] = 0;
return;
}
int l = bw[i][c], r = i + 1;
ge[i][c] = G(l, r);
}
void CalcGS(int i, int c) {
if (gs[i][c] >= 0) return;
CalcGS(fw[i - 1][c] + 1, c);
if (A[i] == c) {
gs[i][c] = 0 ^ gs[fw[i - 1][c] + 1][c];
return;
}
int g = G(i - 1, fw[i - 1][c]) ^ gs[fw[i - 1][c] + 1][c];
gs[i][c] = g;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
{
string s;
cin >> s;
n = s.size();
for (int i = 0; i <= n; i++)
for (int ch = 0; ch < 26; ch++) gs[i][ch] = ge[i][ch] = -1;
for (int ch = 0; ch < 26; ch++) gs[0][ch] = gs[n + 1][ch] = 0;
for (int i = 0; i < n; i++) A[i + 1] = s[i] - 'a';
for (int ch = 0; ch < 26; ch++) {
int lastChSeen = n + 1;
for (int i = n; i--;) {
fw[i + 1][ch] = lastChSeen;
if (A[i + 1] == ch) lastChSeen = i + 1;
}
fw[0][ch] = lastChSeen;
lastChSeen = 0;
bw[0][ch] = lastChSeen;
for (int i = 0; i < n; i++) {
bw[i + 1][ch] = lastChSeen;
if (A[i + 1] == ch) lastChSeen = i + 1;
}
}
}
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
if (l == r) {
cout << "Alice\n";
continue;
}
int g = G(l - 1, r + 1);
if (g == 0)
cout << "Bob\n";
else
cout << "Alice\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
char s[111111];
int m, l, r, n, pos[111111], nxt[111111][28], pre[111111][28], pr[111111][28],
nx[111111][28], cur[28], a[111111];
int prefix[111111];
int solve(int l, int r);
int getsuf(int pos, int k) {
if (~nx[pos][k]) return nx[pos][k];
return nx[pos][k] = solve(pos, nxt[pos][k] - 1);
}
int getpre(int pos, int k) {
if (~pr[pos][k]) return pr[pos][k];
return pr[pos][k] = solve(pre[pos][k] + 1, pos);
}
int solve(int l, int r) {
if (l > r) return 0;
if (l == r) return 1;
bool used[55];
memset(used, 0, sizeof(used));
int ans, res;
for (int i = 0; i < 26; i++) {
int s = nxt[l][i], e = pre[r][i];
if (s > e || !s || !e) continue;
ans = prefix[e] ^ prefix[pre[s][i]];
if (s != l) ans ^= getsuf(l, i);
if (e != r) ans ^= getpre(r, i);
used[ans] = 1;
}
res = 0;
while (used[res]) res++;
return res;
}
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 1; i <= n; i++) {
a[i] = s[i - 1] - 'a';
}
memset(nx, -1, sizeof(nx));
memset(pr, -1, sizeof(pr));
for (int i = n; i >= 1; i--) {
cur[a[i]] = i;
for (int j = 0; j < 26; j++) nxt[i][j] = cur[j];
}
memset(cur, 0, sizeof(cur));
for (int i = 1; i <= n; i++) {
cur[a[i]] = i;
for (int j = 0; j < 26; j++) pre[i][j] = cur[j];
}
for (int i = 1; i <= n; i++) {
if (!pre[i][a[i]]) continue;
prefix[i] = prefix[pre[i - 1][a[i]]] ^ solve(pre[i - 1][a[i]] + 1, i - 1);
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &l, &r);
if (!solve(l, r))
printf("Bob\n");
else
printf("Alice\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 101000;
const int MAXM = 101000;
int N, M;
char sraw[MAXN];
int s[MAXN];
int L[MAXN][26], R[MAXN][26];
int pfx[MAXN][26], sfx[MAXN][26];
int psm[MAXN];
void initLR() {
for (int i = 0; i < 26; i++) L[1][i] = 0;
for (int i = 2; i <= N; i++) {
for (int c = 0; c < 26; c++) L[i][c] = L[i - 1][c];
L[i][s[i - 1]] = i - 1;
}
for (int i = 0; i < 26; i++) R[N - 1][i] = N;
for (int i = N - 2; i >= 0; i--) {
for (int c = 0; c < 26; c++) R[i][c] = R[i + 1][c];
R[i][s[i + 1]] = i + 1;
}
}
void initPFX() {
psm[0] = 0;
bool u[32];
int o[26], t;
for (int i = 1; i <= N; i++) {
for (int j = 0; j < 26; j++) o[j] = j;
sort(o, o + 26,
[&](const int& a, const int& b) { return L[i][a] > L[i][b]; });
for (int c = 0; c < 26; c++) {
for (int j = 0; j < 27; j++) u[j] = false;
for (int d = 0; d < c; d++) {
assert(L[i][o[d]] >= L[i][o[c]]);
if (L[i][o[d]] == 0) continue;
if ((t = pfx[R[L[i][o[c]]][o[d]]][o[c]] xor
(psm[L[i][o[d]]] xor psm[R[L[i][o[c]]][o[d]]]) xor
pfx[i][o[d]]) < 27)
u[t] = true;
}
int a = 0;
while (u[a]) a++;
pfx[i][o[c]] = a;
}
psm[i] = psm[L[i][s[i]]] xor pfx[i][s[i]];
}
}
void initSFX() {
bool u[32];
int o[26], t;
for (int i = N - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) o[j] = j;
sort(o, o + 26,
[&](const int& a, const int& b) { return R[i][a] < R[i][b]; });
for (int c = 0; c < 26; c++) {
for (int j = 0; j < 27; j++) u[j] = false;
for (int d = 0; d < c; d++) {
assert(R[i][o[d]] <= R[i][o[c]]);
if (R[i][o[d]] == N) continue;
if ((t = sfx[i][o[d]] xor
(psm[L[R[i][o[c]]][o[d]]] xor psm[R[i][o[d]]]) xor
sfx[L[R[i][o[c]]][o[d]]][o[c]]) < 27)
u[t] = true;
}
int a = 0;
while (u[a]) a++;
sfx[i][o[c]] = a;
}
}
}
int main() {
scanf("%s", sraw);
s[0] = -1;
for (N = 1; sraw[N - 1] != '\0'; N++) {
assert(N < MAXN);
s[N] = static_cast<int>(sraw[N - 1]) - 97;
}
s[N] = -1;
initLR();
initPFX();
initSFX();
scanf("%d", &M);
int t;
for (int i = 0; i < M; i++) {
int a, b;
scanf("%d%d", &a, &b);
b++;
assert(a < b);
bool u = ((psm[L[b][s[a]]] xor psm[a]) xor pfx[b][s[a]]) == 0;
for (int c = 0; c < 26; c++) {
if (s[a] == c) continue;
if (R[a][c] > L[b][c]) continue;
assert(R[a][c] != R[b][c]);
t = sfx[a - 1][c] xor (psm[R[a - 1][c]] xor psm[L[b][c]]) xor pfx[b][c];
if (!t) u = true;
}
if (u)
printf("Alice\n");
else
printf("Bob\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "inline", "unroll-loops", "no-stack-protector")
using namespace std;
const int maxn = 100000;
map<int, int> sg[maxn + 10];
vector<pair<int, int> > sgg[maxn + 10];
char s[maxn + 10];
int b[maxn + 10], q, n;
int pre[maxn + 10][26], nxt[maxn + 10][26], xo[maxn + 10], cnt;
int f[2][maxn + 10], nowl, nowr;
void read(int &x) {
x = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
}
int mex(int *a) {
for (int i = 0; i < 26; ++i) b[a[i]] = 1;
int ans = 0;
while (b[ans]) ++ans;
for (int i = 0; i < 26; ++i) b[a[i]] = 0;
return ans;
}
int getsg(int l, int r) {
if (l > r) return 0;
map<int, int>::iterator it = sg[l].find(r);
if (it != sg[l].end()) return it->second;
int lst[26], val[26], ans;
for (int i = 0; i < 26; ++i) {
lst[i] = l - 1;
val[i] = 0;
}
for (int i = l; i <= r; ++i) {
int c = s[i] - 'a';
val[c] ^= getsg(lst[c] + 1, i - 1);
lst[c] = i;
}
for (int i = 0; i < 26; ++i) {
if (lst[i] >= l)
val[i] ^= getsg(lst[i] + 1, r);
else
val[i] = 27;
}
sg[l].insert(make_pair(r, ans = mex(val)));
return ans;
}
int gettruesg(int l, int r) {
if (l > r) return 0;
if (l != nowl && r != nowr)
return lower_bound(sgg[l].begin(), sgg[l].end(), make_pair(r, 0))->second;
int &ans = l == nowl ? f[0][r] : f[1][l];
if (ans != -1) return ans;
int val[26];
for (int i = 0; i < 26; ++i)
if (pre[r][i] >= l)
val[i] = gettruesg(l, nxt[l][i] - 1) ^ gettruesg(pre[r][i] + 1, r) ^
xo[nxt[l][i]] ^ xo[pre[r][i]];
else
val[i] = 27;
return ans = mex(val);
}
int main() {
scanf("%s", s + 1);
read(q);
n = strlen(s + 1);
getsg(1, n);
for (int i = 1; i <= n; ++i)
for (auto j : sg[i]) sgg[i].push_back(j);
for (int i = 1; i <= n; ++i)
for (int j = 0; j < 26; ++j)
pre[i][j] = s[i] == j + 'a' ? i : pre[i - 1][j];
for (int i = n; i >= 1; --i)
for (int j = 0; j < 26; ++j)
nxt[i][j] = s[i] == j + 'a' ? i : nxt[i + 1][j];
for (int i = 1; i <= n; ++i)
xo[i] =
xo[pre[i - 1][s[i] - 'a']] ^ getsg(pre[i - 1][s[i] - 'a'] + 1, i - 1);
while (q--) {
read(nowl);
read(nowr);
for (int i = 0; i < 26; ++i) {
if (nxt[nowl][i]) f[0][nxt[nowl][i] - 1] = -1;
if (pre[nowr][i]) f[1][pre[nowr][i] + 1] = -1;
}
f[0][nowr] = -1;
puts(gettruesg(nowl, nowr) ? "Alice" : "Bob");
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int MAXSIZE = 10000020;
int bufpos;
char buf[MAXSIZE];
void init() {
buf[fread(buf, 1, MAXSIZE, stdin)] = '\0';
bufpos = 0;
}
int readint() {
int val = 0;
for (; !isdigit(buf[bufpos]); bufpos++)
;
for (; isdigit(buf[bufpos]); bufpos++) val = val * 10 + buf[bufpos] - '0';
return val;
}
char readchar() {
for (; isspace(buf[bufpos]); bufpos++)
;
return buf[bufpos++];
}
int readstr(char* s) {
int cur = 0;
for (; isspace(buf[bufpos]); bufpos++)
;
for (; !isspace(buf[bufpos]); bufpos++) s[cur++] = buf[bufpos];
s[cur] = '\0';
return cur;
}
const int maxn = 100005;
int pre[maxn][26], suf[maxn][26];
struct block {
int n, sz, cnt;
int a[maxn], np[maxn];
int sum[maxn];
int st[433], bs[433];
void init(int n) {
if (n <= 0) return;
this->n = n;
st[1] = 1;
sz = sqrt(n) + 0.5;
cnt = (n - 1) / sz + 1;
for (int i = 1; i <= n; i++) np[i] = (i - 1) / sz + 1;
st[1] = 1;
for (int i = 2; i <= cnt; i++) st[i] = st[i - 1] + sz;
st[cnt + 1] = n + 1;
}
void add(int p, int v) {
int u = np[p];
for (int i = u; i <= cnt; i++) bs[i] ^= v;
for (int i = p; i < st[u + 1]; i++) {
sum[i] ^= v;
}
}
inline int query(int r) { return r ? (sum[r] ^ bs[np[r] - 1]) : 0; }
} b[26];
int p[maxn][26], id[maxn], cur[26];
int nxt[maxn][26], lst[maxn][26];
char s[maxn];
struct seg {
int l, r, c;
bool operator<(const seg& rhs) const { return r - l < rhs.r - rhs.l; }
} a[maxn * 53], w[maxn * 53];
int sum[maxn];
int query(int l, int r) {
if (l == r) return 1;
unsigned ans = 0;
for (int i = 0; i < 26; i++) {
if (nxt[l][i] == nxt[r + 1][i] || nxt[l][i] == cur[i] + 1) continue;
int now = suf[l][i] ^ pre[r][i] ^ b[i].query(lst[r][i] - 1) ^
b[i].query(nxt[l][i] - 1);
ans |= 1U << now;
}
for (int i = 0; i < 26; i++)
if (!(ans >> i & 1)) return i;
return 26;
}
int main() {
init();
int n = readstr(s + 1);
for (int i = 1; i <= n; i++) p[id[i] = ++cur[s[i] - 'a']][s[i] - 'a'] = i;
int cnt = 0;
for (int i = 0; i < 26; i++) {
int now = 1;
for (int j = 1; j <= n; j++) {
nxt[j][i] = now;
if (s[j] == i + 'a')
now++;
else if (now <= cur[i])
a[++cnt] = (seg){j, p[now][i] - 1, i};
}
now = cur[i];
for (int j = n; j; j--) {
lst[j][i] = now;
if (s[j] == i + 'a')
now--;
else if (now && (now == cur[i] || j != p[now + 1][i] - 1))
a[++cnt] = (seg){p[now][i] + 1, j, i};
}
}
for (int i = 0; i < 26; i++) b[i].init(cur[i] - 1);
for (int i = 1; i <= cnt; i++) sum[a[i].r - a[i].l + 1]++;
for (int i = 1; i <= n; i++) sum[i] += sum[i - 1];
for (int i = 1; i <= cnt; i++) w[sum[a[i].r - a[i].l + 1]--] = a[i];
for (int i = 1; i <= cnt; i++) {
int now = query(w[i].l, w[i].r);
bool fl = s[w[i].l - 1] == w[i].c + 'a', fr = s[w[i].r + 1] == w[i].c + 'a';
if (fl) pre[w[i].r][w[i].c] = now;
if (fr) suf[w[i].l][w[i].c] = now;
if (fl && fr) {
b[w[i].c].add(id[w[i].l - 1], now);
}
}
int m = readint();
while (m--) {
int l = readint(), r = readint();
puts(query(l, r) ? "Alice" : "Bob");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005;
int n, q, l, r, sig[MX][26], ant[MX][26], dpl[MX][26], dpr[MX][26], acu[MX];
string s;
int mex(int x) {
for (int i = 0;; i++)
if (!(x & (1 << i))) return i;
}
int query(int l, int r) {
if (l > r) return 0;
int res = 0;
for (int i = 0; i < 26; i++) {
int lt = sig[l][i];
int rt = ant[r][i];
if (lt != -1 && rt != -1 && lt <= r && rt >= l) {
if (dpl[l][i] == -1) dpl[l][i] = query(l, lt - 1);
if (dpr[r][i] == -1) dpr[r][i] = query(rt + 1, r);
res |= 1 << (acu[lt] ^ acu[rt] ^ dpl[l][i] ^ dpr[r][i]);
}
}
return mex(res);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
memset(sig, -1, sizeof(sig));
memset(ant, -1, sizeof(ant));
memset(dpl, -1, sizeof(dpl));
memset(dpr, -1, sizeof(dpr));
cin >> s;
n = s.size();
for (int i = 0; i < n; i++) {
for (int j = 0; i && j < 26; j++) ant[i][j] = ant[i - 1][j];
ant[i][s[i] - 'a'] = i;
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 26; j++) sig[i][j] = sig[i + 1][j];
sig[i][s[i] - 'a'] = i;
}
for (int i = 1; i < n; i++) {
int a = ant[i - 1][s[i] - 'a'];
if (a != -1) acu[i] = query(a + 1, i - 1) ^ acu[a];
}
cin >> q;
while (q--) {
cin >> l >> r;
if (query(l - 1, r - 1))
cout << "Alice" << '\n';
else
cout << "Bob" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1e5 + 10, M = 26;
template <typename T = int>
inline T read() {
T x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? -x : x;
}
char s[N];
int a[N], pre[N][26], suf[N][26], f[N][26], g[N], dp[27];
inline int mex(int a) {
int res = 0;
while (a >> res & 1) ++res;
return res;
}
inline int solve(int l, int r, int c) {
if (l > r) return 0;
if (dp[c] != -1) return dp[c];
int sta = 0;
for (int i = 0; i < 26; ++i) {
int L = suf[l][i], R = pre[r][i];
if (R < L) continue;
sta |= 1 << (f[L - 1][c] ^ g[R] ^ g[L] ^ solve(R + 1, r, i));
}
return dp[c] = mex(sta);
}
inline int Solve(int l, int r, int c) {
if (l > r) return 0;
if (dp[c] != -1) return dp[c];
int sta = 0;
for (int i = 0; i < 26; ++i) {
int L = suf[l][i], R = pre[r][i];
if (R < L) continue;
sta |= 1 << (Solve(l, L - 1, i) ^ g[R] ^ g[L] ^ f[r][i]);
}
return dp[c] = mex(sta);
}
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; ++i) a[i] = s[i] - 'a';
for (int i = 0; i < 26; ++i) suf[n + 1][i] = n + 1;
for (int i = 1; i <= n; ++i)
memcpy(pre[i], pre[i - 1], sizeof(pre[i])), pre[i][a[i]] = i;
for (int i = n; i >= 1; --i)
memcpy(suf[i], suf[i + 1], sizeof(suf[i])), suf[i][a[i]] = i;
for (int i = 1; i <= n; ++i) {
memset(dp, -1, sizeof(dp)), g[i] = g[pre[i - 1][a[i]]] ^ f[i - 1][a[i]];
for (int c = 0; c < 26; ++c) f[i][c] = solve(pre[i][c] + 1, i, c);
}
for (int q = read(); q; --q) {
int l = read(), r = read();
memset(dp, -1, sizeof(dp));
puts(Solve(l, r, 26) ? "Alice" : "Bob");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int rd() {
char ch = getchar();
int i = 0, f = 1;
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
i = (i << 1) + (i << 3) + ch - '0';
ch = getchar();
}
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>
template <typename Y>
inline bool updmin(Y &a, Y b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename Y>
inline bool updmax(Y &a, Y b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename Y>
inline Y abs(Y a) {
if (a < 0) a = -a;
return a;
}
template <typename Y>
inline Y sqr(Y a) {
return a * a;
}
int read() {
int w = 1, q = 0, ch = ' ';
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') w = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) q = q * 10 + ch - 48;
return q * w;
}
inline void FileIO() {
freopen(
""
".in",
"r", stdin);
freopen(
""
".out",
"w", stdout);
}
const int N = 100010;
char str[N];
int n, q, s[N], f[N][26], g[N][26], pre[N][26], nxt[N][26], sum[N];
int vis[27];
inline int calc(int l, int r) {
if (l > r) {
return 0;
}
for (int x = 0; x < 26; x++) {
vis[x] = 0;
}
for (int x = 0; x < 26; x++) {
int p = nxt[l][x], q = pre[r][x];
if (p <= q) {
vis[f[l][x] ^ g[r][x] ^ sum[p] ^ sum[q]] = 1;
}
}
for (int x = 0; x < 26; x++) {
if (!vis[x]) {
return x;
}
}
assert(0);
}
int main() {
memset(f, -1, sizeof f);
memset(g, -1, sizeof g);
scanf("%s", str + 1);
n = (int)strlen(str + 1);
q = read();
for (int i = 1; i <= n; i++) {
s[i] = str[i] - 'a';
}
for (int i = 1; i <= n; i++) {
for (int x = 0; x < 26; x++) {
pre[i][x] = pre[i - 1][x];
}
pre[i][s[i]] = i;
}
for (int x = 0; x < 26; x++) {
nxt[n + 1][x] = n + 1;
}
for (int i = n; i; i--) {
for (int x = 0; x < 26; x++) {
nxt[i][x] = nxt[i + 1][x];
}
nxt[i][s[i]] = i;
}
for (int i = 1; i <= n; i++) {
int k = pre[i - 1][s[i]];
if (k) {
sum[i] = sum[k] ^ g[i - 1][s[i]];
}
for (int j = i; j > k; j--) {
f[j][s[i]] = calc(j, i - 1);
}
std::vector<std::pair<int, int> > P(0);
for (int x = 0; x < 26; x++) {
if (pre[i][x]) {
P.push_back(std::make_pair(-pre[i][x], x));
}
}
std::sort(P.begin(), P.end());
for (auto p : P) {
g[i][p.second] = calc(-p.first + 1, i);
}
}
while (q--) {
int l = read(), r = read();
puts(calc(l, r) ? "Alice" : "Bob");
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.