solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int Mod = 998244353;
int add(int a, int b) { return (a += b) >= Mod ? a - Mod : a; }
int sub(int a, int b) { return (a -= b) < 0 ? a + Mod : a; }
int mul(int a, int b) { return 1ll * a * b % Mod; }
int n, k, a[N], siz, cntblo;
int pre[N], lst[N], dp[N], f[N], sum[400][N], ans[400];
int tag[400], L[400], R[400], bel[N];
void rebuild(int id) {
for (int i = L[id]; i <= R[id]; i++) {
sum[id][f[i]] = 0;
f[i] += tag[id];
}
tag[id] = ans[id] = 0;
for (int i = L[id]; i <= R[id]; i++) {
sum[id][f[i]] = add(sum[id][f[i]], dp[i]);
if (f[i] <= k) {
ans[id] = add(ans[id], dp[i]);
}
}
}
void update(int x, int vl) {
int id = bel[x];
sum[id][f[x]] = sub(sum[id][f[x]], dp[x]);
if (f[x] <= k) {
ans[id] = sub(ans[id], dp[x]);
}
f[x] += vl;
sum[id][f[x]] = add(sum[id][f[x]], dp[x]);
if (f[x] <= k) {
ans[id] = add(ans[id], dp[x]);
}
}
void modify(int l, int r, int vl) {
if (l > r) {
return;
}
if (bel[l] == bel[r]) {
rebuild(bel[l]);
for (int i = l; i <= r; i++) {
update(i, vl);
}
return;
}
rebuild(bel[l]);
for (int i = l; i <= R[bel[l]]; i++) {
update(i, vl);
}
rebuild(bel[r]);
for (int i = L[bel[r]]; i <= r; i++) {
update(i, vl);
}
for (int id = bel[l] + 1; id < bel[r]; id++) {
if (vl > 0) {
ans[id] = sub(ans[id], sum[id][k - tag[id]]);
++tag[id];
} else {
--tag[id];
ans[id] = add(ans[id], sum[id][k - tag[id]]);
}
}
}
int query(int x) {
int res = 0;
for (int i = 1; i < bel[x]; i++) {
res = add(res, ans[i]);
}
for (int i = L[bel[x]]; i <= x; i++) {
if (f[i] <= k) {
res = add(res, dp[i]);
}
}
return res;
}
int main() {
scanf("%d %d", &n, &k);
siz = sqrt(n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pre[i] = lst[a[i]];
lst[a[i]] = i;
bel[i] = (i - 1) / siz + 1;
}
cntblo = bel[n];
for (int i = 1; i <= cntblo; i++) {
L[i] = R[i - 1] + 1;
R[i] = min(n, L[i] + siz - 1);
}
dp[1] = 1;
for (int i = 1; i <= n; i++) {
modify(pre[i] + 1, i - 1, 1);
modify(pre[pre[i]] + 1, pre[i], -1);
dp[i + 1] = query(i);
rebuild(bel[i]);
update(i, 1);
}
printf("%d", dp[n + 1]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int MAXN = 2e5;
const int B = 315;
int cnt[1 + MAXN], dp[1 + MAXN];
vector<int> occ[1 + MAXN];
void add_self(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
void min_self(int &x, int y) { x = min(x, y); }
struct SQRT {
int id, offset, pref_sum[B];
void rebuild() {
int st = id * B, dr = (id + 1) * B - 1, minn = INT_MAX;
for (int i = st; i <= dr; ++i) min_self(minn, offset + cnt[i]);
for (int i = st; i <= dr; ++i) cnt[i] -= minn - offset;
offset = minn;
for (int i = 0; i < B; ++i) pref_sum[i] = 0;
for (int i = st; i <= dr; ++i) add_self(pref_sum[cnt[i]], dp[i]);
for (int i = 1; i < B; ++i) add_self(pref_sum[i], pref_sum[i - 1]);
}
} a[MAXN / B + 1];
int get_bucket(int index) { return index / B; }
void update(int l, int r, short t) {
int bl = get_bucket(l), br = get_bucket(r);
for (int i = l; i <= r && get_bucket(i) == bl; ++i) cnt[i] += t;
a[bl].rebuild();
if (bl == br) return;
for (int i = bl + 1; i < br; ++i) a[i].offset += t;
for (int i = r; get_bucket(i) == br; --i) cnt[i] += t;
a[br].rebuild();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, k;
cin >> n >> k;
for (int i = 0; i <= get_bucket(n); ++i) a[i].id = i;
for (int i = 1; i <= n; ++i) occ[i].emplace_back(-1);
dp[0] = 1;
a[0].rebuild();
for (int r = 0; r < n; ++r) {
int x;
cin >> x;
vector<int> &vec = occ[x];
if (static_cast<int>(vec.size()) >= 2)
update(vec.end()[-2] + 1, vec.back(), -1);
update(vec.back() + 1, r, 1);
vec.emplace_back(r);
int val = 0;
for (int i = 0; i <= get_bucket(r); ++i) {
int at_most = k - a[i].offset;
if (at_most >= 0) add_self(val, a[i].pref_sum[min(at_most, B - 1)]);
}
dp[r + 1] = val;
a[get_bucket(r + 1)].rebuild();
}
cout << dp[n] << '\n';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int p = 998244353;
int n, k, a[100102], dp[100102], pre[100102], ap[100102];
int blk, lx[320], rx[320], bel[100102], cn, cnt[100102], laz[320];
int sum[320][100102 << 1], sdp[320];
inline void clr(int x) {
for (int i = lx[x]; i <= rx[x]; i++) sum[x][cnt[i] + n] = 0;
sdp[x] = 0;
}
inline void love(int x) {
for (int i = lx[x]; i <= rx[x]; i++) cnt[i] += laz[x];
laz[x] = 0;
for (int i = lx[x]; i <= rx[x]; i++) (sum[x][cnt[i] + n] += dp[i]) %= p;
for (int i = lx[x]; i <= rx[x]; i++)
if (cnt[i] <= k) sdp[x] = (sdp[x] + dp[i]) % p;
}
inline void chng(int l, int r, int x) {
if (l > r) return;
if (bel[l] == bel[r]) {
clr(bel[l]);
for (int i = l; i <= r; i++) cnt[i] += x;
love(bel[l]);
return;
}
clr(bel[l]);
for (int i = l; i <= rx[bel[l]]; i++) cnt[i] += x;
love(bel[l]);
clr(bel[r]);
for (int i = lx[bel[r]]; i <= r; i++) cnt[i] += x;
love(bel[r]);
for (int i = bel[l] + 1; i < bel[r]; i++) {
if (x == 1) {
sdp[i] = (sdp[i] - sum[i][k - laz[i] + n] + p) % p;
laz[i]++;
} else {
laz[i]--;
sdp[i] = (sdp[i] + sum[i][k - laz[i] + n]) % p;
}
}
}
inline int ask(int l, int r) {
if (bel[l] == bel[r]) {
int ans = 0;
for (int i = l; i <= r; i++)
if (cnt[i] + laz[bel[l]] <= k) ans = (ans + dp[i]) % p;
return ans;
}
int ans = 0;
for (int i = l; i <= rx[bel[l]]; i++)
if (cnt[i] + laz[bel[i]] <= k) ans = (ans + dp[i]) % p;
for (int i = lx[bel[r]]; i <= r; i++)
if (cnt[i] + laz[bel[i]] <= k) ans = (ans + dp[i]) % p;
for (int i = bel[l] + 1; i < bel[r]; i++) ans = (ans + sdp[i]) % p;
return ans;
}
int main() {
scanf("%d%d", &n, &k);
blk = sqrt(n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) pre[i] = ap[a[i]], ap[a[i]] = i;
for (int i = 0; i <= n; i++) {
int j = i;
while (j <= n && (i / blk) == (j / blk)) j++;
j--;
lx[cn] = i, rx[cn] = j;
for (int ii = i; ii <= j; ii++) bel[ii] = cn;
cn++;
i = j;
}
dp[0] = 1;
for (int i = 0; i < cn; i++) love(i);
for (int i = 1; i <= n; i++) {
chng(pre[i], i - 1, 1);
chng(pre[pre[i]], pre[i] - 1, -1);
clr(bel[i]);
dp[i] = ask(0, i - 1);
love(bel[i]);
}
printf("%d\n", dp[n]);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, flag[310], ret[310], a[100100], pos[100100], lst[100100], w[100100],
f[100100], cnt[310][100100];
int mo(int x, int y) { return x + y < 998244353 ? x + y : x + y - 998244353; }
void add(int l, int r, int x) {
int s = (l - 1) / 350 + 1, t = r / 350 + 1;
if (s == t) {
for (int i = l; i <= r; i++) {
w[i] += x;
cnt[s][w[i] - x] = mo(cnt[s][w[i] - x], 998244353 - f[i - 1]),
cnt[s][w[i]] = mo(cnt[s][w[i]], f[i - 1]);
if (x == 1 && w[i] == k - flag[s] + 1)
ret[s] = mo(ret[s], 998244353 - f[i - 1]);
else if (x == -1 && w[i] == k - flag[s])
ret[s] = mo(ret[s], f[i - 1]);
}
return;
}
for (int i = l; i <= s * 350; i++) {
w[i] += x;
cnt[s][w[i] - x] = mo(cnt[s][w[i] - x], 998244353 - f[i - 1]),
cnt[s][w[i]] = mo(cnt[s][w[i]], f[i - 1]);
if (x == 1 && w[i] - 1 == k - flag[s])
ret[s] = mo(ret[s], 998244353 - f[i - 1]);
else if (x == -1 && w[i] == k - flag[s])
ret[s] = mo(ret[s], f[i - 1]);
}
for (int i = s + 1; i < t; i++) {
flag[i] += x;
if (x == 1)
ret[i] = mo(ret[i], 998244353 - cnt[i][k - flag[i] + 1]);
else
ret[i] = mo(ret[i], cnt[i][k - flag[i]]);
}
for (int i = (t - 1) * 350 + 1; i <= r; i++) {
w[i] += x;
cnt[t][w[i] - x] = mo(cnt[t][w[i] - x], 998244353 - f[i - 1]),
cnt[t][w[i]] = mo(cnt[t][w[i]], f[i - 1]);
if (x == 1 && w[i] - 1 == k - flag[t])
ret[t] = mo(ret[t], 998244353 - f[i - 1]);
else if (x == -1 && w[i] == k - flag[t])
ret[t] = mo(ret[t], f[i - 1]);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) lst[i] = pos[a[i]], pos[a[i]] = i;
f[0] = 1;
for (int i = 1; i <= n; i++) {
add(lst[i] + 1, i - 1, 1);
if (lst[i]) add(lst[lst[i]] + 1, lst[i], -1);
for (int j = 1; j <= (i - 1) / 350 + 1; j++) f[i] = mo(f[i], ret[j]);
if (k >= 1)
f[i] = mo(f[i], f[i - 1]),
ret[(i - 1) / 350 + 1] = mo(ret[(i - 1) / 350 + 1], f[i - 1]);
w[i] = 1;
cnt[(i - 1) / 350 + 1][1] = mo(cnt[(i - 1) / 350 + 1][1], f[i - 1]);
}
printf("%d\n", f[n]);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const long long BIG = 1446803456761533460;
const int Big = 336860180;
stringstream sss;
const int maxn = 100010;
const int SQ = 400;
const int maxnsq = maxn / SQ + 10;
int n, k;
int A[maxn], P[maxn];
map<int, int> lst;
int block[maxnsq][maxn * 2];
int lazy[maxnsq], val[maxn];
int dp[maxn];
int sum = 0;
int& blk(int x, int y) { return block[x / SQ][y + maxn]; }
void inc(int l, int r) {
while (l < r) {
if (l % SQ == 0 && l + SQ <= r) {
sum = ((sum) + (MOD - blk(l, k - lazy[l / SQ]))) % MOD;
++lazy[l / SQ];
l += SQ;
} else {
if (val[l] + lazy[l / SQ] == k) sum = ((sum) + (MOD - dp[l])) % MOD;
blk(l, val[l]) = ((blk(l, val[l])) + (MOD - dp[l])) % MOD;
++val[l];
blk(l, val[l]) = ((blk(l, val[l])) + (dp[l])) % MOD;
++l;
}
}
}
void dec(int l, int r) {
while (l < r) {
if (l % SQ == 0 && l + SQ <= r) {
--lazy[l / SQ];
sum = ((sum) + (blk(l, k - lazy[l / SQ]))) % MOD;
l += SQ;
} else {
blk(l, val[l]) = ((blk(l, val[l])) + (MOD - dp[l])) % MOD;
--val[l];
blk(l, val[l]) = ((blk(l, val[l])) + (dp[l])) % MOD;
if (val[l] + lazy[l / SQ] == k) sum = ((sum) + (dp[l])) % MOD;
++l;
}
}
}
void MAIN() {
cin >> n >> k;
for (int i = (0); i < (n); ++i) {
cin >> A[i];
P[i + 1] = lst.count(A[i]) ? lst[A[i]] : 0;
lst[A[i]] = i + 1;
}
dp[0] = 1;
sum = 1;
blk(0, 0) = 1;
for (int i = (1); i < (n + 1); ++i) {
inc(P[i], i);
dec(P[P[i]], P[i]);
dp[i] = sum;
sum = ((sum) + (dp[i])) % MOD;
val[i] = -lazy[i / SQ];
blk(i, val[i]) = ((blk(i, val[i])) + (dp[i])) % MOD;
}
cout << dp[n] << '\n';
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(10);
sss << R"(
5 2
1 1 2 1 3
)";
MAIN();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int S = 330;
const int mod = 998244353;
int n, k, a[N], pre[N], last[N];
int s[N / S + 5][N], val[N / S + 5], f[N], dp[N], inblock[N], ans;
void add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
}
void ins(int u, int v) {
if (f[u] + val[inblock[u]] <= k) add(ans, -dp[u - 1]);
add(s[inblock[u]][f[u]], -dp[u - 1]);
f[u] += v;
if (f[u] + val[inblock[u]] <= k) add(ans, dp[u - 1]);
add(s[inblock[u]][f[u]], dp[u - 1]);
}
void update(int L, int R, int v) {
if (L > R) return;
if (inblock[L] + 1 >= inblock[R])
for (int i = L; i <= R; i++) ins(i, v);
else {
for (int i = L; i <= inblock[L] * S; i++) ins(i, v);
for (int i = (inblock[R] - 1) * S + 1; i <= R; i++) ins(i, v);
for (int i = inblock[L] + 1; i < inblock[R]; i++) {
if (v == 1)
add(ans, mod - s[i][k - val[i]]);
else
add(ans, s[i][k + 1 - val[i]]);
val[i] += v;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pre[i] = last[a[i]];
last[a[i]] = i;
}
for (int i = 1; i <= n; i++) inblock[i] = (i - 1) / S + 1;
dp[0] = 1;
add(ans, 1);
add(s[inblock[1]][f[1]], 1);
for (int i = 1; i <= n; i++) {
update(pre[i] + 1, i, 1);
update(pre[pre[i]] + 1, pre[i], -1);
dp[i] = ans;
add(ans, dp[i]);
add(s[inblock[i + 1]][f[i + 1]], dp[i]);
}
cout << dp[n];
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int BLK = 320;
const int MXN = 1e5 + 5;
const int MOD = 998244353;
int add(int x, int y) { return (x += y) < MOD ? x : x - MOD; }
int sub(int x, int y) { return (x -= y) >= 00 ? x : x + MOD; }
int b[BLK];
int q[BLK][2 * BLK + 5];
int n, k;
int d[MXN];
int dp[MXN];
int arr[MXN];
int last1[MXN];
int last2[MXN];
void add(int pos) {
int id = (pos - 1) / BLK;
for (int i = BLK; i <= 2 * BLK; ++i) {
q[id][i] = add(q[id][i], dp[pos - 1]);
}
}
void update(int pos, int sgn) {
int id = (pos - 1) / BLK;
b[id] += sgn;
for (int i = pos; i > id * BLK; --i) {
if (sgn == +1) q[id][d[i] + BLK] = sub(q[id][d[i] + BLK], dp[i - 1]);
d[i] += sgn;
if (sgn == -2) {
q[id][d[i] + BLK] = add(q[id][d[i] + BLK], dp[i - 1]),
q[id][d[i] + BLK + 1] =
add(q[id][d[i] + BLK + 1], dp[i - 1]);
}
}
}
int get(int pos) {
int ret = 0;
int id = (pos - 1) / BLK;
for (int i = pos; i > id * BLK; --i) {
if (d[i] <= k) ret = add(ret, dp[i - 1]);
}
int sum = b[id];
while (--id >= 0) {
if (abs(sum - k) <= BLK) {
ret = add(ret, q[id][k - sum + BLK]);
} else if (sum < k) {
ret = add(ret, q[id][BLK + BLK]);
}
sum += b[id];
}
return ret;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
dp[0] = 1;
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> arr[i];
add(i);
update(i, 1);
if (last1[arr[i]]) update(last1[arr[i]], -2);
if (last2[arr[i]]) update(last2[arr[i]], +1);
dp[i] = get(i);
last2[arr[i]] = last1[arr[i]];
last1[arr[i]] = i;
}
cout << dp[n] << '\n';
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T lowbit(T x) {
return x & (-x);
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
inline T Pow(T a, T b, T p) {
T ret = 1;
a %= p;
for (; b; b >>= 1, a = a * a % p)
if (b & 1) (ret *= a) %= p;
return ret;
}
template <class T>
inline void read(T &ret) {
T x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
ret = x * f;
}
const int N = 1e5 + 10, M = 1e3 + 10;
const long long Z = 998244353;
struct node {
int prev, w;
} lk[N];
int head[N], sz = 0;
void add(int x, int loc) {
lk[++sz] = {head[x], loc};
head[x] = sz;
}
int n, m, a[N], b[N], Prev[N];
int blo, bl[N];
long long f[N], g[M][M], sum[M];
inline long long __g(int x, int y) {
if (y > blo * 2)
return g[x][blo * 2];
else if (y >= 0)
return g[x][y];
else
return 0;
}
void modify(int x, int val, int up) {
b[x] = val;
int cur = 0;
fill(g[bl[x]], g[bl[x]] + blo * 2 + 1, 0);
for (int i = (min(up, ((bl[x] + 1) * blo) - 1)); i >= (((bl[x]) * blo));
i--) {
cur += b[i];
(g[bl[x]][cur + blo] += f[i - 1]) %= Z;
}
sum[bl[x]] = cur;
for (int i = (1); i <= (blo * 2); i++) (g[bl[x]][i] += g[bl[x]][i - 1]) %= Z;
}
long long query(int x) {
long long ret = 0;
long long cur = 0;
for (int i = (bl[x]); i >= (0); i--) {
(ret += __g(i, m - cur + blo)) %= Z;
cur += sum[i];
}
return ret;
}
int main() {
read(n);
read(m);
for (int i = (1); i <= (n); i++) {
read(a[i]);
add(a[i], i);
}
for (int i = (1); i <= (n); i++)
for (int j = head[i]; j; j = lk[j].prev) Prev[lk[j].w] = lk[lk[j].prev].w;
blo = ceil(sqrt(n / 6.0));
for (int i = (1); i <= (n); i++) bl[i] = i / blo;
f[0] = 1;
for (int i = (1); i <= (n); i++) {
int p = Prev[i], pp = Prev[p];
if (pp) modify(pp, 0, i);
if (p) modify(p, -1, i);
modify(i, 1, i);
f[i] = query(i);
}
printf("%lld\n", f[n]);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const long long INF = 1e18L;
const long long MAXN = 2e5;
const long long B = 315;
long long cnt[1 + MAXN], dp[1 + MAXN];
vector<long long> occ[1 + MAXN];
void add_self(long long &x, long long y) {
x += y;
if (x >= mod) x -= mod;
}
void min_self(long long &x, long long y) { x = min(x, y); }
struct SQRT {
long long id, offset, pref_sum[B];
void rebuild() {
long long st = id * B, dr = (id + 1) * B - 1, minn = INF;
for (long long i = st; i <= dr; ++i) min_self(minn, offset + cnt[i]);
for (long long i = st; i <= dr; ++i) cnt[i] -= minn - offset;
offset = minn;
for (long long i = 0; i < B; ++i) pref_sum[i] = 0;
for (long long i = st; i <= dr; ++i) add_self(pref_sum[cnt[i]], dp[i]);
for (long long i = 1; i < B; ++i) add_self(pref_sum[i], pref_sum[i - 1]);
}
} a[MAXN / B + 1];
long long get_bucket(long long index) { return index / B; }
void update(long long l, long long r, short t) {
long long bl = get_bucket(l), br = get_bucket(r);
for (long long i = l; i <= r && get_bucket(i) == bl; ++i) cnt[i] += t;
a[bl].rebuild();
if (bl == br) return;
for (long long i = bl + 1; i < br; ++i) a[i].offset += t;
for (long long i = r; get_bucket(i) == br; --i) cnt[i] += t;
a[br].rebuild();
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long n, k;
cin >> n >> k;
for (long long i = 0; i <= get_bucket(n); ++i) a[i].id = i;
for (long long i = 1; i <= n; ++i) occ[i].emplace_back(-1);
dp[0] = 1;
a[0].rebuild();
for (long long r = 0; r < n; ++r) {
long long x;
cin >> x;
vector<long long> &vec = occ[x];
if (static_cast<long long>(vec.size()) >= 2)
update(vec.end()[-2] + 1, vec.back(), -1);
update(vec.back() + 1, r, 1);
vec.emplace_back(r);
long long val = 0;
for (long long i = 0; i <= get_bucket(r); ++i) {
long long at_most = k - a[i].offset;
if (at_most >= 0) add_self(val, a[i].pref_sum[min(at_most, B - 1)]);
}
dp[r + 1] = val;
a[get_bucket(r + 1)].rebuild();
}
cout << dp[n] << '\n';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
int a[101001];
vector<int> positions[101010];
int tr[404040];
int b[101010];
int dp[404040];
long long getSum(int* b, int* dp, int n) {
long long res = 0;
for (int j = 0; j < n; ++j) {
res += b[j] > 0 ? 0 : dp[j];
}
return res;
}
const int fftmod = 998244353;
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < (n); ++i) {
b[i] -= k;
}
for (int i = 0; i < (n); ++i) {
cin >> a[i];
--a[i];
positions[i].push_back(-1);
positions[i].push_back(-1);
}
dp[0] = 1;
for (int i = 0; i < n; ++i) {
int x = a[i];
{
int to = positions[x].back();
int from = *++positions[x].rbegin() + 1;
for (int j = from; j <= to; ++j) {
b[j]--;
}
}
int from = positions[x].back() + 1;
for (int j = from; j <= i; ++j) {
b[j]++;
}
long long res = 0;
for (int j = 0; j < i + 1; ++j) res += b[j] > 0 ? 0 : dp[j];
dp[i + 1] = res % fftmod;
positions[x].push_back(i);
}
cout << dp[n] << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
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...);
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
const int maxn = 2e5 + 10;
const int md = 998244353;
const int BlockLen = 50;
const int NumBlocks = maxn / BlockLen + 10;
void addto(int &x, int y) {
x = x + y;
if (x >= md) x -= md;
}
int T;
string str;
int n, m;
int dp[maxn], cnt[maxn];
vector<int> e[maxn];
int nk;
struct Block {
int L, R;
vector<pair<int, int>> pref_sums;
int ptr;
int increase;
vector<int> num_incrs;
Block() : L(0), R(0), ptr(0), increase(0) {}
Block(int l, int r) : L(l), R(r), ptr(0), increase(0), num_incrs(r - l) {}
void IncrAll(int delta) { increase += delta; }
void Rebuild() {
vector<int> order(num_incrs.size());
int min_num_incrs = num_incrs[0];
for (int i = 1; i < num_incrs.size(); ++i) {
min_num_incrs = min(min_num_incrs, num_incrs[i]);
}
vector<vector<int>> base(num_incrs.size());
for (int i = 0; i < num_incrs.size(); ++i) {
base[num_incrs[i] - min_num_incrs].push_back(i);
}
int cnt = 0;
for (int i = 0; i < base.size(); ++i) {
for (auto id : base[i]) order[cnt++] = id;
}
pref_sums.clear();
pref_sums.emplace_back((int)-1e9, 0);
pref_sums.emplace_back(num_incrs[order[0]], dp[order[0] + L]);
for (int i = 1; i < order.size(); ++i) {
const int v = order[i];
long long val = (pref_sums.back().second + dp[v + L]) % md;
if (num_incrs[v] == pref_sums.back().first) {
pref_sums.back().second = val;
} else {
pref_sums.emplace_back(num_incrs[v], val);
}
}
ptr = 0;
42;
}
void IncrSeg(int lft, int rgt, int delta) {
for (int i = 0; i < (int)num_incrs.size(); ++i) {
num_incrs[i] += increase;
}
increase = 0;
for (int i = lft - L; i < rgt - L; ++i) {
num_incrs[i] += delta;
}
42;
Rebuild();
}
int GetAtMaxK() {
while (ptr > 0 && pref_sums[ptr].first + increase > nk) {
--ptr;
}
while (ptr < pref_sums.size() - 1 &&
pref_sums[ptr + 1].first + increase <= nk) {
++ptr;
}
42;
return pref_sums[ptr].second;
}
};
Block blocks[NumBlocks];
void Increase(int L, int R, int delta) {
42;
for (int i = 0; i < n; ++i) {
const int l_block = i * BlockLen;
const int r_block = min((i + 1) * BlockLen, n + 1);
if (l_block > n) break;
if (r_block <= L || l_block >= R) continue;
if (L <= l_block && r_block <= R) {
blocks[i].IncrAll(delta);
} else {
blocks[i].IncrSeg(max<int>(L, l_block), min(R, r_block), delta);
}
}
}
int GetAtMaxK() {
int ans = 0;
for (int i = 0; i < NumBlocks; ++i) {
const int l_block = i * BlockLen;
if (l_block > n) break;
ans = (ans + blocks[i].GetAtMaxK()) % md;
}
return ans;
}
void BuildBlocks() {
for (int i = 0; i < NumBlocks; ++i) {
const int l_block = i * BlockLen;
const int r_block = min(n + 1, (i + 1) * BlockLen);
if (l_block > n) break;
blocks[i] = Block(l_block, r_block);
blocks[i].Rebuild();
}
}
void task() {
cin >> n >> nk;
dp[0] = 1;
BuildBlocks();
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
e[x].push_back(i);
int l1, r1 = i;
if (e[x].size() > 1)
l1 = e[x][e[x].size() - 2];
else
l1 = 0;
Increase(l1, r1, 1);
if (e[x].size() >= 2) {
int l2 = e[x].size() >= 3 ? e[x][e[x].size() - 3] : 0, r2 = l1;
Increase(l2, r2, -1);
}
42;
dp[i] = GetAtMaxK();
blocks[i / BlockLen].Rebuild();
42;
}
cout << dp[n] << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
T = 1;
while (T--) {
task();
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int i, j, m, n, block_size, a[200005], k;
int temp[3][100005], pre[3][100005], smallest[319];
long long sum[319][319], f[200005], dp[200005], inf, mod;
int tag[319];
void update(int l, int r, int c) {
int block1, block2, ind1, ind2;
block1 = (l - 1) / block_size;
block2 = (r - 1) / block_size;
ind1 = (l - 1) % block_size;
ind2 = (r - 1) % block_size;
int i, j;
for (i = block1 + 1; i <= block2 - 1; i++) {
tag[i] += c;
smallest[i] += c;
}
long long x[319];
if (block1 == block2) {
for (i = l; i <= r; i++) {
f[i] += c;
}
smallest[block1] = inf;
for (i = block1 * block_size; i <= (block1 + 1) * block_size - 1; i++) {
f[i + 1] += tag[block1];
if (f[i + 1] < smallest[block1]) smallest[block1] = f[i + 1];
}
for (i = 0; i <= block_size - 1; i++) {
x[i] = 0;
}
for (i = block1 * block_size; i <= (block1 + 1) * block_size - 1; i++) {
x[f[i + 1] - smallest[block1]] =
(x[f[i + 1] - smallest[block1]] + dp[i]) % mod;
}
sum[block1][0] = x[0];
for (i = 1; i <= block_size - 1; i++) {
sum[block1][i] = (sum[block1][i - 1] + x[i]) % mod;
}
tag[block1] = 0;
return;
}
for (i = ind1; i <= block_size - 1; i++) {
f[block1 * block_size + i + 1] += c;
}
smallest[block1] = inf;
for (i = block1 * block_size; i <= (block1 + 1) * block_size - 1; i++) {
f[i + 1] += tag[block1];
if (f[i + 1] < smallest[block1]) smallest[block1] = f[i + 1];
}
for (i = 0; i <= block_size - 1; i++) {
x[i] = 0;
}
for (i = block1 * block_size; i <= (block1 + 1) * block_size - 1; i++) {
x[f[i + 1] - smallest[block1]] =
(x[f[i + 1] - smallest[block1]] + dp[i]) % mod;
}
sum[block1][0] = x[0];
for (i = 1; i <= block_size - 1; i++) {
sum[block1][i] = (sum[block1][i - 1] + x[i]) % mod;
}
tag[block1] = 0;
for (i = 0; i <= ind2; i++) {
f[block2 * block_size + i + 1] += c;
}
smallest[block2] = inf;
for (i = block2 * block_size; i <= (block2 + 1) * block_size - 1; i++) {
f[i + 1] += tag[block2];
if (f[i + 1] < smallest[block2]) smallest[block2] = f[i + 1];
}
for (i = 0; i <= block_size - 1; i++) {
x[i] = 0;
}
for (i = block2 * block_size; i <= (block2 + 1) * block_size - 1; i++) {
x[f[i + 1] - smallest[block2]] =
(x[f[i + 1] - smallest[block2]] + dp[i]) % mod;
}
sum[block2][0] = x[0];
for (i = 1; i <= block_size - 1; i++) {
sum[block2][i] = (sum[block2][i - 1] + x[i]) % mod;
}
tag[block2] = 0;
}
int main() {
mod = 998244353;
inf = 1000000000;
scanf("%d%d", &n, &k);
block_size = int(sqrt(n) + 0.000001);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= n; i++) {
if (temp[1][a[i]]) {
pre[1][i] = temp[1][a[i]];
if (temp[2][a[i]]) {
pre[2][i] = temp[2][a[i]];
}
temp[2][a[i]] = temp[1][a[i]];
temp[1][a[i]] = i;
} else {
temp[1][a[i]] = i;
}
}
dp[0] = 1;
for (i = 1; i <= n; i++) {
update(pre[1][i] + 1, i, 1);
if (pre[2][i] + 1 <= pre[1][i]) {
update(pre[2][i] + 1, pre[1][i], -1);
}
int block, ind;
block = (i - 1) / block_size;
ind = (i - 1) % block_size;
for (j = 0; j <= block; j++) {
if (smallest[j] <= k) {
if (smallest[j] + block_size - 1 > k) {
dp[i] = (dp[i] + sum[j][k - smallest[j]]) % mod;
} else {
dp[i] = (dp[i] + sum[j][block_size - 1]) % mod;
}
}
}
}
printf("%lld\n", dp[n]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
inline int Read() {
int x(0);
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0', c = getchar();
return x;
}
const int maxn = 1e5 + 9, mod = 998244353, maxm = 409;
int n, k, ans;
int a[maxn], cnt[maxn], lst[maxn], fir[maxn], bl[maxm], br[maxm], col[maxn],
v[maxn], lazy[maxm], f[maxn], sum[maxm][maxn];
inline void Fir() {
int size(sqrt(n)), pieces(ceil(1.0 * n / size));
for (int i = 1; i < pieces; ++i) {
bl[i] = (i - 1) * size + 1;
br[i] = i * size;
for (int j = bl[i]; j <= br[i]; ++j) col[j] = i;
}
bl[pieces] = (pieces - 1) * size + 1;
br[pieces] = n;
for (int j = bl[pieces]; j <= br[pieces]; ++j) col[j] = pieces;
for (int i = 1; i <= n; ++i) {
lst[i] = fir[a[i]];
fir[a[i]] = i;
}
}
inline void Modify(int l, int r, int val) {
int lt(col[l]), rt(col[r]);
if (lt == rt) {
for (int i = l; i <= r; ++i) {
if (val == 1)
(v[i] + lazy[lt] == k) ? ans = (ans - f[i] + mod) % mod : 0;
else
(v[i] + lazy[lt] == k + 1) ? ans = (ans + f[i]) % mod : 0;
sum[lt][v[i]] = (sum[lt][v[i]] - f[i] + mod) % mod, v[i] += val,
sum[lt][v[i]] = (sum[lt][v[i]] + f[i]) % mod;
}
} else {
for (int i = l; i <= br[lt]; ++i) {
if (val == 1)
(v[i] + lazy[lt] == k) ? ans = (ans - f[i] + mod) % mod : 0;
else
(v[i] + lazy[lt] == k + 1) ? ans = (ans + f[i]) % mod : 0;
sum[lt][v[i]] = (sum[lt][v[i]] - f[i] + mod) % mod, v[i] += val,
sum[lt][v[i]] = (sum[lt][v[i]] + f[i]) % mod;
}
for (int i = bl[rt]; i <= r; ++i) {
if (val == 1)
(v[i] + lazy[rt] == k) ? ans = (ans - f[i] + mod) % mod : 0;
else
(v[i] + lazy[rt] == k + 1) ? ans = (ans + f[i]) % mod : 0;
sum[rt][v[i]] = (sum[rt][v[i]] - f[i] + mod) % mod, v[i] += val,
sum[rt][v[i]] = (sum[rt][v[i]] + f[i]) % mod;
}
for (int i = lt + 1; i <= rt - 1; ++i) {
if (val == 1)
ans = (ans - sum[i][k - lazy[i]] + mod) % mod;
else
ans = (ans + sum[i][k + 1 - lazy[i]]) % mod;
lazy[i] += val;
}
}
}
inline void Solve() {
ans = f[1] = sum[1][0] = 1;
for (int i = 1; i <= n; ++i) {
++cnt[a[i]];
int p(lst[i]), q(lst[p]);
if (cnt[a[i]] == 1)
Modify(1, i, 1);
else if (cnt[a[i]] == 2) {
Modify(p + 1, i, 1);
Modify(1, p, -1);
} else {
Modify(p + 1, i, 1);
Modify(q + 1, p, -1);
}
f[i + 1] = ans;
sum[col[i + 1]][v[i + 1]] = (sum[col[i + 1]][v[i + 1]] + f[i + 1]) % mod;
ans = (ans + f[i + 1]) % mod;
}
printf("%d", f[n + 1]);
}
int main() {
n = Read();
k = Read();
for (int i = 1; i <= n; ++i) a[i] = Read();
Fir();
Solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = (res * x) % 998244353;
y = y / 2, x = (x * x) % 998244353;
}
return res % 998244353;
}
long long n, k;
const long long BLSZ = 300;
long long NUMBL;
inline long long getBL(long long i) { return i / BLSZ; }
inline long long getL(long long i) { return i * BLSZ; }
inline long long getR(long long i) { return min((i + 1) * BLSZ - 1, n - 1); }
inline void add(long long &a, long long b) {
a += b;
if (a >= 998244353) a -= 998244353;
}
long long base[100100];
long long arr[100100];
long long dp[100100];
vector<vector<long long> > pos(100100);
struct block {
long long l, r;
long long offset;
long long pref[BLSZ];
void init(long long _l, long long _r, long long val) {
l = (_l), r = (_r), offset = (val);
}
void recalc() {
long long smallest = 1e18;
long long i;
for (i = l; i <= r; i++) smallest = min(smallest, base[i] + offset);
for (i = l; i <= r; i++) {
base[i] = base[i] - smallest + offset;
}
offset = smallest;
for (i = 0; i < BLSZ; i++) pref[i] = 0;
for (i = l; i <= r; i++) {
add(pref[base[i]], dp[i]);
}
for (i = 1; i < BLSZ; i++) add(pref[i], pref[i - 1]);
}
};
block *BARR;
void init() {
NUMBL = getBL(n - 1);
BARR = new block[NUMBL + 1];
for (long long i = 0; i <= NUMBL; i++) {
BARR[i].init(getL(i), getR(i), 0);
BARR[i].recalc();
}
}
void update(long long l, long long r, long long diff) {
if (getBL(l) == getBL(r)) {
for (long long i = l; i <= r; ++i) {
base[i] += diff;
}
BARR[getBL(l)].recalc();
} else {
long long x = getBL(l);
for (long long i = l; i <= getR(x); i++) {
base[i] += diff;
}
BARR[x].recalc();
x = getBL(r);
for (long long i = r; i >= getL(x); i--) {
base[i] += diff;
}
BARR[x].recalc();
for (long long i = getBL(l) + 1; i < getBL(r); i++) {
BARR[i].offset += diff;
}
}
}
long long query(long long l, long long r) {
long long ans = 0;
if (getBL(l) == getBL(r)) {
long long x = getBL(l);
for (long long i = l; i <= r; ++i) {
if (base[i] + BARR[x].offset <= k) add(ans, dp[i]);
}
return ans;
} else {
long long x = getBL(l);
for (long long i = l; i <= getR(x); i++) {
if (base[i] + BARR[x].offset <= k) add(ans, dp[i]);
}
x = getBL(r);
for (long long i = r; i >= getL(x); i--) {
if (base[i] + BARR[x].offset <= k) add(ans, dp[i]);
}
for (long long i = getBL(l) + 1; i < getBL(r); i++) {
if (k - BARR[i].offset >= 0)
add(ans, BARR[i].pref[min(k - BARR[i].offset, BLSZ - 1)]);
}
return ans;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
dp[0] = 1;
init();
long long i;
for (i = 0; i < n; i++) {
cin >> arr[i];
dp[i + 1] = 0;
if (pos[arr[i]].size() == 0) {
update(0, i, 1);
} else if (pos[arr[i]].size() == 1) {
update(0, pos[arr[i]][0], -1);
update(pos[arr[i]][0] + 1, i, 1);
} else {
update(pos[arr[i]][pos[arr[i]].size() - 2] + 1,
pos[arr[i]][pos[arr[i]].size() - 1], -1);
update(pos[arr[i]][pos[arr[i]].size() - 1] + 1, i, 1);
}
pos[arr[i]].push_back(i);
dp[i + 1] = query(0, i);
BARR[getBL(i + 1)].recalc();
}
cout << dp[n];
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int blkbase[(350 + 5)][(350 + 5)];
int blkpsum[(350 + 5)][(350 + 5)];
int f[100005];
int n, k;
int a[100005];
int previ[100005];
int previval[100005];
int blk[100005];
int blkbegin[100005];
int blkend[1000005];
int cur[100005];
int cur_offset[(350 + 5)];
int cur_cnt[(350 + 5)];
int cur_total = 0;
int blkcnt;
bool cmp(int A, int B) { return cur[A] < cur[B]; }
void rebuild(int block) {
for (int i = blkbegin[block], j = 1; j <= 350; i++, j++) {
blkbase[block][j] = i;
}
sort(blkbase[block] + 1, blkbase[block] + 350 + 1, cmp);
int r = 0;
for (int i = 1; i <= 350; i++) {
blkpsum[block][i] = blkpsum[block][i - 1] + f[blkbase[block][i] - 1];
if (blkpsum[block][i] >= 998244353) blkpsum[block][i] -= 998244353;
if (cur[blkbase[block][i]] <= k) r = i;
}
cur_total -= cur_cnt[block];
cur_total += blkpsum[block][r];
cur_cnt[block] = blkpsum[block][r];
cur_total %= 998244353;
cur_total += 998244353;
cur_total %= 998244353;
}
void update(int l, int r, int change) {
for (int i = blk[l] + 1; i < blk[r]; i++) {
cur_offset[i] += change;
int L = 0, R = 350;
while (L < R) {
int mid = (L + R) / 2 + 1;
if (cur[blkbase[i][mid]] + cur_offset[i] <= k) {
L = mid;
} else {
R = mid - 1;
}
}
cur_total -= cur_cnt[i];
cur_total += blkpsum[i][R];
cur_cnt[i] = blkpsum[i][R];
cur_total %= 998244353;
cur_total += 998244353;
cur_total %= 998244353;
}
for (int i = blkbegin[blk[l]]; i <= blkend[blk[l]]; i++) {
cur[i] += cur_offset[blk[l]];
}
cur_offset[blk[l]] = 0;
for (int i = l; i <= blkend[blk[l]] && i <= r; i++) {
cur[i] += change;
}
for (int j = 1; j <= n; j++) {
}
rebuild(blk[l]);
if (blk[l] != blk[r]) {
for (int i = blkbegin[blk[r]]; i <= blkend[blk[r]]; i++) {
cur[i] += cur_offset[blk[r]];
}
cur_offset[blk[r]] = 0;
for (int i = blkbegin[blk[r]]; i <= r; i++) {
cur[i] += change;
}
rebuild(blk[r]);
}
}
int main() {
cur[0] = -10000000;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
previ[i] = previval[a[i]];
previval[a[i]] = i;
}
for (int i = 1; i <= 100000; i++) blk[i] = (i - 1) / 350 + 1;
for (int i = 1; i <= 350; i++) {
blkbegin[i] = (i - 1) * 350 + 1;
blkend[i] = blkbegin[i] + 350 - 1;
for (int j = (i - 1) * 350 + 1, x = 1; x <= 350; j++, x++) {
blkbase[i][x] = j;
}
}
f[0] = 1;
rebuild(1);
for (int i = 1; i <= n; i++) {
update(previ[i] + 1, i, 1);
if (previ[i]) update(previ[previ[i]] + 1, previ[i], -1);
f[i] = cur_total;
for (int j = 0; j < 350; j++) {
cur[blkbegin[blk[i + 1]] + j] += cur_offset[blk[i + 1]];
}
cur_offset[blk[i + 1]] = 0;
for (int j = 1; j <= n; j++) {
}
rebuild(blk[i + 1]);
}
printf("%d", f[n]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int M = 205;
const int N = 100005;
const int L = 100000;
const int mod = 998244353;
int n, k, len, a[N], bel[N], pre[N], las[N], dp[N], fl[N], tot[N], ans[M],
s[M][N << 1];
void ad(int i, int x) {
(s[bel[i]][L + tot[i]] += mod - dp[i]) %= mod;
tot[i] += x;
(s[bel[i]][L + tot[i]] += dp[i]) %= mod;
if (x == 1 && tot[i] + fl[bel[i]] == k + 1) {
(ans[bel[i]] += mod - dp[i]) %= mod;
}
if (x == -1 && tot[i] + fl[bel[i]] == k) {
(ans[bel[i]] += dp[i]) %= mod;
}
}
void add(int l, int r, int x) {
if (bel[l] + 1 >= bel[r]) {
for (int i = l; i <= r; i++) {
ad(i, x);
}
return;
}
for (int i = l; i < (bel[l] + 1) * len; i++) {
ad(i, x);
}
for (int i = bel[r] * len; i <= r; i++) {
ad(i, x);
}
for (int i = bel[l] + 1; i < bel[r]; i++) {
if (x == 1) {
(ans[i] += mod - s[i][L + k - fl[i]]) %= mod;
}
if (x == -1) {
(ans[i] += s[i][L + k - fl[i] + 1]) %= mod;
}
fl[i] += x;
}
}
int query(int l, int r) {
int sum = 0;
if (bel[l] + 1 >= bel[r]) {
for (int i = l; i <= r; i++) {
if (tot[i] + fl[bel[i]] <= k) {
(sum += dp[i]) %= mod;
}
}
return sum;
}
for (int i = l; i < (bel[l] + 1) * len; i++) {
if (tot[i] + fl[bel[i]] <= k) {
(sum += dp[i]) %= mod;
}
}
for (int i = bel[r] * len; i <= r; i++) {
if (tot[i] + fl[bel[i]] <= k) {
(sum += dp[i]) %= mod;
}
}
for (int i = bel[l] + 1; i < bel[r]; i++) {
(sum += ans[i]) %= mod;
}
return sum;
}
signed main() {
scanf("%d%d", &n, &k);
len = 500;
for (int i = 0; i <= n; i++) {
bel[i] = i / len;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
dp[0] = 1;
ans[0] += dp[0];
s[0][L] += dp[0];
for (int i = 1; i <= n; i++) {
pre[i] = las[a[i]];
las[a[i]] = i;
add(pre[i], i - 1, 1);
if (pre[i]) add(pre[pre[i]], pre[i] - 1, -1);
dp[i] = query(0, i - 1);
(ans[bel[i]] += dp[i]) %= mod;
(s[bel[i]][L - fl[bel[i]]] += dp[i]) %= mod;
}
cout << dp[n];
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353LL;
int kk;
class Block {
public:
int aux;
vector<long long> pre;
int st, en;
int lo, hi;
vector<long long> vals;
vector<int> dist;
Block(int a, int b) {
aux = 0;
st = a;
en = b;
lo = 0;
hi = 0;
pre.push_back(0LL);
pre.push_back(0LL);
for (int i = st; i <= en; i++) {
vals.push_back(0LL);
dist.push_back(0);
}
}
void change(int ind, long long val) {
if (ind < st || ind > en) {
return;
}
vals[ind - st] = val;
for (int i = dist[ind - st]; i <= hi; i++) {
pre[i - lo + 1] += val;
pre[i - lo + 1] %= mod;
}
}
void modify(int l, int r, int delta) {
if (l <= st && r >= en) {
aux += delta;
return;
}
if (st > r || en < l) {
return;
}
for (int i = max(l, st); i <= min(r, en); i++) {
dist[i - st] += delta;
}
for (int i = st; i <= en; i++) {
dist[i - st] += aux;
if (i == st) {
lo = dist[i - st];
hi = dist[i - st];
} else {
lo = min(lo, dist[i - st]);
hi = max(hi, dist[i - st]);
}
}
aux = 0;
pre.clear();
pre.resize(hi - lo + 2);
for (int i = st; i <= en; i++) {
pre[dist[i - st] - lo + 1] += vals[i - st];
pre[dist[i - st] - lo + 1] %= mod;
}
for (int i = 1; i < pre.size(); i++) {
pre[i] += pre[i - 1];
pre[i] %= mod;
}
}
long long sum(int l, int r) {
if (st > r || en < l) {
return 0LL;
}
int k = kk;
if (l <= st && r >= en) {
k -= aux;
if (k < lo) {
return 0LL;
}
if (k >= hi) {
return pre.back();
}
return pre[k - lo + 1];
}
long long ret = 0LL;
for (int i = max(l, st); i <= min(r, en); i++) {
k -= aux;
if (dist[i - st] <= k) {
ret += vals[i - st];
ret %= mod;
}
}
return (ret % mod);
}
};
int sz = 300;
int n;
vector<Block> blocks;
void build() {
int point = 0;
while (point < n + 1) {
int en = min(point + sz - 1, n);
blocks.push_back(Block(point, en));
point = en + 1;
}
}
void add(int l, int r, int delta) {
for (int i = 0; i < blocks.size(); i++) {
blocks[i].modify(l, r, delta);
}
}
long long gsum(int l, int r) {
long long ret = 0LL;
for (int i = 0; i < blocks.size(); i++) {
ret += blocks[i].sum(l, r);
}
return ret % mod;
}
void doChange(int ind, long long vv) {
for (int i = 0; i < blocks.size(); i++) {
blocks[i].change(ind, vv);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> kk;
vector<int> list[n];
int a[n + 1];
int bef[n + 1];
int bef2[n + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i]--;
list[a[i]].push_back(i);
int siz = list[a[i]].size();
if (list[a[i]].size() == 1) {
bef[i] = -1;
bef2[i] = -1;
} else if (list[a[i]].size() == 2) {
bef[i] = list[a[i]][siz - 2];
bef2[i] = -1;
} else {
bef[i] = list[a[i]][siz - 2];
bef2[i] = list[a[i]][siz - 3];
}
}
build();
doChange(0, 1LL);
for (int i = 1; i <= n; i++) {
if (bef[i] == -1) {
add(0, i - 1, 1);
} else if (bef2[i] == -1) {
add(0, bef[i] - 1, -1);
add(bef[i], i - 1, 1);
} else {
add(bef2[i], bef[i] - 1, -1);
add(bef[i], i - 1, 1);
}
long long got = gsum(0, i - 1) % mod;
doChange(i, got);
}
cout << blocks.back().vals.back() << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
const int ms = 110000;
const int bs = 1000;
const int MOD = 998244353;
void add(int &a, int b) { a = a + b < MOD ? a + b : a + b - MOD; }
int *pivot;
bool comp(int x1, int x2) { return pivot[x1] < pivot[x2]; }
int tmp[2][bs];
struct Bucket {
Bucket() { dirty = size = 0; }
void push_back(int x) {
p[size] = size;
lazy[size] = 0;
dp[size] = x;
values[size++] = 0;
}
void clean() {
for (int i = size - 2; i >= 0; i--) {
add(lazy[i], lazy[i + 1]);
}
for (int i = 0; i < size; i++) {
add(dp[p[i]], lazy[i]);
lazy[i] = 0;
}
if (dirty) {
for (int i = 0; i < size; i++) {
values[i] += dirty;
}
dirty = 0;
}
}
void sort() {
clean();
pivot = values;
std::sort(p, p + size, comp);
}
int getID(int x) {
if (x < values[p[0]] + dirty) {
return -1;
}
int l = 0, r = size - 1;
while (l != r) {
int mid = (l + r + 1) / 2;
if (values[p[mid]] + dirty <= x) {
l = mid;
} else {
r = mid - 1;
}
}
return l;
}
void upd(int x, int l, int r, int val) {
if (l == 0 && r == size) {
int id = getID(x);
if (id != -1) {
add(lazy[id], val);
}
} else {
for (int i = l; i < r; i++) {
if (values[i] + dirty <= x) {
add(dp[i], val);
} else {
}
}
}
}
void upd2(int l, int r, int val) {
if (l == 0 && r == size) {
dirty += val;
} else {
for (int i = l; i < r; i++) {
values[i] += val;
}
clean();
pivot = values;
int s0 = 0, s1 = 0;
for (int i = 0; i < size; i++) {
if (l <= p[i] && p[i] < r) {
tmp[0][s0++] = p[i];
} else {
tmp[1][s1++] = p[i];
}
}
std::merge(tmp[0], tmp[0] + s0, tmp[1], tmp[1] + s1, p, comp);
}
}
int values[bs], p[bs], lazy[bs], dp[bs];
int dirty;
int size;
};
Bucket b[ms / bs + 2];
std::vector<int> pos[ms];
int a[ms];
int pt[ms];
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int n, k;
std::cin >> n >> k;
for (int i = 1; i <= n; i++) {
pos[i].push_back(-1);
}
for (int i = 0; i < n; i++) {
std::cin >> a[i];
pos[a[i]].push_back(i);
b[i / bs].push_back(i == 0 ? 1 : 0);
}
b[n / bs].push_back(0);
for (int i = 1; i <= n; i++) {
pos[i].push_back(n);
pos[i].push_back(n);
}
auto upd2 = [&](int l, int r, int val) {
if (l >= r) return;
int bl = l / bs, br = (r - 1) / bs;
if (bl == br) {
b[bl].upd2(l - bl * bs, r - bl * bs, val);
return;
}
b[bl].upd2(l - bl * bs, bs, val);
for (int i = bl + 1; i < br; i++) {
b[i].upd2(0, bs, val);
}
b[br].upd2(0, r - br * bs, val);
};
auto upd = [&](int l, int r, int val) {
if (l >= r) return;
int bl = l / bs, br = (r - 1) / bs;
if (bl == br) {
b[bl].upd(k, l - bl * bs, r - bl * bs, val);
return;
}
b[bl].upd(k, l - bl * bs, bs, val);
for (int i = bl + 1; i < br; i++) {
b[i].upd(k, 0, bs, val);
}
b[br].upd(k, 0, r - br * bs, val);
};
for (int i = 1; i <= n; i++) {
upd2(pos[i][1] + 1, pos[i][2] + 1, 1);
}
for (int i = 0; i < n; i++) {
b[i / bs].clean();
int dp = b[i / bs].dp[i % bs];
upd(i + 1, n + 1, dp);
{
int v = a[i];
upd2(pos[v][pt[v] + 1] + 1, pos[v][pt[v] + 2] + 1, -1);
pt[v]++;
upd2(pos[v][pt[v] + 1] + 1, pos[v][pt[v] + 2] + 1, 1);
}
}
b[n / bs].clean();
std::cout << b[n / bs].dp[n % bs] << '\n';
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int magic = 404, mod = 998244353, maxn = 100000;
int n, k, pre[111111], a[111111], cur[111111], dp[111111], b[111111];
int pr[255][222222], d[333];
void add(int &x, int y) {
x += y;
if (x < 0) x += mod;
if (x >= mod) x -= mod;
}
void Add(int l, int r, int R) {
while (r >= l && r / magic == R / magic) {
b[r]++;
r--;
}
if (l > r) return;
int lb = l / magic, rb = r / magic;
if (lb == rb) {
for (int i = l; i <= r; i++) {
add(pr[lb][b[i] + maxn], -dp[i - 1]);
b[i]++;
}
} else {
for (int i = l; i < (lb + 1) * magic; i++) {
add(pr[lb][b[i] + maxn], -dp[i - 1]);
b[i]++;
}
for (int i = rb * magic; i <= r; i++) {
add(pr[rb][b[i] + maxn], -dp[i - 1]);
b[i]++;
}
for (int i = lb + 1; i < rb; i++) {
d[i]++;
}
}
}
void del(int l, int r, int R) {
while (r >= l && r / magic == R / magic) {
b[r]--;
r--;
}
if (l > r) return;
int lb = l / magic, rb = r / magic;
if (lb == rb) {
for (int i = l; i <= r; i++) {
add(pr[lb][b[i] - 1 + maxn], dp[i - 1]);
b[i]--;
}
} else {
for (int i = l; i < (lb + 1) * magic; i++) {
add(pr[lb][b[i] - 1 + maxn], dp[i - 1]);
b[i]--;
}
for (int i = rb * magic; i <= r; i++) {
add(pr[rb][b[i] - 1 + maxn], dp[i - 1]);
b[i]--;
}
for (int i = lb + 1; i < rb; i++) {
d[i]--;
}
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
pre[i] = cur[a[i]];
cur[a[i]] = i;
}
dp[0] = 1;
for (int i = 1; i <= n; i++) {
Add(pre[i] + 1, i, i + 1);
if (pre[i]) del(pre[pre[i]] + 1, pre[i], i + 1);
for (int j = i; j / magic == (i + 1) / magic && j > 0; j--) {
if (b[j] <= k) add(dp[i], dp[j - 1]);
}
for (int j = (i + 1) / magic - 1; j >= 0; j--) {
add(dp[i], pr[j][k - d[j] + maxn]);
}
if ((i + 1) % magic == magic - 1) {
for (int j = i + 1; j / magic == (i + 1) / magic && j > 0; j--) {
add(pr[j / magic][b[j] + maxn], dp[j - 1]);
}
for (int j = 1; j <= n + 2; j++)
add(pr[(i + 1) / magic][j + maxn], pr[(i + 1) / magic][j - 1 + maxn]);
}
}
if (n == 10000 && k == 10000 && dp[n] != 430192466) {
for (int i = 2; i <= n; i++) {
if (dp[i] != dp[i - 1] * 2 % mod) {
cout << i << " " << dp[i] << " " << dp[i - 1] << endl;
}
}
return 0;
}
printf("%d\n", dp[n]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 9, mod = 998244353, maxm = 409;
int n, k, ans;
int a[maxn], cnt[maxn], lst[maxn], fir[maxn], bl[maxm], br[maxm], col[maxn],
v[maxn], lazy[maxm], f[maxn], sum[maxm][maxn];
inline void Fir() {
int size(sqrt(n));
int pieces(ceil(1.0 * n / size));
for (int i = 1; i <= pieces; ++i) {
bl[i] = (i - 1) * size + 1;
br[i] = (i == pieces ? n : i * size);
for (int j = bl[i]; j <= br[i]; ++j) col[j] = i;
}
for (int i = 1; i <= n; ++i) {
lst[i] = fir[a[i]];
fir[a[i]] = i;
}
}
inline void Modify(int l, int r, int val) {
int lt(col[l]), rt(col[r]);
if (lt == rt) {
for (int i = l; i <= r; ++i) {
if (val == 1) {
if (v[i] + lazy[lt] == k) ans = (ans - f[i] + mod) % mod;
} else {
if (v[i] + lazy[lt] == k + 1) ans = (ans + f[i]) % mod;
}
sum[lt][v[i]] = (sum[lt][v[i]] - f[i] + mod) % mod, v[i] += val,
sum[lt][v[i]] = (sum[lt][v[i]] + f[i]) % mod;
}
} else {
for (int i = l; i <= br[lt]; ++i) {
if (val == 1) {
if (v[i] + lazy[lt] == k) ans = (ans - f[i] + mod) % mod;
} else {
if (v[i] + lazy[lt] == k + 1) ans = (ans + f[i]) % mod;
}
sum[lt][v[i]] = (sum[lt][v[i]] - f[i] + mod) % mod, v[i] += val,
sum[lt][v[i]] = (sum[lt][v[i]] + f[i]) % mod;
}
for (int i = bl[rt]; i <= r; ++i) {
if (val == 1) {
if (v[i] + lazy[rt] == k) ans = (ans - f[i] + mod) % mod;
} else {
if (v[i] + lazy[rt] == k + 1) ans = (ans + f[i]) % mod;
}
sum[rt][v[i]] = (sum[rt][v[i]] - f[i] + mod) % mod, v[i] += val,
sum[rt][v[i]] = (sum[rt][v[i]] + f[i]) % mod;
}
for (int i = lt + 1; i <= rt - 1; ++i) {
if (val == 1)
ans = (ans - sum[i][k - lazy[i]] + mod) % mod;
else
ans = (ans + sum[i][k + 1 - lazy[i]]) % mod;
lazy[i] += val;
}
}
}
inline void Update(int x) {
sum[col[x + 1]][v[x + 1]] = (sum[col[x + 1]][v[x + 1]] + f[x + 1]) % mod;
ans = (ans + f[x + 1]) % mod;
}
inline void Solve() {
ans = 1;
f[1] = 1;
sum[1][0] = 1;
for (int i = 1; i <= n; ++i) {
++cnt[a[i]];
int p(lst[i]), q(lst[p]);
if (cnt[a[i]] == 1) {
Modify(1, i, 1);
} else if (cnt[a[i]] == 2) {
Modify(p + 1, i, 1);
Modify(1, p, -1);
} else {
Modify(p + 1, i, 1);
Modify(q + 1, p, -1);
}
f[i + 1] = ans;
Update(i);
}
printf("%d", f[n + 1]);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
Fir();
Solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int BASE = 998244353;
const int SZ = 320;
struct BlockData {
int sumC;
vector<long long> sumF;
BlockData() {}
};
int n, k, c[100100];
long long f[100100];
BlockData blocks[SZ];
long long calc(int i) {
long long res = 0;
int sumC = 0, block = i / SZ;
for (int j = i; j >= block * SZ; j--) {
sumC += c[j];
if (sumC <= k) res += j ? f[j - 1] : 1;
}
for (int j = block - 1; j >= 0; j--) {
int need = k - sumC;
if (need >= -SZ) res += blocks[j].sumF[min(need, SZ) + SZ];
sumC += blocks[j].sumC;
}
return res % BASE;
}
void constructBlock(int block) {
BlockData &data = blocks[block];
data.sumC = 0;
data.sumF = vector<long long>(SZ * 2 + 1, 0);
for (int i = block * SZ + SZ - 1; i >= block * SZ; i--) {
data.sumC += c[i];
data.sumF[data.sumC + SZ] += i ? f[i - 1] : 1;
}
for (int i = 0; i <= SZ * 2; i++) {
if (i) data.sumF[i] += data.sumF[i - 1];
data.sumF[i] %= BASE;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int x;
cin >> n >> k;
vector<int> id[100100];
for (int i = 0; i < n; i++) {
cin >> x;
c[i] = 1;
if (!id[x].empty()) {
int j = id[x].back();
c[j] = -1;
if (id[x].size() >= 2) {
int k = id[x][id[x].size() - 2];
c[k] = 0;
if (k / SZ != j / SZ) constructBlock(k / SZ);
}
if (j / SZ != i / SZ) constructBlock(j / SZ);
}
id[x].push_back(i);
f[i] = calc(i);
if (i % SZ == SZ - 1) constructBlock(i / SZ);
}
cout << f[n - 1] << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int Read() {
int x(0);
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0', c = getchar();
return x;
}
const int maxn = 1e5 + 9, mod = 998244353, maxm = 409;
int n, k, ans;
int a[maxn], cnt[maxn], lst[maxn], fir[maxn], bl[maxm], br[maxm], col[maxn],
v[maxn], lazy[maxm], f[maxn], sum[maxm][maxn];
inline int G(int x) {
while (x > mod) x -= mod;
return x;
}
inline void Fir() {
int size(sqrt(n)), pieces(ceil(1.0 * n / size));
for (int i = 1; i < pieces; ++i) {
bl[i] = (i - 1) * size + 1;
br[i] = i * size;
for (int j = bl[i]; j <= br[i]; ++j) col[j] = i;
}
bl[pieces] = (pieces - 1) * size + 1;
br[pieces] = n;
for (int j = bl[pieces]; j <= br[pieces]; ++j) col[j] = pieces;
for (int i = 1; i <= n; ++i) {
lst[i] = fir[a[i]];
fir[a[i]] = i;
}
}
inline void Modify(int l, int r, int val) {
int lt(col[l]), rt(col[r]);
if (lt == rt) {
for (int i = l; i <= r; ++i) {
if (val == 1) {
if (v[i] + lazy[lt] == k) ans = G(ans - f[i] + mod);
} else {
if (v[i] + lazy[lt] == k + 1) ans = G(ans + f[i]);
}
sum[lt][v[i]] = G(sum[lt][v[i]] - f[i] + mod), v[i] += val,
sum[lt][v[i]] = G(sum[lt][v[i]] + f[i]);
}
} else {
for (int i = l; i <= br[lt]; ++i) {
if (val == 1) {
if (v[i] + lazy[lt] == k) ans = G(ans - f[i] + mod);
} else {
if (v[i] + lazy[lt] == k + 1) ans = G(ans + f[i]);
}
sum[lt][v[i]] = G(sum[lt][v[i]] - f[i] + mod), v[i] += val,
sum[lt][v[i]] = G(sum[lt][v[i]] + f[i]);
}
for (int i = bl[rt]; i <= r; ++i) {
if (val == 1) {
if (v[i] + lazy[rt] == k) ans = G(ans - f[i] + mod);
} else {
if (v[i] + lazy[rt] == k + 1) ans = G(ans + f[i]);
}
sum[rt][v[i]] = G(sum[rt][v[i]] - f[i] + mod), v[i] += val,
sum[rt][v[i]] = G(sum[rt][v[i]] + f[i]);
}
for (int i = lt + 1; i <= rt - 1; ++i) {
if (val == 1)
ans = G(ans - sum[i][k - lazy[i]] + mod);
else
ans = G(ans + sum[i][k + 1 - lazy[i]]);
lazy[i] += val;
}
}
}
inline void Update(int x) {
sum[col[x + 1]][v[x + 1]] = G(sum[col[x + 1]][v[x + 1]] + f[x + 1]);
ans = G(ans + f[x + 1]);
}
inline void Solve() {
ans = f[1] = sum[1][0] = 1;
for (int i = 1; i <= n; ++i) {
++cnt[a[i]];
int p(lst[i]), q(lst[p]);
if (cnt[a[i]] == 1)
Modify(1, i, 1);
else if (cnt[a[i]] == 2) {
Modify(p + 1, i, 1);
Modify(1, p, -1);
} else {
Modify(p + 1, i, 1);
Modify(q + 1, p, -1);
}
f[i + 1] = ans;
Update(i);
}
printf("%d", f[n + 1]);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
Fir();
Solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 119 << 23 | 1;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int)1e9 + 23111992;
const long long LINF = (long long)1e18 + 23111992;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline unsigned long long isqrt(unsigned long long k) {
unsigned long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int myrand() { return abs((int)mt()); }
const int maxn = 1e5 + 5;
const int magic = 500;
int n, k;
int a[maxn];
int nxt[maxn];
int off[magic];
int c[maxn];
int f[magic][maxn];
int dp[maxn];
int sum;
void inc(int d) {
if (0 <= k - off[d] && k - off[d] < maxn) {
submod(sum, f[d][k - off[d]]);
}
off[d]++;
}
void dec(int d) {
off[d]--;
if (0 <= k - off[d] && k - off[d] < maxn) {
addmod(sum, f[d][k - off[d]]);
}
}
void upd(int d, int l, int r, int val) {
for (int i = d * magic; i < (d + 1) * magic && i < n; i++) {
if (c[i] + off[d] <= k) {
submod(sum, f[d][c[i]]);
}
f[d][c[i]] = 0;
c[i] += off[d];
}
off[d] = 0;
for (int i = l; i <= r; i++) {
c[i] += val;
}
for (int i = d * magic; i < (d + 1) * magic && i < n; i++) {
addmod(f[d][c[i]], dp[i + 1]);
if (c[i] <= k) {
addmod(sum, dp[i + 1]);
}
}
}
void upd(int l, int r, int val) {
int il = (l + magic - 1) / magic;
int ir = r / magic;
for (int i = (il); i < (ir); ++i) {
if (val == 1) {
inc(i);
} else {
dec(i);
}
}
if (l < il * magic) {
upd(il - 1, l, min(il * magic - 1, r), val);
}
if (il <= ir && ir * magic <= r) {
upd(ir, max(l, ir * magic), r, val);
}
}
void chemthan() {
cin >> n >> k;
for (int i = (0); i < (n); ++i) cin >> a[i];
dp[n] = 1;
vector<int> lst(n + 1, n);
fill_n(nxt, n + 1, n);
for (int i = (n)-1; i >= (0); --i) {
addmod(sum, dp[i + 1]);
addmod(f[i / magic][0], dp[i + 1]);
nxt[i] = lst[a[i]];
if (nxt[i] == n) {
upd(i, nxt[i] - 1, 1);
} else {
int ni = nxt[i];
upd(ni, nxt[ni] - 1, -1);
upd(i, ni - 1, 1);
}
dp[i] = sum;
lst[a[i]] = i;
}
cout << dp[0] << "\n";
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
if (argc > 1) {
assert(freopen(argv[1], "r", stdin));
}
if (argc > 2) {
assert(freopen(argv[2], "wb", stdout));
}
chemthan();
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int P = 998244353;
const int N = 101000, B = 340;
int n, b, c, kk;
int a[N], ans[N], lst[N], prv[N], tag[N];
void add(int& x, int y) {
if ((x += y) >= P) x -= P;
}
struct Block {
int ptr, ans;
int v[N];
void set(int j) {
if (tag[j] <= ptr) add(ans, ::ans[j]);
add(v[tag[j]], ::ans[j]);
}
void mv(int x) {
if (x == 1) {
++ptr;
if (ptr >= 0) add(ans, v[ptr]);
} else {
if (ptr >= 0) add(ans, P - v[ptr]);
--ptr;
}
}
} sum[B];
void ch(int l, int v) {
int f = l / b;
for (int i = f + 1; i < c; ++i) sum[i].mv(-v);
int lz = kk - sum[f].ptr;
sum[f].ptr = kk;
sum[f].ans = 0;
for (int j = f * b; j < (f + 1) * b; ++j) sum[f].v[tag[j]] = 0;
for (int j = f * b; j < (f + 1) * b; ++j) {
tag[j] += lz;
if (j >= l) tag[j] += v;
sum[f].set(j);
}
}
int qry() {
int ret = 0;
for (int i = 0; i < c; ++i) add(ret, sum[i].ans);
return ret;
}
int main() {
int k;
scanf("%d%d", &n, &k);
kk = k;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
b = sqrt(n);
c = n / b + 1;
ans[0] = 1;
for (int i = 0; i < c; ++i) sum[i].ptr = k;
sum[0].set(0);
for (int i = 1; i <= n; ++i) {
int cur = lst[a[i]];
lst[a[i]] = i;
prv[i] = cur;
if (cur) {
ch(cur, 1);
ch(prv[cur], -1);
}
ch(cur, 1);
ch(i, -1);
ans[i] = qry();
sum[i / b].set(i);
}
printf("%d\n", ans[n]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
void add(int &a, int b) {
a += b;
if (a >= MOD) {
a -= MOD;
}
if (a < 0) {
a += MOD;
}
}
struct FenwickTree {
int dat[100055];
FenwickTree() { memset(dat, 0, sizeof(dat)); }
void add(int id, int val) {
while (id <= (int)1e5) {
::add(dat[id], val);
id |= (id + 1);
}
}
int get(int id) {
int res = 0;
while (id >= 0) {
::add(res, dat[id]);
id = (id & (id + 1)) - 1;
}
return res;
}
};
const int B = 317;
int n, k;
int a[100055];
FenwickTree dat[B];
int dp[100055];
vector<int> occ[100055];
int offset[B];
int cnt[100055];
void change(int l, int r, int val) {
if (l / B == r / B) {
for (int i = l; i <= r; i++) {
dat[i / B].add(cnt[i], -dp[i]);
cnt[i] += val;
dat[i / B].add(cnt[i], +dp[i]);
}
return;
}
while (l % B != 0) {
dat[l / B].add(cnt[l], -dp[l]);
cnt[l] += val;
dat[l / B].add(cnt[l], +dp[l]);
l++;
}
while (r % B != B - 1) {
dat[r / B].add(cnt[r], -dp[r]);
cnt[r] += val;
dat[r / B].add(cnt[r], +dp[r]);
r--;
}
while (l <= r) {
offset[l / B] += val;
l += B;
}
}
int query() {
int res = 0;
for (int i = 0; i < B; i++) {
int ub = k - offset[i];
add(res, dat[i].get(ub));
}
return res;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i <= n; i++) {
occ[i].push_back(0);
}
dat[0].add(0, 1);
dp[0] = 1;
for (int i = 1; i <= n; i++) {
if (occ[a[i]].size() > 1) {
change(occ[a[i]].end()[-2], occ[a[i]].back() - 1, -1);
}
occ[a[i]].push_back(i);
change(occ[a[i]].end()[-2], occ[a[i]].back() - 1, 1);
dp[i] = query();
dat[i / B].add(0, dp[i]);
}
cout << dp[n];
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, unit, tot;
int be[(100005)], st[(100005)], en[(100005)], a[(100005)], sum[2055][2055],
f[(100005)], pre[(100005)], now[(100005)], lazy[(100005)], S[(100005)];
const int P = 998244353;
template <typename T>
void read(T& t) {
t = 0;
bool fl = true;
char p = getchar();
while (!isdigit(p)) {
if (p == '-') fl = false;
p = getchar();
}
do {
(t *= 10) += p - 48;
p = getchar();
} while (isdigit(p));
if (!fl) t = -t;
}
inline int Inc(int a, int b) { return (a + b >= P) ? (a + b - P) : (a + b); }
void reset(int u) {
for (int i = st[u]; i <= en[u]; i++) S[i] += lazy[u];
lazy[u] = 0;
int minn = S[st[u]];
for (int i = st[u]; i <= en[u]; i++) minn = min(minn, S[i]);
for (int i = st[u]; i <= en[u]; i++) S[i] -= minn;
memset(sum[u], 0, sizeof(sum[u]));
for (int i = st[u]; i <= en[u]; i++) sum[u][S[i]] = Inc(sum[u][S[i]], f[i]);
for (int i = unit - 1; i >= 0; i--) sum[u][i] = Inc(sum[u][i], sum[u][i + 1]);
lazy[u] = minn;
}
void change(int L, int R, int data) {
if (be[L] == be[R]) {
for (int i = L; i <= R; i++) S[i] += data;
reset(be[L]);
} else {
for (int i = be[L] + 1; i <= be[R] - 1; i++) lazy[i] += data;
for (int i = L; i <= en[be[L]]; i++) S[i] += data;
reset(be[L]);
for (int i = st[be[R]]; i <= R; i++) S[i] += data;
reset(be[R]);
}
}
int query(int R, int lim) {
if (R == 0) return 0;
int ret = 0;
for (int i = 1; i < be[R]; i++) {
if (lim - lazy[i] > unit) continue;
ret = Inc(ret, sum[i][max(lim - lazy[i], 0)]);
}
for (int i = st[be[R]]; i <= R; i++) {
if (S[i] + lazy[be[i]] >= lim) ret = Inc(ret, f[i]);
}
return ret;
}
int main() {
read(n), read(k);
unit = sqrt(n);
for (int i = 1; i <= n; i++) {
read(a[i]);
pre[i] = now[a[i]];
now[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
be[i] = (i - 1) / unit + 1;
if (be[i] != be[i - 1]) {
en[be[i - 1]] = i - 1;
st[be[i]] = i;
}
}
tot = be[n];
en[tot] = n;
f[0] = 1;
S[0] = 0;
for (int i = 1; i <= n; i++) {
if (be[i - 1] != be[i])
S[i] = S[i - 1] + 1 + lazy[be[i - 1]];
else
S[i] = S[i - 1] + 1;
if (pre[pre[i]]) change(pre[pre[i]], i, 1);
if (pre[i]) change(pre[i], i, -2);
f[i] = query(i - 1, S[i] + lazy[be[i]] - k);
if (S[i] + lazy[be[i]] <= k) f[i]++;
if (i == en[be[i]]) reset(be[i]);
}
printf("%d", f[n]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,popcnt,abm,mmx,tune=native")
#pragma GCC optimize("fast-math")
using namespace std;
long long MOD = 998244353;
long long ans[100007];
int a[100007], b[100007], t[100007];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
ans[0] = 1;
long long sum = 0;
for (int i = 0; i < n; i++) {
int u;
cin >> u;
u--;
sum += ans[i];
if (a[u] == 0) {
for (int j = i; j >= 0; j--) {
t[j]++;
if (t[j] == k + 1) sum -= ans[j];
}
} else if (b[u] == 0) {
for (int j = a[u] - 1; j >= 0; j--) {
t[j]--;
if (t[j] == k) sum += ans[j];
}
for (int j = i; j >= a[u]; j--) {
t[j]++;
if (t[j] == k + 1) sum -= ans[j];
}
b[u] = a[u];
} else {
for (int j = a[u] - 1; j >= b[u]; j--) {
t[j]--;
if (t[j] == k) sum += ans[j];
}
for (int j = i; j >= a[u]; j--) {
t[j]++;
if (t[j] == k + 1) sum -= ans[j];
}
b[u] = a[u];
}
a[u] = i + 1;
ans[i + 1] = sum % MOD;
if (ans[i + 1] < 0) ans[i + 1] += MOD;
}
cout << ans[n];
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class X, class Y>
void amax(X &x, const Y &y) {
if (x < y) x = y;
}
template <class X, class Y>
void amin(X &x, const Y &y) {
if (x > y) x = y;
}
const int INF = 1e9 + 10;
const long long INFL = (long long)1e18 + 10;
const int MAX = 1e5 + 10;
const int MAXS = 320;
const int MOD = 998244353;
int n, k, sn;
int a[MAX], prv[MAX], last[MAX], dp[MAX], q[MAXS][2 * MAXS];
int c[MAX], sc[MAXS];
int gb(int i) { return (i - 1) / sn + 1; }
int bl(int i) {
if (i <= n / sn) return sn;
return n - (n / sn) * sn;
}
pair<int, int> itv(int i) {
return make_pair((i - 1) * sn + 1, min(i * sn, n));
}
int add(int a, int b) { return (a + b) % MOD; }
int gq(int i, int j) { return q[i][j + MAXS]; }
void uq(int i, int j, int v) { q[i][j + MAXS] = add(q[i][j + MAXS], v); }
void calcq(int i) {
memset(q[i], 0, 2 * MAXS * sizeof(q[i][0]));
int l = itv(i).first, r = itv(i).second;
int t = 0;
for (int j = r; j >= l; j--) {
t += c[j];
uq(i, t, dp[j - 1]);
}
for (int j = -bl(i) + 1; j <= bl(i); j++) uq(i, j, gq(i, j - 1));
sc[i] = t;
}
void process() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sn = max((int)sqrt(n), 1);
for (int i = 1; i <= n; i++) {
prv[i] = last[a[i]];
last[a[i]] = i;
}
dp[0] = 1;
for (int i = 1; i <= n; i++) {
if (i > 0 && gb(i) > gb(i - 1)) calcq(gb(i - 1));
if (prv[prv[i]] != 0) {
c[prv[prv[i]]] = 0;
if (gb(prv[prv[i]]) < gb(i)) calcq(gb(prv[prv[i]]));
}
if (prv[i] != 0) {
c[prv[i]] = -1;
if (gb(prv[i]) < gb(i)) calcq(gb(prv[i]));
}
c[i] = 1;
int l = itv(gb(i)).first;
int t = 0;
for (int j = i; j >= l; j--) {
t += c[j];
if (t <= k) dp[i] = add(dp[i], dp[j - 1]);
}
int x = k - t;
for (int j = gb(i) - 1; j >= 1; j--) {
if (x >= -bl(j)) {
if (x <= bl(j))
dp[i] = add(dp[i], gq(j, x));
else
dp[i] = add(dp[i], gq(j, bl(j)));
}
x -= sc[j];
}
}
cout << dp[n];
}
int main() {
ios_base::sync_with_stdio(false);
process();
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5, B = 350, Mod = 998244353;
int n, lim, siz, block_cnt, cnt[maxn], a[maxn], b[maxn], sum_b[1005],
sum_f[1005][1005], f[maxn];
vector<int> pos[maxn];
void cal(int w) {
memset(sum_f[w], 0, sizeof sum_f[w]);
int tmp = 0;
for (int i = w * siz; i > w * siz - siz; i--)
tmp += b[i], sum_f[w][tmp + B] = (sum_f[w][tmp + B] + f[i - 1]) % Mod;
for (int i = -siz + 1; i <= siz; i++)
sum_f[w][i + B] = (sum_f[w][i + B] + sum_f[w][i - 1 + B]) % Mod;
sum_b[w] = tmp;
}
int main() {
f[0] = 1;
cin >> n >> lim;
for (int i = 1; i <= n; i++) cin >> a[i], pos[a[i]].push_back(i);
siz = sqrt(n);
block_cnt = (n - 1) / siz + 1;
for (int i = 1; i <= block_cnt; i++) {
for (int j = i * siz - siz + 1; j <= min(i * siz, n); j++) {
if (cnt[a[j]] == 1) {
int p = pos[a[j]][cnt[a[j]] - 1];
b[p] = -1;
if (p <= i * siz - siz) cal((p - 1) / siz + 1);
} else if (cnt[a[j]] > 1) {
int p1 = pos[a[j]][cnt[a[j]] - 2], p2 = pos[a[j]][cnt[a[j]] - 1];
b[p1] = 0;
b[p2] = -1;
if (p1 <= i * siz - siz) cal((p1 - 1) / siz + 1);
if (p2 <= i * siz - siz) cal((p2 - 1) / siz + 1);
}
b[j] = 1;
cnt[a[j]]++;
int tmp = 0;
for (int k = j; k > i * siz - siz; k--) {
tmp += b[k];
if (tmp <= lim) f[j] = (f[j] + f[k - 1]) % Mod;
}
for (int k = i - 1; k; k--) {
if (lim - tmp >= -siz)
f[j] = (f[j] + sum_f[k][min(lim - tmp, siz) + B]) % Mod;
tmp += sum_b[k];
}
}
if (i < block_cnt) cal(i);
}
cout << f[n] << '\n';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long a, long long b,
long long mod = (long long)(1e9 + 7)) {
if (!b) return 1;
a %= mod;
return modpow(a * a % mod, b / 2, mod) * (b & 1 ? a : 1) % mod;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int mxn = 2e5, mod = 998244353;
const int B = 300;
int n, k;
int a[mxn], dp[mxn], values[mxn];
vector<int> oc[mxn];
void init() {
for (int i = 0; i < mxn; i++) dp[i] = values[i] = 0;
for (int i = 0; i < mxn; i++) oc[i].push_back(-1);
}
void add(int &a, int b) { a = a + b >= mod ? a + b - mod : a + b; }
int id(int i) { return i / B; }
struct Bucket {
int prefix[B];
int offset;
Bucket() {
for (int i = 0; i < B; i++) prefix[i] = 0;
offset = 0;
}
void rebuild(int id) {
int newoffset = mod;
int f = id * B, s = (id + 1) * B - 1;
for (int i = f; i <= s; i++)
(newoffset) = min((newoffset), (values[i] + offset));
for (int i = f; i <= s; i++) values[i] += offset - newoffset;
offset = newoffset;
for (int i = 0; i < B; i++) prefix[i] = 0;
for (int i = f; i <= s; i++) add(prefix[values[i]], dp[i]);
for (int i = 0; i < B; i++)
if (i) add(prefix[i], prefix[i - 1]);
}
} b[mxn / B + 1];
void add(int i, int j, int x) {
for (int k = i; k <= j && id(k) == id(i); k++) values[k] += x;
b[id(i)].rebuild(id(i));
if (id(i) == id(j)) return;
for (int k = id(i) + 1; k < id(j); k++) b[k].offset += x;
for (int k = j; k >= 0 && id(k) == id(j); k--) values[k] += x;
b[id(j)].rebuild(id(j));
}
void solve() {
scanf("%d", &n);
scanf("%d", &k);
init();
dp[0] = 1;
b[id(0)].rebuild(id(0));
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i]--;
if (oc[a[i]].size() >= 2)
add(oc[a[i]].end()[-2] + 1, oc[a[i]].end()[-1], -1);
add(oc[a[i]].end()[-1] + 1, i, 1);
dp[i + 1] = 0;
for (int j = 0; j <= id(i); j++) {
int x = k - b[j].offset;
if (x >= 0) add(dp[i + 1], b[j].prefix[min(x, B - 1)]);
}
b[id(i + 1)].rebuild(id(i + 1));
oc[a[i]].push_back(i);
}
cout << dp[n] << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 998244353;
int add(int a, int b) { return a + b >= Mod ? a + b - Mod : a + b; }
void Add(int &a, int b) { a = add(a, b); }
int dec(int a, int b) { return a - b < 0 ? a - b + Mod : a - b; }
void Dec(int &a, int b) { a = dec(a, b); }
const int N = 1e5 + 50, M = 300, A = 1e5;
int n, k, S, ct, a[N], pre[N], blk[N], dp[N];
int b[N], t[M], bin[M][N + A], sm[M], L[N], R[N];
void ins(int u, int vl) {
int p = blk[u];
Add(sm[p], vl);
Add(bin[p][b[u] - t[p] + A], vl);
}
void mdf(int i, int lp, int v) {
if (b[i] + t[lp] <= k) Dec(sm[lp], dp[i - 1]);
Dec(bin[lp][b[i] + A], dp[i - 1]);
b[i] += v;
if (b[i] + t[lp] <= k) Add(sm[lp], dp[i - 1]);
Add(bin[lp][b[i] + A], dp[i - 1]);
}
void add(int l, int r, int v) {
if (l > r) return;
int lp = blk[l], rp = blk[r];
if (blk[l] == blk[r]) {
for (int i = l; i <= r; i++) mdf(i, lp, v);
return;
}
for (int i = l; i <= R[lp]; i++) mdf(i, lp, v);
for (int i = L[rp]; i <= r; i++) mdf(i, rp, v);
for (int i = lp + 1; i < rp; i++) {
if (v > 0)
Dec(sm[i], bin[i][k - t[i] + A]);
else
Add(sm[i], bin[i][k - t[i] + 1 + A]);
t[i] += v;
}
}
int qry(int p) {
int ans = 0, c = 0;
for (; c <= ct && R[c] <= p; c++) Add(ans, sm[c]);
if (c > ct) return ans;
for (int i = L[c]; i <= p; i++)
if (b[i] + t[c] <= k) Add(ans, dp[i - 1]);
return ans;
}
int main() {
scanf("%d%d", &n, &k);
S = 350;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
static int ls[N];
for (int i = 1; i <= n; i++) pre[i] = ls[a[i]], ls[a[i]] = i;
for (int i = 1; i <= n; i++) blk[i] = (i - 1) / S + 1;
for (int i = 1; i <= n; i += S) L[++ct] = i, R[ct] = i + S - 1;
R[ct] = n;
dp[0] = 1;
for (int i = 1; i <= n; i++) {
ins(i, dp[i - 1]);
add(pre[i] + 1, i, 1);
add(pre[pre[i]] + 1, pre[i], -1);
dp[i] = qry(i);
}
cout << dp[n];
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2e5 + 5;
const int M = 505;
const ll mod = 998244353;
ll add(ll a, ll b) { return (a + b >= mod ? a + b - mod : a + b); }
ll sub(ll a, ll b) { return (a - b < 0 ? a - b + mod : a - b); }
ll mul(ll a, ll b) { return (a * b) % mod; }
int n, k;
int a[N];
int last[N], preLast[N];
ll dp[N];
int inDex[N], head[M];
int magic;
struct block {
int sz;
int Min, Max;
int lazy;
int bad[M];
ll val[M], sum[M];
void init(int n) {
sz = n;
Min = Max = 0;
for (int i = 0; i <= sz; i++) {
val[i] = bad[i] = sum[i] = 0;
}
}
void updAll(int x) {
lazy += x;
Min += x;
Max += x;
}
void upd(int l, int r, int x) {
for (int i = 0; i < sz; i++) bad[i] += lazy;
for (int i = l; i <= r; i++) bad[i] += x;
lazy = 0;
Min = 1e9;
Max = -1e9;
for (int i = 0; i < sz; i++) {
Min = min(Min, bad[i]);
Max = max(Max, bad[i]);
}
for (int i = 0; i <= Max - Min; i++) sum[i] = 0;
for (int i = 0; i < sz; i++) {
sum[bad[i] - Min] = add(sum[bad[i] - Min], val[i]);
}
for (int i = 1; i <= Max - Min; i++) {
sum[i] = add(sum[i], sum[i - 1]);
}
}
void active(int id, ll x) {
val[id] = x;
for (int i = bad[id] - Min; i <= Max - Min; i++) {
sum[i] = add(sum[i], x);
}
}
ll get(int x) {
if (Min > x) return 0;
if (Max < x) return sum[Max - Min];
return sum[x - Min];
}
} block[M];
void update(int l, int r, ll x) {
int L = inDex[l], R = inDex[r];
if (L == R) {
block[L].upd(l - head[L], r - head[L], x);
return;
}
block[L].upd(l - head[L], head[L + 1] - head[L] - 1, x);
block[R].upd(0, r - head[R], x);
for (int i = L + 1; i < R; i++) {
block[i].updAll(x);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
preLast[i] = -1;
}
magic = sqrt(n);
int now = 1, cnt = 0;
for (int i = 1; i <= n; i++) {
if (head[now] == 0) head[now] = i;
inDex[i] = now;
cnt++;
if (cnt == magic || i == n) {
block[now].init(i - head[now] + 1);
now++;
cnt = 0;
}
}
head[now] = n + 1;
dp[0] = 1;
for (int i = 1; i <= n; i++) {
update(last[a[i]] + 1, i, 1);
if (preLast[a[i]] != -1) {
update(preLast[a[i]] + 1, last[a[i]], -1);
}
preLast[a[i]] = last[a[i]];
last[a[i]] = i;
block[inDex[i]].active(i - head[inDex[i]], dp[i - 1]);
for (int j = 1; j <= inDex[i]; j++) {
dp[i] = add(dp[i], block[j].get(k));
}
}
cout << dp[n];
}
| 10 | CPP |
#include <bits/stdc++.h>
const int N = 100005, B = 320, M = 998244353;
using namespace std;
int n, k, ti, a[N], occ[N], pre[N], b[N], f[N], sum[B], q[B][B << 1 | 1], now;
inline void mdf(int x, int y) {
b[x] = y;
int z = x / B;
if (z == now) return;
sum[z] = 0;
for (int i = 0; i <= B << 1; i++) q[z][i] = 0;
for (int i = z * B + B - 1; i >= z * B; i--)
sum[z] += b[i], (q[z][sum[z] + B] += f[i]) %= M;
for (int i = 0; i < B << 1; i++) (q[z][i + 1] += q[z][i]) %= M;
}
int main() {
scanf("%d%d", &n, &k);
memset(occ, -1, N << 2);
for (int i = 0; i < n; i++)
scanf("%d", a + i), pre[i] = occ[a[i]], occ[a[i]] = i;
f[0] = 1;
for (int i = 0; i < n; i++) {
now = (i + 1) / B, mdf(i, 1);
if (~pre[i]) {
mdf(pre[i], -1);
if (~pre[pre[i]]) mdf(pre[pre[i]], 0);
}
ti = 0;
for (int j = i; j / B == now && ~j; j--) {
ti += b[j];
if (ti <= k) (f[i + 1] += f[j]) %= M;
}
for (int j = now - 1; ~j; j--) {
if (ti <= k + B) (f[i + 1] += q[j][min(B << 1, k + B - ti)]) %= M;
ti += sum[j];
}
}
printf("%d", f[n]);
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int block = 320, nax = 100005, mod = 998244353;
inline int add(int x, int y) { return (x += y) < mod ? x : x - mod; }
inline int sub(int x, int y) { return (x -= y) >= 0 ? x : x + mod; }
int b[block], q[block][block << 1 | 1], n, k, d[nax], dp[nax], a[nax], lst[nax],
lst2[nax];
void add(int pos) {
int id = (pos - 1) / block;
for (int i = block; i <= 2 * block; ++i)
q[id][i] = add(q[id][i], dp[pos - 1]);
}
void upd(int pos, int sgn) {
int id = (pos - 1) / block;
b[id] += sgn;
for (int i = pos; i > id * block; --i) {
if (sgn == 1) q[id][d[i] + block] = sub(q[id][d[i] + block], dp[i - 1]);
d[i] += sgn;
if (sgn == -2)
q[id][d[i] + block] = add(q[id][d[i] + block], dp[i - 1]),
q[id][d[i] + block + 1] =
add(q[id][d[i] + block + 1], dp[i - 1]);
}
}
int get(int pos) {
int ret = 0, id = (pos - 1) / block, sum = b[id];
for (int i = pos; i > id * block; --i)
if (d[i] <= k) ret = add(ret, dp[i - 1]);
while (--id >= 0) {
if (abs(sum - k) <= block)
ret = add(ret, q[id][k - sum + block]);
else if (sum < k)
ret = add(ret, q[id][block << 1]);
sum += b[id];
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
dp[0] = 1;
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i], add(i), upd(i, 1);
if (lst[a[i]]) upd(lst[a[i]], -2);
if (lst2[a[i]]) upd(lst2[a[i]], 1);
dp[i] = get(i), lst2[a[i]] = lst[a[i]], lst[a[i]] = i;
}
cout << dp[n] << '\n';
}
| 10 | CPP |
#include <bits/stdc++.h>
const int N = 1e5 + 5, M = N / 160 + 3;
int bel[N], f[N], g[N], tag[M], s[M][160 + 3 << 1];
inline int read() {
int now = 0;
register char c = getchar();
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); now = now * 10 + c - 48, c = getchar())
;
return now;
}
void Update(int p, int v) {
int *s = ::s[bel[p]];
for (int i = 160; i <= 160 << 1; ++i)
(s[i] += v) >= 998244353 && (s[i] -= 998244353);
}
void Modify(int p, int v) {
int bel = ::bel[p], *s = ::s[bel];
tag[bel] += v;
for (int i = bel * 160 + 1; i <= p; ++i) {
if (v == 1)
(s[g[i] + 160] += 998244353 - f[i - 1]) >= 998244353 &&
(s[g[i] + 160] -= 998244353);
else
(s[g[i] - 1 + 160] += f[i - 1]) >= 998244353 &&
(s[g[i] - 1 + 160] -= 998244353),
(s[g[i] - 2 + 160] += f[i - 1]) >= 998244353 &&
(s[g[i] - 2 + 160] -= 998244353);
g[i] += v;
}
}
int Query(int p, int K) {
int bel = ::bel[p], sum = tag[bel];
long long res = 0;
for (int i = bel * 160 + 1; i <= p; ++i) g[i] <= K && (res += f[i - 1]);
while (bel--) {
if (std::abs(sum - K) <= 160)
res += s[bel][K - sum + 160];
else if (sum < K)
res += s[bel][160 << 1];
sum += tag[bel];
}
return res % 998244353;
}
int main() {
static int las[N], pre[N];
int n = read(), K = read();
for (int i = 1; i <= n; ++i) bel[i] = (i - 1) / 160;
f[0] = 1;
for (int i = 1; i <= n; ++i) {
int a = read();
las[i] = pre[a], pre[a] = i;
Update(i, f[i - 1]), Modify(i, 1);
if (las[i]) {
Modify(las[i], -2);
if (las[las[i]]) Modify(las[las[i]], 1);
}
f[i] = Query(i, K);
}
printf("%d\n", f[n]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 998244353;
long long mpow(long long a, long long b) {
if (b == 0) return 1;
long long t1 = mpow(a, b / 2);
t1 *= t1;
t1 %= MOD;
if (b % 2) t1 *= a;
t1 %= MOD;
return t1;
}
const long long N = 1e5 + 5;
const long long block = 320;
vector<long long> mcount(N, 0);
vector<long long> offset(block, 0);
vector<long long> mprev(N, 0), dp(N, 0);
vector<long long> recent(N, 0);
long long n, k;
long long ans;
vector<vector<long long> > sum(block, vector<long long>(N, 0));
void update(long long st, long long la, long long val) {
if (st <= 0 || la <= 0) return;
for (long long i = 0; i < block; i++) {
long long stb = i * block + 1, lab = (i + 1) * block;
if (stb > la || lab < st)
continue;
else if (stb >= st && la >= lab) {
if (val == 1 && k - offset[i] >= 0)
ans -= sum[i][k - offset[i]];
else if (val == -1 && k + 1 - offset[i] >= 0)
ans += sum[i][k + 1 - offset[i]];
ans = (ans + MOD) % MOD;
offset[i] += val;
} else {
for (long long j = stb; j < lab + 1; j++) {
if (j < st || j > la) continue;
if (val == 1 && offset[i] + mcount[j] == k) {
ans -= dp[j - 1];
} else if (val == -1 && offset[i] + mcount[j] == k + 1)
ans += dp[j - 1];
ans = (ans + MOD) % MOD;
sum[i][mcount[j]] -= dp[j - 1] - MOD;
sum[i][mcount[j]] %= MOD;
mcount[j] += val;
sum[i][mcount[j]] += dp[j - 1];
sum[i][mcount[j]] %= MOD;
}
}
}
}
void solve() {
cin >> n >> k;
dp[0] = 1;
for (long long i = 1; i < n + 1; i++) {
long long a;
cin >> a;
ans += dp[i - 1];
ans %= MOD;
sum[(i - 1) / block][0] += dp[i - 1];
sum[(i - 1) / block][0] %= MOD;
mprev[i] = recent[a];
update(mprev[i] + 1, i, 1);
update(mprev[mprev[i]] + 1, mprev[i], -1);
recent[a] = i;
dp[i] = ans;
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
for (long long i = 0; i < t; i++) {
solve();
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int Read() {
int x(0);
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0', c = getchar();
return x;
}
const int maxn = 1e5 + 9, mod = 998244353, maxm = 409;
int n, k, ans;
int a[maxn], cnt[maxn], lst[maxn], fir[maxn], bl[maxm], br[maxm], col[maxn],
v[maxn], lazy[maxm], f[maxn], sum[maxm][maxn];
inline int G(int x) {
while (x > mod) x -= mod;
return x;
}
inline void Fir() {
int size(sqrt(n)), pieces(ceil(1.0 * n / size));
for (int i = 1; i < pieces; ++i) {
bl[i] = (i - 1) * size + 1;
br[i] = i * size;
for (int j = bl[i]; j <= br[i]; ++j) col[j] = i;
}
bl[pieces] = (pieces - 1) * size + 1;
br[pieces] = n;
for (int j = bl[pieces]; j <= br[pieces]; ++j) col[j] = pieces;
for (int i = 1; i <= n; ++i) {
lst[i] = fir[a[i]];
fir[a[i]] = i;
}
}
inline void Modify(int l, int r, int val) {
int lt(col[l]), rt(col[r]);
if (lt == rt) {
for (int i = l; i <= r; ++i) {
if (val == 1) {
if (v[i] + lazy[lt] == k) ans = G(ans - f[i] + mod);
} else {
if (v[i] + lazy[lt] == k + 1) ans = G(ans + f[i]);
}
sum[lt][v[i]] = G(sum[lt][v[i]] - f[i] + mod), v[i] += val,
sum[lt][v[i]] = G(sum[lt][v[i]] + f[i]);
}
} else {
for (int i = l; i <= br[lt]; ++i) {
if (val == 1) {
if (v[i] + lazy[lt] == k) ans = G(ans - f[i] + mod);
} else {
if (v[i] + lazy[lt] == k + 1) ans = G(ans + f[i]);
}
sum[lt][v[i]] = G(sum[lt][v[i]] - f[i] + mod), v[i] += val,
sum[lt][v[i]] = G(sum[lt][v[i]] + f[i]);
}
for (int i = bl[rt]; i <= r; ++i) {
if (val == 1) {
if (v[i] + lazy[rt] == k) ans = G(ans - f[i] + mod);
} else {
if (v[i] + lazy[rt] == k + 1) ans = G(ans + f[i]);
}
sum[rt][v[i]] = G(sum[rt][v[i]] - f[i] + mod), v[i] += val,
sum[rt][v[i]] = G(sum[rt][v[i]] + f[i]);
}
for (int i = lt + 1; i <= rt - 1; ++i) {
if (val == 1)
ans = G(ans - sum[i][k - lazy[i]] + mod);
else
ans = G(ans + sum[i][k + 1 - lazy[i]]);
lazy[i] += val;
}
}
}
inline void Solve() {
ans = f[1] = sum[1][0] = 1;
for (int i = 1; i <= n; ++i) {
++cnt[a[i]];
int p(lst[i]), q(lst[p]);
if (cnt[a[i]] == 1)
Modify(1, i, 1);
else if (cnt[a[i]] == 2) {
Modify(p + 1, i, 1);
Modify(1, p, -1);
} else {
Modify(p + 1, i, 1);
Modify(q + 1, p, -1);
}
f[i + 1] = ans;
sum[col[i + 1]][v[i + 1]] = G(sum[col[i + 1]][v[i + 1]] + f[i + 1]);
ans = G(ans + f[i + 1]);
}
printf("%d", f[n + 1]);
}
int main() {
n = Read();
k = Read();
for (int i = 1; i <= n; ++i) a[i] = Read();
Fir();
Solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int P = 998244353;
int n, k;
inline int ad(int& x, int& y) { return (x + y > P ? x + y - P : x + y); }
int A[200006], las[200006], pr[200006];
const int blo = 133;
int bel[200006];
pair<int, int> B[200006];
int S[200006];
int val[200006], gv[200006], lz[200006], cur;
void rebuild(int b) {
int l = b * blo - blo + 1, r = b * blo;
for (int i = (l), iend = (r); i <= iend; ++i) val[i] = val[i] + lz[b];
lz[b] = 0;
for (int i = (l), iend = (r); i <= iend; ++i) B[i] = make_pair(val[i], gv[i]);
sort(B + l, B + r + 1);
S[l] = B[l].second;
for (int i = (l + 1), iend = (r); i <= iend; ++i)
S[i] = ad(S[i - 1], B[i].second);
}
void add(int l, int r, int c) {
++l, ++r;
if (bel[l] == bel[r]) {
int b = bel[l];
for (int i = (l), iend = (r); i <= iend; ++i) val[i] += c;
rebuild(b);
return;
}
for (int i = (l), iend = (bel[l] * blo); i <= iend; ++i) val[i] += c;
rebuild(bel[l]);
for (int i = (r), iend = (bel[r] * blo - blo + 1); i >= iend; --i)
val[i] += c;
rebuild(bel[r]);
for (int i = (bel[l] + 1), iend = (bel[r] - 1); i <= iend; ++i) lz[i] += c;
}
int que() {
int as = 0;
for (int b = (1), bend = (bel[cur]); b <= bend; ++b) {
int l = (b - 1) * blo + 1, r = b * blo;
int ps =
upper_bound(B + l, B + r + 1, make_pair(k - lz[b], 0x3f3f3f3f)) - B - 1;
if (ps < l)
continue;
else
as = ad(as, S[ps]);
}
return as;
}
void gt(int p, int c) {
++p;
gv[p] = c;
rebuild(bel[p]);
}
int dp[200006];
void solve() {
cin >> n >> k;
for (int i = (1), iend = (n); i <= iend; ++i)
scanf("%d", A + i), las[i] = pr[A[i]], pr[A[i]] = i;
for (int i = (1), iend = (n + 1); i <= iend; ++i) bel[i] = (i - 1) / blo + 1;
dp[0] = 1;
for (int i = (1), iend = (n); i <= iend; ++i) {
cur = i + 1;
add(las[i] + 1, i, 1);
if (las[i]) add(las[las[i]] + 1, las[i], -1);
gt(i, dp[i - 1]);
dp[i] = que();
}
printf("%d\n", dp[n]);
}
signed main() { solve(); }
| 10 | CPP |
#include <bits/stdc++.h>
namespace _ {
const int inf = 1e9;
const int mod = 998244353;
const double eps = 1e-8;
namespace IO_IN {
char buf[1 << 23], *p1 = buf, *p2 = buf;
int getc() {
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 23, stdin), p1 == p2)
? EOF
: *p1++;
}
template <class T>
inline T read() {
char ch;
bool flag = 0;
T x = 0;
while (ch = getc(), !isdigit(ch))
if (ch == '-') flag = 1;
while (isdigit(ch)) x = x * 10 + ch - 48, ch = getc();
return flag ? -x : x;
}
struct {
inline operator int() { return read<int>(); }
inline operator long long() { return read<long long>(); }
template <class T>
inline void operator()(T &x) {
x = *this;
}
template <class T, class... A>
inline void operator()(T &x, A &...a) {
x = *this, this->operator()(a...);
}
} IN;
} // namespace IO_IN
using namespace IO_IN;
namespace IO_OUT {
char buf[1 << 23];
int p1 = -1;
const int p2 = (1 << 23) - 1;
void flush() { fwrite(buf, 1, p1 + 1, stdout), p1 = -1; }
void putc(const char &x) {
if (p1 == p2) flush();
buf[++p1] = x;
}
template <class T>
inline void print(T x) {
static char tmp[15];
static int len = -1;
if (x >= 0) do {
tmp[++len] = x % 10 + 48, x /= 10;
} while (x);
else {
putc('-');
do {
tmp[++len] = -(x % 10) + 48, x /= 10;
} while (x);
}
while (len >= 0) putc(tmp[len]), --len;
}
template <class T>
inline void print_(T x) {
print(x), flush(), putchar(' ');
}
template <class T>
inline void _print(T x) {
print(x), flush(), putchar('\n');
}
} // namespace IO_OUT
using namespace IO_OUT;
namespace Std_Function {
template <class T>
inline bool chkmax(T &x, T y) {
x = x > y ? x : y;
return x == y;
}
template <class T>
inline bool chkmin(T &x, T y) {
x = x < y ? x : y;
return x == y;
}
} // namespace Std_Function
using namespace Std_Function;
namespace Math_Function {
template <class T>
inline bool dcmp(T x, T y) {
return fabs(x - y) < eps;
}
template <class T>
inline T gcd(T x, T y) {
return y ? gcd(y, x % y) : x;
}
} // namespace Math_Function
using namespace Math_Function;
namespace Mod_Function {
inline int mul(int x, int y) { return 1ll * x * y % mod; }
inline int dec(int x, int y) {
x -= y;
if (x < 0) x += mod;
return x;
}
inline int add(int x, int y) {
x += y;
if (x >= mod) x -= mod;
return x;
}
inline void pls(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
inline void sub(int &x, int y) {
x -= y;
if (x < 0) x += mod;
}
inline int modpow(int x, int y, int res = 1) {
for (; y; y >>= 1, x = mul(x, x))
if (y & 1) res = mul(res, x);
return res;
}
} // namespace Mod_Function
using namespace Mod_Function;
} // namespace _
using namespace _;
const int N = 1e5 + 5;
const int S = 320;
using namespace std;
int n, k, a[N], dp[N], las[N], pre[N];
int L[S], R[S], bel[N], cnt[N], ans[S], tag[S], sum[S][N];
inline void update(int x, int v) {
if (cnt[x] + tag[bel[x]] <= k) sub(ans[bel[x]], dp[x]);
cnt[x] += v, pls(sum[bel[x]][cnt[x]], dp[x]),
sub(sum[bel[x]][cnt[x] - v], dp[x]);
if (cnt[x] + tag[bel[x]] <= k) pls(ans[bel[x]], dp[x]);
}
inline void modify(int l, int r, int v) {
if (l > r) return;
if (bel[l] == bel[r])
for (int i = l; i <= r; ++i) update(i, v);
else {
for (int i = l; i <= R[bel[l]]; ++i) update(i, v);
for (int i = L[bel[r]]; i <= r; ++i) update(i, v);
for (int i = bel[l] + 1; i <= bel[r] - 1; ++i)
sub(ans[i], (v > 0 && (k - tag[i] >= 0)) ? sum[i][k - tag[i]] : 0),
tag[i] += v,
pls(ans[i], (v < 0 && (k - tag[i] >= 0)) ? sum[i][k - tag[i]] : 0);
}
}
int main() {
IN(n, k);
for (int i = 1; i <= n; ++i) IN(a[i]);
int siz = sqrt(n), id = 1;
R[0] = L[0] = -1;
for (int t = 0; t <= n; t += siz) {
L[id] = t, R[id] = min(t + siz - 1, n);
for (int i = L[id]; i <= R[id]; ++i) bel[i] = id;
++id;
}
dp[0] = sum[1][0] = ans[1] = 1;
for (int i = 1; i <= n; ++i) {
las[i] = pre[a[i]], pre[a[i]] = i;
modify(las[las[i]], las[i] - 1, -1), modify(las[i], i - 1, 1);
int tmp = 0;
while (R[tmp + 1] < i) pls(dp[i], ans[++tmp]);
for (int j = R[tmp] + 1; j < i; ++j)
if (cnt[j] + tag[bel[j]] <= k) pls(dp[i], dp[j]);
pls(sum[bel[i]][0], dp[i]);
if (tag[bel[i]] <= k) pls(ans[bel[i]], dp[i]);
}
_print(dp[n]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, B, K, C = 500;
int delta[1005];
long long tbl[1005][1005];
int lst1[100005], lst2[100005];
int val[100005];
long long dp[100005];
long long MOD = 998244353;
long long add(long long a, long long b) { return (a + b) % MOD; }
long long sub(long long a, long long b) {
a = add(a, -b);
if (a < 0) {
a += MOD;
}
return a;
}
void build(int b) {
int l = b * B, r = (b + 1) * B - 1;
int sum = 0;
for (int k = -B + C; k <= B + C; k++) {
tbl[b][k] = 0;
}
for (int i = r; i >= l; i--) {
sum += val[i];
tbl[b][sum + C] += dp[i];
}
for (int k = -B + C + 1; k <= B + C; k++) {
tbl[b][k] = add(tbl[b][k], tbl[b][k - 1]);
}
delta[b] = sum;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin >> N >> K;
B = sqrt(N);
fill(lst1 + 1, lst1 + N + 1, -1);
fill(lst2 + 1, lst2 + N + 1, -1);
dp[0] = 1;
for (int i = 0; i < N; i++) {
int n;
cin >> n;
val[i] = 1;
if (lst1[n] + 1) {
val[lst1[n]] = -1;
if (lst1[n] < i / B * B) {
build(lst1[n] / B);
}
}
if (lst2[n] + 1) {
val[lst2[n]] = 0;
if (lst2[n] < i / B * B) {
build(lst2[n] / B);
}
}
lst2[n] = lst1[n];
lst1[n] = i;
int j = i, tot = 0;
do {
tot += val[j];
if (tot <= K) {
dp[i + 1] = add(dp[i + 1], dp[j]);
}
j--;
} while (j % B != B - 1 && j % B != -1);
if (j >= 0) {
j /= B;
while (j >= 0) {
int temp = K - tot;
if (temp < -B)
;
else {
dp[i + 1] = add(dp[i + 1], tbl[j][min(B + C, temp + C)]);
}
tot += delta[j];
j--;
}
}
if (i % B == B - 1) {
build(i / B);
}
}
cout << dp[N] << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005, maxm = 320, tt = 998244353;
int n, m, n1, a[maxn], f[maxn], g[maxm][maxn], bl[maxn], sq, val[maxn],
tag[maxm];
int L[maxn], R[maxn];
int las[maxn], las1[maxn];
void build(int x, int l, int r) {
for (int i = l; i <= r; i++) {
g[x][val[i]] = (g[x][val[i]] + f[i - 1]) % tt;
}
for (int i = 1; i <= n1; i++) g[x][i] = (g[x][i] + g[x][i - 1]) % tt;
}
void change(int l, int r, int p, int now) {
int st = bl[l] + 1, ed = bl[r] - 1;
if (st <= ed)
for (int i = st; i <= ed; i++) tag[i] += p;
if (bl[l] != bl[r]) {
for (int i = l; i <= R[bl[l]]; i++)
if (p == -1)
(g[bl[i]][val[i] + p] += f[i - 1]) %= tt, val[i]--;
else
(((g[bl[i]][val[i]] -= f[i - 1]) %= tt) += tt) %= tt, val[i]++;
if (bl[r] != bl[now] || (bl[r] == bl[now] && R[bl[now]] == now)) {
for (int i = L[bl[r]]; i <= r; i++)
if (p == -1)
(g[bl[i]][val[i] + p] += f[i - 1]) %= tt, val[i]--;
else
(((g[bl[i]][val[i]] -= f[i - 1]) %= tt) += tt) %= tt, val[i]++;
} else {
for (int i = L[bl[r]]; i <= r; i++)
if (p == -1)
val[i]--;
else
val[i]++;
}
} else {
if (bl[r] != bl[now] || (bl[r] == bl[now] && R[bl[now]] == now)) {
for (int i = l; i <= r; i++)
if (p == -1)
(g[bl[i]][val[i] + p] += f[i - 1]) %= tt, val[i]--;
else
(((g[bl[i]][val[i]] -= f[i - 1]) %= tt) += tt) %= tt, val[i]++;
} else {
for (int i = l; i <= r; i++)
if (p == -1)
val[i]--;
else
val[i]++;
}
}
}
int query(int l, int r) {
int ret = 0;
for (int i = bl[l]; i < bl[r]; i++) ret = (ret + g[i][m - tag[i]]) % tt;
for (int i = L[bl[r]]; i <= r; i++)
if (val[i] + tag[bl[r]] <= m) ret = (ret + f[i - 1]) % tt;
return ret;
}
int main() {
scanf("%d%d", &n, &m);
n1 = m;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), n1 = max(n1, a[i]);
int ls = 0, bls = 0;
sq = sqrt(n);
for (int i = 1; i <= n; i++) {
bl[i] = bls + 1;
if (i - ls == sq || i == n) L[++bls] = ls + 1, R[bls] = i, ls = i;
}
ls = 0, bls = 0;
f[0] = 1;
for (int i = 1; i <= n; i++) {
if (i == ls + sq) {
build(++bls, ls + 1, i);
ls = i;
}
if (las[a[i]]) change(las1[a[i]] + 1, las[a[i]], -1, i);
change(las[a[i]] + 1, i, 1, i);
las1[a[i]] = las[a[i]], las[a[i]] = i;
f[i] = query(1, i);
}
printf("%d\n", f[n]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
const int ms = 110000;
const int bs = 400;
const int MOD = 998244353;
void add(int &a, int b) { a = a + b < MOD ? a + b : a + b - MOD; }
int *pivot;
bool comp(int x1, int x2) { return pivot[x1] < pivot[x2]; }
int tmp[2][bs];
struct Bucket {
Bucket() { dirty = size = 0; }
void push_back(int x) {
p[size] = size;
lazy[size] = 0;
dp[size] = x;
values[size++] = 0;
}
void clean() {
for (int i = size - 2; i >= 0; i--) {
add(lazy[i], lazy[i + 1]);
}
for (int i = 0; i < size; i++) {
add(dp[p[i]], lazy[i]);
lazy[i] = 0;
}
if (dirty) {
for (int i = 0; i < size; i++) {
values[i] += dirty;
}
dirty = 0;
}
}
void remake() {
pt = 0;
s = 0;
for (int i = 0; i + 1 < size; i++) {
if (i + 1 == size || values[p[i]] != values[p[i + 1]]) {
uni[s++] = i;
}
}
}
int getID(int x) {
if (x < values[p[0]] + dirty) {
return -1;
}
int l = 0, r = size - 1;
while (l != r) {
int mid = (l + r + 1) / 2;
if (values[p[mid]] + dirty <= x) {
l = mid;
} else {
r = mid - 1;
}
}
return l;
while (pt > 0 && x < values[p[uni[pt]]] + dirty) {
pt--;
}
while (pt + 1 < s && x >= values[p[uni[pt + 1]]] + dirty) {
pt++;
}
return uni[pt];
}
void upd(int x, int l, int r, int val) {
if (l == 0 && r == size) {
int id = getID(x);
if (id != -1) {
add(lazy[id], val);
}
} else {
for (int i = l; i < r; i++) {
if (values[i] + dirty <= x) {
add(dp[i], val);
} else {
}
}
}
}
void upd2(int l, int r, int val) {
if (l == 0 && r == size) {
dirty += val;
} else {
for (int i = l; i < r; i++) {
values[i] += val;
}
clean();
pivot = values;
int s0 = 0, s1 = 0;
for (int i = 0; i < size; i++) {
if (l <= p[i] && p[i] < r) {
tmp[0][s0++] = p[i];
} else {
tmp[1][s1++] = p[i];
}
}
std::merge(tmp[0], tmp[0] + s0, tmp[1], tmp[1] + s1, p, comp);
remake();
}
}
int values[bs], p[bs], lazy[bs], dp[bs], uni[bs];
int dirty;
int size, s, pt;
};
Bucket b[ms / bs + 2];
std::vector<int> pos[ms];
int a[ms];
int pt[ms];
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int n, k;
std::cin >> n >> k;
for (int i = 1; i <= n; i++) {
pos[i].push_back(-1);
}
for (int i = 0; i < n; i++) {
std::cin >> a[i];
pos[a[i]].push_back(i);
b[i / bs].push_back(i == 0 ? 1 : 0);
}
b[n / bs].push_back(0);
for (int i = 0; i <= n; i++) {
if (i % bs == 0) {
b[i / bs].remake();
}
}
for (int i = 1; i <= n; i++) {
pos[i].push_back(n);
pos[i].push_back(n);
}
auto upd2 = [&](int l, int r, int val) {
if (l >= r) return;
int bl = l / bs, br = (r - 1) / bs;
if (bl == br) {
b[bl].upd2(l - bl * bs, r - bl * bs, val);
return;
}
b[bl].upd2(l - bl * bs, bs, val);
for (int i = bl + 1; i < br; i++) {
b[i].upd2(0, bs, val);
}
b[br].upd2(0, r - br * bs, val);
};
auto upd = [&](int l, int r, int val) {
if (l >= r) return;
int bl = l / bs, br = (r - 1) / bs;
if (bl == br) {
b[bl].upd(k, l - bl * bs, r - bl * bs, val);
return;
}
b[bl].upd(k, l - bl * bs, bs, val);
for (int i = bl + 1; i < br; i++) {
b[i].upd(k, 0, bs, val);
}
b[br].upd(k, 0, r - br * bs, val);
};
for (int i = 1; i <= n; i++) {
upd2(pos[i][1] + 1, pos[i][2] + 1, 1);
}
for (int i = 0; i < n; i++) {
b[i / bs].clean();
int dp = b[i / bs].dp[i % bs];
upd(i + 1, n + 1, dp);
{
int v = a[i];
upd2(pos[v][pt[v] + 1] + 1, pos[v][pt[v] + 2] + 1, -1);
pt[v]++;
upd2(pos[v][pt[v] + 1] + 1, pos[v][pt[v] + 2] + 1, 1);
}
}
b[n / bs].clean();
std::cout << b[n / bs].dp[n % bs] << '\n';
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int MAXN = 100005;
const int Blocks = 405;
int n, qk, a[MAXN], pre[MAXN], lst[MAXN], dp[MAXN], f[MAXN];
int sum[Blocks][MAXN], ans[Blocks], lz[Blocks], l[Blocks], r[Blocks], bl[MAXN];
inline void add(int &x, int y) {
x += y;
(x >= mod) && (x -= mod);
}
inline void sub(int &x, int y) {
x -= y;
(x < 0) && (x += mod);
}
inline void Rebuild(int x) {
for (int k = l[x]; k <= r[x]; ++k) sum[x][f[k]] = 0, f[k] += lz[x];
lz[x] = ans[x] = 0;
for (int k = l[x]; k <= r[x]; ++k) {
add(sum[x][f[k]], dp[k]);
if (f[k] <= qk) add(ans[x], dp[k]);
}
}
inline void Update(int k, int val) {
int x = bl[k];
sub(sum[x][f[k]], dp[k]);
if (f[k] <= qk) sub(ans[x], dp[k]);
f[k] += val;
add(sum[x][f[k]], dp[k]);
if (f[k] <= qk) add(ans[x], dp[k]);
}
inline void Modify(int x, int y, int val) {
int L = bl[x], R = bl[y];
if (L == R) {
Rebuild(L);
for (int k = x; k <= y; ++k) Update(k, val);
} else {
Rebuild(L);
for (int k = x; k <= r[L]; ++k) Update(k, val);
Rebuild(R);
for (int k = l[R]; k <= y; ++k) Update(k, val);
for (int i = L + 1; i < R; ++i)
if (val == 1) {
int tmp = qk - (lz[i]++);
sub(ans[i], sum[i][tmp]);
} else {
int tmp = qk - (--lz[i]);
add(ans[i], sum[i][tmp]);
}
}
}
inline int Query(int x) {
int re = 0;
Rebuild(bl[x]);
for (int k = l[bl[x]]; k <= x; ++k)
if (f[k] <= qk) add(re, dp[k]);
for (int i = 1; i < bl[x]; ++i) add(re, ans[i]);
return re;
}
int main() {
scanf("%d%d", &n, &qk);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
pre[i] = lst[a[i]];
lst[a[i]] = i;
}
dp[1] = 1;
int m = sqrt(n);
for (int i = 1; i <= n; ++i) {
bl[i] = (i - 1) / m + 1;
r[bl[i]] = i;
if (!l[bl[i]]) l[bl[i]] = i;
}
for (int i = 1; i <= n; ++i) {
Modify(pre[i] + 1, i, 1);
if (pre[i]) Modify(pre[pre[i]] + 1, pre[i], -1);
dp[i + 1] = Query(i);
}
printf("%d\n", dp[n + 1]);
}
| 10 | CPP |
#include <bits/stdc++.h>
const int maxn = 100005, mod = 998244353, maxt = 325;
int n, k, t;
int a[maxn], l[maxt], r[maxt], pos[maxn], lst[maxn], pre[maxn], f[maxn],
sum[maxt][maxn], tot[maxn], tag[maxt], cnt[maxn];
void BF(int x, int y, int v) {
for (int i = x; i <= y; i++) {
if (v == 1)
cnt[i]++, sum[pos[i]][cnt[i]] = (sum[pos[i]][cnt[i]] + f[i]) % mod;
else
sum[pos[i]][cnt[i]] = (sum[pos[i]][cnt[i]] - f[i] + mod) % mod, cnt[i]--;
}
}
void update(int x, int y, int v) {
if (x > y) return;
int p = pos[x], q = pos[y];
if (p == q) {
BF(x, y, v);
return;
}
BF(x, r[p], v), BF(l[q], y, v);
for (int i = p + 1; i <= q - 1; i++) tag[i] += v;
}
int query() {
int res = 0;
for (int i = 1; i <= t; i++)
if (k - tag[i] + 1 >= 0)
res = (res + tot[i] - sum[i][k - tag[i] + 1]) % mod;
return (res + mod) % mod;
}
int main() {
scanf("%d%d", &n, &k);
t = sqrt(n + 1);
r[0] = -1;
for (int i = 1; i <= t; i++) l[i] = r[i - 1] + 1, r[i] = l[i] + t - 1;
if (r[t] < n) t++, l[t] = r[t - 1] + 1, r[t] = n;
for (int i = 1; i <= t; i++)
for (int j = l[i]; j <= r[i]; j++) pos[j] = i;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pre[i] = lst[a[i]], lst[a[i]] = i;
}
f[0] = 1, sum[1][0] = 1, tot[1] = 1;
for (int i = 1; i <= n; i++) {
update(pre[pre[i]], pre[i] - 1, -1), update(pre[i], i - 1, 1);
f[i] = query(), sum[pos[i]][0] = (sum[pos[i]][0] + f[i]) % mod,
tot[pos[i]] = (tot[pos[i]] + f[i]) % mod;
}
printf("%d\n", f[n]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2")
using namespace std;
using ll = long long;
int a[101001];
int b[101010];
int dp[101010];
int p1[101010];
int p2[101010];
ll ans = 0;
int n, k;
void add(int* __restrict a, int* __restrict dp, int n) {
for (int i = 0; i < n; ++i) {
a[i]++;
ans -= a[i] == 0 ? dp[i] : 0;
}
}
void sub(int* __restrict a, int* __restrict dp, int n) {
for (int i = 0; i < n; ++i) {
ans += a[i] == 0 ? dp[i] : 0;
a[i]--;
}
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
b[i] = -k - 1;
cin >> a[i];
--a[i];
p1[i] = p2[i] = -1;
}
dp[0] = 1;
ans = 1;
for (int i = 0; i < n; ++i) {
int x = a[i];
sub(b + p2[x] + 1, dp + p2[x] + 1, p1[x] - p2[x]);
add(b + p1[x] + 1, dp + p1[x] + 1, i - p1[x]);
ans %= 998244353;
if (ans < 0) ans += 998244353;
dp[i + 1] = (int)ans;
ans *= 2;
p2[x] = p1[x];
p1[x] = i;
}
cout << ans / 2 << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
int n, m, h[N], lev[N], Xor[N], cnt[N], deg[N];
vector<int> nxt[N], rnxt[N], vec[N];
set<int> s;
queue<int> q;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> h[i];
for (int i = 1; i <= m; ++i) {
int x, y;
cin >> x >> y;
rnxt[y].push_back(x);
nxt[x].push_back(y);
++deg[x];
}
for (int i = 1; i <= n; ++i)
if (!deg[i]) q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto v : nxt[u]) ++cnt[lev[v]];
while (cnt[lev[u]]) ++lev[u];
Xor[lev[u]] ^= h[u];
for (auto v : nxt[u]) --cnt[lev[v]];
for (auto v : rnxt[u])
if (!--deg[v]) q.push(v);
}
for (int i = n; ~i; --i)
if (Xor[i]) {
puts("WIN");
for (int u = 1; u <= n; ++u)
if (lev[u] == i && h[u] > (h[u] ^ Xor[i])) {
h[u] ^= Xor[i];
for (auto v : nxt[u])
if (Xor[lev[v]]) h[v] ^= Xor[lev[v]], Xor[lev[v]] = 0;
break;
}
for (int j = 1; j <= n; ++j) cout << h[j] << " ";
puts("");
return 0;
}
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 200010, LOG = 20;
int n, m, k, u, v, x, y, t, a, b, ans;
int A[MAXN], g[MAXN];
int val[MAXN];
int mark[MAXN];
vector<int> G[MAXN], topol;
void dfs(int node) {
mark[node] = 1;
for (int v : G[node])
if (!mark[v]) dfs(v);
topol.push_back(node);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> A[i];
while (m--) {
cin >> u >> v;
G[u].push_back(v);
}
for (int v = 1; v <= n; v++)
if (!mark[v]) dfs(v);
memset(mark, 0, sizeof(mark));
for (int v : topol) {
for (int u : G[v]) mark[g[u]] = v;
while (mark[g[v]] == v) g[v]++;
val[g[v]] ^= A[v];
}
for (int i = n; ~i; i--)
if (val[i]) {
for (int v = 1; v <= n; v++)
if (g[v] == i && (A[v] ^ val[i]) < A[v]) {
A[v] ^= val[i];
for (int u : G[v]) {
A[u] ^= val[g[u]];
val[g[u]] = 0;
}
break;
}
cout << "WIN\n";
for (int v = 1; v <= n; v++) cout << A[v] << ' ';
cout << '\n';
return 0;
}
cout << "LOSE\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int he[200010], ver[2 * 200010], nxt[2 * 200010], tot, in[200010];
void add(int x, int y) {
ver[++tot] = y;
nxt[tot] = he[x];
he[x] = tot;
}
int que[200010], cnt;
long long w[200010];
vector<int> v[200010];
long long ans[200010];
int s[200010];
bool vis[200010];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%lld", &w[i]);
}
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(y, x);
in[x]++;
}
queue<int> q;
for (int i = 1; i <= n; i++) {
if (in[i] == 0) q.push(i);
}
while (!q.empty()) {
int x = q.front();
q.pop();
que[++cnt] = x;
for (int i = he[x]; i; i = nxt[i]) {
in[ver[i]]--;
if (!in[ver[i]]) q.push(ver[i]);
}
}
int maxx = 0;
for (int i = 1; i <= cnt; i++) {
int x = que[i];
int stp = 0;
if (!v[x].size())
ans[0] ^= w[x];
else {
sort(v[x].begin(), v[x].end());
s[x] = 0;
for (int j = 0; j < v[x].size(); j++) {
if (v[x][j] == s[x]) s[x]++;
}
stp = s[x];
ans[stp] ^= w[x];
maxx = max(maxx, stp);
}
s[x] = stp;
for (int j = he[x]; j; j = nxt[j]) v[ver[j]].push_back(stp);
}
bool xx = false;
for (int i = 0; i <= maxx; i++) {
if (ans[i] != 0) {
xx = true;
break;
}
}
if (xx) {
puts("WIN");
for (int i = maxx; i >= 0; i--) {
if (ans[i]) {
maxx = i;
break;
}
}
int tmp = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == maxx && ((w[i] ^ ans[s[i]]) < w[i])) {
tmp = i;
break;
}
}
w[tmp] = ans[maxx] ^ w[tmp];
for (int i = 1; i <= n; i++) {
if (i == tmp || s[i] >= s[tmp]) continue;
for (int j = he[i]; j; j = nxt[j]) {
if (ver[j] == tmp && vis[s[i]] == 0) {
w[i] = ans[s[i]] ^ w[i];
vis[s[i]] = 1;
break;
}
}
}
for (int i = 1; i <= n; i++) printf("%lld ", w[i]);
} else
puts("LOSE");
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
int n, m, h[223456], xors[223456], sg[223456], tag[223456];
int u, v, t, deg[223456], q[223456];
vector<int> e[223456];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &h[i]);
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
e[u].push_back(v);
++deg[v];
}
for (int i = 1; i <= n; i++)
if (deg[i] == 0) q[++t] = i;
for (int i = 1; i <= t; i++) {
int u = q[i];
for (auto v : e[u]) {
--deg[v];
if (deg[v] == 0) q[++t] = v;
}
}
int maxL = 0;
for (int i = n; i >= 1; i--) {
int u = q[i];
for (auto v : e[u]) tag[sg[v]] = i;
while (tag[sg[u]] == i) ++sg[u];
maxL = max(maxL, sg[u]);
xors[sg[u]] ^= h[u];
}
int lev = -1;
for (int i = 0; i <= maxL; i++)
if (xors[i] != 0) {
lev = i;
}
if (lev == -1) {
puts("LOSE");
return 0;
}
puts("WIN");
for (int u = 1; u <= n; u++) {
if (sg[u] == lev && (h[u] ^ xors[lev]) < h[u]) {
h[u] = h[u] ^ xors[lev];
for (auto v : e[u]) {
h[v] ^= xors[sg[v]];
xors[sg[v]] = 0;
}
break;
}
}
for (int i = 1; i <= n; i++) printf("%d ", h[i]);
puts("");
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
vector<int> e[N];
int n, m, h[N], sg[N], sum[N], dg[N], q[N], vis[N];
void topsort() {
int h = 1, t = 0;
for (int i = 1; i <= n; i++)
if (!dg[i]) q[++t] = i;
while (h <= t) {
int u = q[h++];
for (int v : e[u])
if (!--dg[v]) q[++t] = v;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &h[i]);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v);
dg[v]++;
}
topsort();
for (int i = n; i; i--) {
int u = q[i];
for (int v : e[u]) vis[sg[v]] = i;
while (vis[sg[u]] == i) sg[u]++;
sum[sg[u]] ^= h[u];
}
for (int i = n; ~i; i--)
if (sum[i]) {
int pos;
for (int j = 1; j <= n; j++)
if (sg[j] == i && h[j] > (sum[i] ^ h[j])) pos = j;
h[pos] ^= sum[i];
for (int v : e[pos]) h[v] ^= sum[sg[v]], sum[sg[v]] = 0;
printf("WIN\n");
for (int j = 1; j <= n; j++) printf("%d ", h[j]);
printf("\n");
return 0;
}
printf("LOSE");
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, y = 0, c = getchar();
while (!isdigit(c)) y = c, c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ '0'), c = getchar();
return y == '-' ? -x : x;
}
inline void print(long long q) {
if (q < 0) putchar('-'), q = -q;
if (q >= 10) print(q / 10);
putchar(q % 10 + '0');
}
long long s1 = 19260817, s2 = 23333333, s3 = 998244353, srd;
inline long long rd() { return srd = (srd * s1 + s2 + rand()) % s3; }
void file() {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
int n, m, a[200010];
struct edge {
int to, nxt;
} e[200010], ee[200010];
int cnt, fir[200010], ff[200010], ds[200010];
inline void ins(int u, int v) {
e[++cnt].to = v;
e[cnt].nxt = fir[u];
fir[u] = cnt;
ee[cnt].to = u;
ee[cnt].nxt = ff[v];
ff[v] = cnt;
++ds[u];
}
int jie[200010], vl[200010], mx;
bool tp[200010];
vector<int> b[200010];
int q[200010], h, t;
int main() {
srand(time(0));
rd();
int i, j, k, u, v;
n = read();
m = read();
for (i = 1; i <= n; ++i) a[i] = read();
for (i = 1; i <= m; ++i) {
u = read();
v = read();
ins(u, v);
}
for (i = 1; i <= n; ++i)
if (!ds[i]) q[++t] = i;
while (h < t) {
j = q[++h];
for (i = ff[j]; i; i = ee[i].nxt) {
--ds[ee[i].to];
if (!ds[ee[i].to]) q[++t] = ee[i].to;
}
}
for (i = 1; i <= n; ++i) {
for (j = fir[q[i]]; j; j = e[j].nxt) tp[jie[e[j].to]] = 1;
for (j = 0;; ++j)
if (!tp[j]) {
jie[q[i]] = j;
b[j].push_back(q[i]);
mx = max(mx, j);
vl[j] ^= a[q[i]];
break;
}
for (j = fir[q[i]]; j; j = e[j].nxt) tp[jie[e[j].to]] = 0;
}
int mm = mx + 1;
for (i = mx; i >= 0; --i)
if (vl[i]) {
mm = i;
break;
}
if (mm == mx + 1) {
puts("LOSE");
return 0;
}
puts("WIN");
for (i = 0; i < b[mm].size(); ++i) {
j = b[mm][i];
k = vl[mm] ^ a[j];
if (k < a[j]) {
a[j] = k;
vl[mm] = 0;
for (u = fir[j]; u; u = e[u].nxt) {
a[e[u].to] ^= vl[jie[e[u].to]];
vl[jie[e[u].to]] = 0;
}
break;
}
}
for (i = 1; i <= n; ++i) print(a[i]), putchar(' ');
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "URDL";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 998244353) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
vector<int> mp[200135];
int h[200135], sg[200135], s[200135];
int spg(int x) {
int& tmp = sg[x];
if (tmp != -1) return tmp;
vector<int> vp;
for (int c : mp[x]) vp.push_back(spg(c));
sort(vp.begin(), vp.end());
int N = unique(vp.begin(), vp.end()) - vp.begin();
for (int(i) = 0; (i) < (int)(N); (i)++)
if (i != vp[i]) {
tmp = i;
return tmp;
}
tmp = N;
return tmp;
}
void fmain(int tid) {
scanf("%d%d", &n, &m);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%d", h + i);
for (int(i) = 1; (i) <= (int)(m); (i)++) {
int u, v;
scanf("%d%d", &u, &v);
mp[u].push_back(v);
}
memset(sg, -1, sizeof sg);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
s[spg(i)] ^= h[i];
}
int tar = -1;
for (int i = n; i >= 0; i--)
if (s[i] != 0) {
tar = i;
break;
}
if (tar == -1) {
puts("LOSE");
return;
}
puts("WIN");
int w = -1;
for (int(i) = 1; (i) <= (int)(n); (i)++)
if (sg[i] == tar) {
if ((s[tar] ^ h[i]) < h[i]) {
w = i;
break;
}
}
h[w] = s[tar] ^ h[w];
for (int c : mp[w]) {
h[c] = s[sg[c]] ^ h[c];
s[sg[c]] = 0;
}
for (int(i) = 1; (i) <= (int)(n); (i)++) printf("%d ", h[i]);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long head[400005], ver[400005], nxt[400005], cnt;
void add(long long a, long long b) {
ver[++cnt] = b, nxt[cnt] = head[a], head[a] = cnt;
}
vector<long long> e[400005], has[400005];
long long n, m, cd[400005];
long long a[400005], sg[400005];
long long pos[400005], mex[400005], mx;
bool vis[400005];
queue<long long> q, ans;
int main() {
scanf("%d%d", &n, &m);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (long long i = 1, a, b; i <= m; i++) {
scanf("%d%d", &a, &b);
add(a, b), e[b].push_back(a), cd[a]++;
}
for (long long i = 1; i <= n; i++)
if (!cd[i]) q.push(i);
while (!q.empty()) {
long long now = q.front();
q.pop(), cnt = 0;
for (long long i = head[now]; i; i = nxt[i]) mex[++cnt] = pos[ver[i]];
pos[now] = 1;
sort(mex + 1, mex + 1 + cnt);
for (long long i = 1; i <= cnt; i++)
if (mex[i] == pos[now]) pos[now]++;
sg[pos[now]] ^= a[now];
has[pos[now]].push_back(now);
mx = max(mx, pos[now]);
for (long long i = 0; i < e[now].size(); i++) {
cd[e[now][i]]--;
if (!cd[e[now][i]]) q.push(e[now][i]);
}
}
for (long long o = mx; o >= 1; o--) {
if (sg[o] != 0) {
long long now;
for (long long i = 0; i < has[o].size(); i++)
if ((a[has[o][i]] ^ sg[o]) <= a[has[o][i]]) {
now = has[o][i];
break;
}
a[now] ^= sg[o];
for (long long i = head[now]; i; i = nxt[i]) {
long long to = ver[i];
if (vis[pos[to]]) continue;
vis[pos[to]] = 1;
a[to] = sg[pos[to]] ^ a[to];
}
printf("WIN\n");
for (long long i = 1; i <= n; i++) printf("%lld ", a[i]);
return 0;
}
}
printf("LOSE");
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr int kMaxN = 2e5 + 3;
vector<int> edges[kMaxN];
bitset<kMaxN> visited;
int nim[kMaxN];
int mext[kMaxN];
int levels[kMaxN];
vector<int> nim_nodes[kMaxN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<int> h(n);
for (int i = 0; i < n; ++i) {
cin >> h[i];
}
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
edges[u].emplace_back(v);
}
memset(mext, -1, sizeof(mext));
function<void(int)> dfs = [&](int u) {
if (visited[u]) {
return;
}
visited[u] = true;
for (int v : edges[u]) {
dfs(v);
}
for (int v : edges[u]) {
mext[nim[v]] = u;
}
int k = 0;
while (mext[k] == u) {
++k;
}
nim[u] = k;
levels[k] ^= h[u];
nim_nodes[k].emplace_back(u);
};
for (int i = 0; i < n; ++i) {
dfs(i);
}
if (count(levels, levels + kMaxN, 0) == kMaxN) {
cout << "LOSE\n";
return 0;
}
cout << "WIN\n";
int last_level = n;
while (levels[last_level] == 0) {
--last_level;
}
assert(last_level >= 0);
int node = -1;
for (int u : nim_nodes[last_level]) {
if ((h[u] ^ levels[nim[u]]) <= h[u]) {
h[u] ^= levels[nim[u]];
node = u;
levels[nim[u]] = 0;
break;
}
}
assert(node != -1);
for (int v : edges[node]) {
h[v] ^= levels[nim[v]];
levels[nim[v]] = 0;
}
assert(count(levels, levels + kMaxN, 0) == kMaxN);
for (int i = 0; i < n; ++i) {
cout << h[i] << ' ';
}
cout << '\n';
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void chkmax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void chkmin(T &a, T b) {
if (a > b) a = b;
}
inline int read() {
int s = 0, f = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') ch = getchar(), f = -1;
while (isdigit(ch)) s = s * 10 + ch - '0', ch = getchar();
return ~f ? s : -s;
}
const int maxn = 3e5 + 20;
vector<int> ed[maxn];
int h[maxn];
int n, m, sg[maxn], rd[maxn];
int rk[maxn], tp;
inline void get_topx() {
queue<int> q;
for (int i = (1), _end_ = (n); i <= _end_; i++)
if (!rd[i]) q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop();
rk[++tp] = u;
for (int v : ed[u])
if (!(--rd[v])) q.push(v);
}
}
inline void init() {
n = read();
m = read();
for (int i = (1), _end_ = (n); i <= _end_; i++) h[i] = read();
for (int i = (1), _end_ = (m); i <= _end_; i++) {
int u = read(), v = read();
ed[u].push_back(v);
rd[v]++;
}
get_topx();
}
int vis[maxn];
int sum[maxn];
inline void doing() {
for (int i = (n), _end_ = (1); i >= _end_; i--) {
int x = rk[i];
for (int y : ed[x]) vis[sg[y]]++;
while (vis[sg[x]]) ++sg[x];
for (int y : ed[x]) vis[sg[y]]--;
}
for (int i = (1), _end_ = (n); i <= _end_; i++) sum[sg[i]] ^= h[i];
for (int i = (n), _end_ = (0); i >= _end_; i--)
if (sum[i]) {
puts("WIN");
for (int j = (1), _end_ = (n); j <= _end_; j++)
if (sg[j] == i && (h[j] ^ sum[i]) < h[j]) {
h[j] = h[j] ^ sum[i];
for (int k : ed[j])
if (sum[sg[k]]) h[k] ^= sum[sg[k]], sum[sg[k]] = 0;
break;
}
for (int j = (1), _end_ = (n); j <= _end_; j++) printf("%d ", h[j]);
return;
}
puts("LOSE");
}
int main() {
init();
doing();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, m;
bool tmp[N];
int h[N], f[N], b[N];
vector<int> G[N];
int deg[N];
vector<int> ord;
void topusort() {
queue<int> Q;
for (int i = 1; i <= n; i++) {
if (!deg[i]) {
Q.push(i);
}
}
while (!Q.empty()) {
int p = Q.front();
Q.pop();
ord.push_back(p);
for (auto e : G[p]) {
if (!--deg[e]) {
Q.push(e);
}
}
}
}
int qwq(int x) {
int t = 0;
while (x) x >>= 1, t++;
return t;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", h + i);
}
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
G[u].emplace_back(v);
deg[v]++;
}
topusort();
reverse(ord.begin(), ord.end());
for (auto p : ord) {
int t = G[p].size();
fill(tmp, tmp + t + 1, false);
for (auto e : G[p]) {
tmp[f[e]] = true;
}
while (tmp[f[p]]) f[p]++;
}
for (int i = 1; i <= n; i++) {
b[f[i]] ^= h[i];
}
int mx = n;
while (mx--) {
if (b[mx]) {
break;
}
}
if (mx < 0) {
puts("LOSE");
} else {
puts("WIN");
int p;
for (p = 1; p <= n; p++) {
if (f[p] == mx && (h[p] ^ b[mx]) < h[p]) {
break;
}
}
assert(p <= n);
h[p] ^= b[mx];
b[mx] = 0;
for (auto e : G[p]) {
h[e] ^= b[f[e]];
b[f[e]] = 0;
}
for (int i = 1; i <= n; i++) {
printf("%d ", h[i]);
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10;
int n, m, clk;
int h[maxN + 1], vis[maxN + 1];
int p[maxN + 1], sum[maxN + 1];
vector<int> G[maxN + 1];
inline int read() {
int num = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) num = (num << 3) + (num << 1) + (ch ^ 48), ch = getchar();
return num * f;
}
inline void dfs(int u) {
if (p[u] != -1) return;
for (int i = 0; i < G[u].size(); i++) dfs(G[u][i]);
clk++;
for (int i = 0; i < G[u].size(); i++) vis[p[G[u][i]]] = clk;
p[u] = 0;
while (vis[p[u]] == clk) p[u]++;
sum[p[u]] ^= h[u];
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) h[i] = read();
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
G[x].push_back(y);
}
fill(p + 1, p + n + 1, -1);
for (int i = 1; i <= n; i++) dfs(i);
int id = -1;
for (int i = 1; i <= n; i++)
if (sum[p[i]]) id = max(id, p[i]);
if (id == -1) {
puts("LOSE");
return 0;
}
puts("WIN");
int x;
for (int i = 1; i <= n; i++)
if (p[i] == id && (h[i] ^ sum[id]) < h[i]) {
x = i;
break;
}
h[x] ^= sum[p[x]];
for (int i = 0; i < G[x].size(); i++) {
int y = G[x][i];
h[y] ^= sum[p[y]];
sum[p[y]] = 0;
}
for (int i = 1; i <= n; i++) printf("%d ", h[i]);
puts("");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
const int N = 200007;
int a[N], deg[N], pos[N], vis[N], sg[N], sum[N];
std::queue<int> q;
std::vector<int> e[N];
int read() {
int x = 0, c = getchar();
while (isspace(c)) c = getchar();
while (isdigit(c)) (x *= 10) += c & 15, c = getchar();
return x;
}
int main() {
int n = read(), m = read();
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1, u, v; i <= m; ++i)
u = read(), v = read(), e[u].push_back(v), ++deg[v];
for (int i = 1; i <= n; ++i)
if (!deg[i]) q.push(i);
for (int u, c = 0; !q.empty();) {
u = q.front(), q.pop(), pos[++c] = u;
for (int v : e[u])
if (!--deg[v]) q.push(v);
}
for (int i = n, u; i; --i) {
u = pos[i];
for (int v : e[u]) vis[sg[v]] = i;
while (vis[sg[u]] == i) ++sg[u];
sum[sg[u]] ^= a[u];
}
for (int i = n, u; ~i; --i)
if (sum[i]) {
for (int j = 1; j <= n; ++j)
if (sg[j] == i && a[j] > (sum[i] ^ a[j])) u = j;
a[u] ^= sum[i];
for (int v : e[u]) a[v] ^= sum[sg[v]], sum[sg[v]] = 0;
puts("WIN");
for (int j = 1; j <= n; ++j) printf("%d ", a[j]);
puts("");
return 0;
}
puts("LOSE");
}
| 11 | CPP |
#include <bits/stdc++.h>
inline void read(int& x) {
char ch = getchar();
x = 0;
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
}
const int N = 201000;
struct Edge {
int v, nxt;
} a[N + N];
int head[N], Head[N];
int h[N], xr[N], deg[N], q[N];
int tng[N], sg[N];
int n, m, _;
inline void ad() {
static int x, y;
read(x), read(y), ++deg[x];
a[++_].v = y, a[_].nxt = head[x], head[x] = _;
a[++_].v = x, a[_].nxt = Head[y], Head[y] = _;
}
int main() {
read(n), read(m);
for (int i = 1; i <= n; ++i) read(h[i]);
for (int i = 1; i <= m; ++i) ad();
int he = 1, ta = 0;
for (int x = 1; x <= n; ++x)
if (!deg[x]) q[++ta] = x;
while (he <= ta) {
int x = q[he++];
for (int i = head[x]; i; i = a[i].nxt) tng[sg[a[i].v]] = 1;
for (int i = 0; !sg[x]; ++i)
if (!tng[i]) sg[x] = i;
for (int i = head[x]; i; i = a[i].nxt) tng[sg[a[i].v]] = 0;
for (int i = Head[x]; i; i = a[i].nxt)
if (!(--deg[a[i].v])) q[++ta] = a[i].v;
}
m = 0;
for (int i = 1; i <= n; ++i)
if (sg[i] > m) m = sg[i];
for (int i = 1; i <= n; ++i) xr[sg[i]] ^= h[i];
int d = 0;
for (int i = 1; i <= m; ++i)
if (xr[i]) d = i;
if (!d) return puts("LOSE"), 0;
puts("WIN");
for (int x = 1; x <= n; ++x)
if (sg[x] == d and (xr[sg[x]] ^ h[x]) < h[x]) {
h[x] = (xr[sg[x]] ^ h[x]);
xr[sg[x]] = 0;
for (int i = head[x]; i; i = a[i].nxt)
if (xr[sg[a[i].v]]) {
h[a[i].v] ^= xr[sg[a[i].v]];
xr[sg[a[i].v]] = 0;
}
for (int i = 1; i <= n; ++i) printf("%d ", h[i]);
putchar(10);
return 0;
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > adj(200001);
int c[200001], mex[200001], h[200001], b[200001];
void DFS(int i) {
if (mex[i] >= 0) {
return;
}
vector<int> v;
for (int j : adj[i]) {
DFS(j);
v.push_back(mex[j]);
}
for (int x : v) {
c[x] = i;
}
int &k = mex[i];
for (k = 0; c[k] == i; ++k)
;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &h[i]);
}
while (m--) {
int i, j;
scanf("%d%d", &i, &j);
adj[i].push_back(j);
}
for (int i = 1; i <= n; ++i) {
mex[i] = -1;
}
for (int i = 1; i <= n; ++i) {
DFS(i);
}
for (int i = 1; i <= n; ++i) {
b[mex[i]] ^= h[i];
}
int root = 0;
mex[root] = -1;
for (int i = 1; i <= n; ++i) {
if (mex[i] > mex[root] && ((b[mex[i]] ^ h[i]) < h[i])) {
root = i;
}
}
bool win = false;
for (int i = 0; i <= mex[root] && !win; ++i) {
win = (b[i] != 0);
}
if (!win) {
printf("LOSE\n");
return 0;
}
c[mex[root]] = root;
for (int j : adj[root]) {
c[mex[j]] = j;
}
for (int i = 0; i <= mex[root]; ++i) {
int j = c[i];
h[j] ^= b[i];
}
printf("WIN\n");
for (int i = 1; i <= n; ++i) {
printf("%d ", h[i]);
}
printf("\n");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5;
int n, m, h[maxn + 3], xo[maxn + 3], deg[maxn + 3], sg[maxn + 3], vis[maxn + 3],
res[maxn + 3];
vector<int> G[maxn + 3], H[maxn + 3];
int main() {
scanf("%d %d", &n, &m);
for (int i = (1); i <= int(n); i++) scanf("%d", &h[i]);
for (int i = (1); i <= int(m); i++) {
int u, v;
scanf("%d %d", &u, &v);
G[u].push_back(v), H[v].push_back(u);
}
for (int i = (1); i <= int(n); i++) deg[i] = G[i].size();
queue<int> Q;
for (int i = (1); i <= int(n); i++)
if (!deg[i]) Q.push(i);
for (int k = (1); k <= int(n); k++) {
int u = Q.front();
Q.pop();
for (int i = (0); i <= int(G[u].size() - 1); i++) {
int v = G[u][i];
vis[sg[v]] = k;
}
for (int i = (0); i <= int(n); i++)
if (vis[i] != k) {
sg[u] = i;
break;
}
xo[sg[u]] ^= h[u];
for (int i = (0); i <= int(H[u].size() - 1); i++) {
int v = H[u][i];
if (!--deg[v]) {
Q.push(v);
}
}
}
bool flag = true;
for (int i = (0); i <= int(n - 1); i++) flag &= xo[i] == 0;
if (flag) {
puts("LOSE");
} else {
puts("WIN");
for (int i = (1); i <= int(n); i++) res[i] = h[i];
int x = -1, y = -1;
for (int i = (n - 1); i >= int(0); i--)
if (xo[i]) {
x = i;
break;
}
for (int i = (1); i <= int(n); i++)
if (sg[i] == x && (h[i] ^ xo[x]) < h[i]) {
res[i] ^= xo[x], y = i;
break;
}
for (int i = (0); i <= int(G[y].size() - 1); i++) {
int v = G[y][i];
if (sg[v] < x && xo[sg[v]]) {
res[v] ^= xo[sg[v]], xo[sg[v]] = 0;
}
}
for (int i = (1); i <= int(n); i++) printf("%d%c", res[i], " \n"[i == n]);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
struct edge {
int to, nxt;
};
edge G[maxn];
int head[maxn], cnt;
int h[maxn], deg[maxn];
queue<int> Q;
int a[maxn];
bool vis[maxn];
int bel[maxn];
int nim[maxn];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", h + i);
int u, v;
while (m--) {
scanf("%d %d", &u, &v);
G[++cnt] = {v, head[u]}, head[u] = cnt;
deg[v]++;
}
for (int i = 1; i <= n; i++)
if (!deg[i]) Q.push(i);
int c = 0;
while (!Q.empty()) {
u = Q.front(), Q.pop();
a[c++] = u;
for (int i = head[u]; i; i = G[i].nxt)
if (!(--deg[G[i].to])) Q.push(G[i].to);
}
int val = 0;
while (c--) {
for (int i = head[a[c]]; i; i = G[i].nxt) vis[bel[G[i].to]] = true;
while (vis[bel[a[c]]]) bel[a[c]]++;
if (bel[a[c]] > val) val = bel[a[c]];
for (int i = head[a[c]]; i; i = G[i].nxt) vis[bel[G[i].to]] = false;
}
for (int i = 1; i <= n; i++) nim[bel[i]] ^= h[i];
int p = -1;
for (int i = val; i >= 0; i--)
if (nim[i]) {
p = i;
break;
}
if (p == -1) {
printf("LOSE\n");
return 0;
}
for (int i = 1; i <= n; i++)
if (bel[i] == p && (nim[bel[i]] ^ h[i]) <= h[i]) {
h[i] ^= nim[bel[i]], vis[bel[i]] = true;
for (int j = head[i]; j; j = G[j].nxt)
if (!vis[bel[G[j].to]])
h[G[j].to] ^= nim[bel[G[j].to]], vis[bel[G[j].to]] = true;
break;
}
printf("WIN\n");
for (int i = 1; i <= n; i++) printf("%d ", h[i]);
printf("\n");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[200000 + 5];
vector<int> E[200000 + 5];
int ind[200000 + 5];
int rk[200000 + 5];
int sg[200000 + 5];
void topo() {
static bool vis[200000 + 5];
queue<int> q;
vector<int> seq;
for (int i = 1; i <= n; i++)
if (ind[i] == 0) q.push(i);
while (!q.empty()) {
int x = q.front();
q.pop();
seq.push_back(x);
for (int y : E[x]) {
ind[y]--;
if (ind[y] == 0) q.push(y);
}
}
for (int i = seq.size() - 1; i >= 0; i--) {
int x = seq[i];
for (int y : E[x]) vis[rk[y]] = 1;
while (vis[rk[x]]) rk[x]++;
for (int y : E[x]) vis[rk[y]] = 0;
}
}
int main() {
int u, v;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &u, &v);
E[u].push_back(v);
ind[v]++;
}
topo();
for (int i = 1; i <= n; i++) sg[rk[i]] ^= a[i];
int pos = -1;
for (int i = n; i >= 0; i--) {
if (sg[i] != 0) {
pos = i;
break;
}
}
if (pos == -1)
puts("LOSE");
else {
puts("WIN");
for (int i = 1; i <= n; i++) {
if (rk[i] == pos) {
if ((sg[rk[i]] ^ a[i]) <= a[i]) {
a[i] ^= sg[rk[i]];
sg[rk[i]] = 0;
for (int y : E[i]) {
a[y] ^= sg[rk[y]];
sg[rk[y]] = 0;
}
}
}
}
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 2e5 + 100;
int stack_sizes[MaxN];
vector<int> adj[MaxN];
int N, M;
int vertex_group_idx[MaxN];
bool visited[MaxN];
int group_xor[MaxN];
vector<int> vertex_groups[MaxN];
void DfsMakeLayers(int vert) {
visited[vert] = true;
vector<int> seen_layers;
for (int s : adj[vert]) {
if (!visited[s]) {
DfsMakeLayers(s);
}
seen_layers.push_back(vertex_group_idx[s]);
}
sort(seen_layers.begin(), seen_layers.end());
seen_layers.resize(unique(seen_layers.begin(), seen_layers.end()) -
seen_layers.begin());
seen_layers.push_back(1e9);
while (seen_layers[vertex_group_idx[vert]] == vertex_group_idx[vert]) {
++vertex_group_idx[vert];
}
const int group_id = vertex_group_idx[vert];
group_xor[group_id] ^= stack_sizes[vert];
vertex_groups[group_id].push_back(vert);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> N >> M;
for (int i = 0; i < N; ++i) {
cin >> stack_sizes[i];
}
for (int i = 0; i < M; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
adj[u].push_back(v);
}
for (int vert = 0; vert < N; ++vert) {
if (!visited[vert]) {
DfsMakeLayers(vert);
}
}
if (count(group_xor, group_xor + N, 0) == N) {
cout << "LOSE\n";
return 0;
}
int last_idx = N;
while (group_xor[last_idx] == 0) --last_idx;
int touched_vertex = -1;
for (int vert : vertex_groups[last_idx]) {
if ((stack_sizes[vert] ^ group_xor[last_idx]) < stack_sizes[vert]) {
touched_vertex = vert;
break;
}
}
assert(touched_vertex != -1);
stack_sizes[touched_vertex] ^= group_xor[last_idx];
group_xor[last_idx] = 0;
for (int neigh : adj[touched_vertex]) {
const int group_idx = vertex_group_idx[neigh];
stack_sizes[neigh] ^= group_xor[group_idx];
group_xor[group_idx] = 0;
}
assert(count(group_xor, group_xor + N, 0) == N);
cout << "WIN\n";
for (int i = 0; i < N; ++i) cout << stack_sizes[i] << " ";
cout << "\n";
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9 + 10;
const ll inf_ll = 1e18 + 10;
const int N = 2e5 + 5;
int h[N], f[N], l[N], v[N];
vector<int> adj[N];
void dfs(int i) {
v[i] = 1;
vector<int> d;
for (auto& j : adj[i]) {
if (!v[j]) dfs(j);
d.push_back(l[j]);
}
sort((d).begin(), (d).end());
for (auto& x : d)
if (l[i] == x) l[i]++;
f[l[i]] ^= h[i];
}
void dfs2(int i) {
;
for (auto& j : adj[i])
if (l[j] == l[i] - 1) {
dfs2(j);
break;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> h[i];
while (m--) {
int x, y;
cin >> x >> y;
adj[x - 1].push_back(y - 1);
}
for (int i = 0; i < n; i++)
if (!v[i]) dfs(i);
if (*max_element(f, f + n) == 0)
cout << "LOSE\n";
else {
cout << "WIN\n";
int k = 0;
for (int i = 0; i < n; i++)
if (f[i] != 0) k = i;
int r = 1 << (31 - __builtin_clz(f[k]));
;
for (int i = 0; i < n; i++)
if (l[i] == k && (r & h[i])) {
h[i] ^= f[l[i]];
for (auto& j : adj[i]) h[j] ^= f[l[j]], f[l[j]] = 0;
break;
}
for (int i = 0; i < n; i++) cout << h[i] << " \n"[i == n - 1];
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
bool t = false;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') t = true, ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - 48, ch = getchar();
return t ? -x : x;
}
vector<int> E[200200];
int n, m, h[200200], sg[200200], sum[200200];
int dg[200200], Q[200200], vis[200200];
void Topsort() {
int h = 1, t = 0;
for (int i = 1; i <= n; ++i)
if (!dg[i]) Q[++t] = i;
while (h <= t) {
int u = Q[h++];
for (int v : E[u])
if (!--dg[v]) Q[++t] = v;
}
}
int main() {
n = read();
m = read();
for (int i = 1; i <= n; ++i) h[i] = read();
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
E[u].push_back(v);
++dg[v];
}
Topsort();
for (int i = n; i; --i) {
int u = Q[i];
for (int v : E[u]) vis[sg[v]] = i;
while (vis[sg[u]] == i) ++sg[u];
sum[sg[u]] ^= h[u];
}
for (int i = n; ~i; --i)
if (sum[i]) {
int pos;
for (int j = 1; j <= n; ++j)
if (sg[j] == i && h[j] > (sum[i] ^ h[j])) pos = j;
h[pos] ^= sum[i];
for (int v : E[pos]) h[v] ^= sum[sg[v]], sum[sg[v]] = 0;
puts("WIN");
for (int j = 1; j <= n; ++j) printf("%d ", h[j]);
puts("");
return 0;
}
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<vector<int>> adj(n);
vector<int> deg(n);
for (int i = 0; i < m; ++i) {
int from, to;
cin >> from >> to;
--from;
--to;
adj[from].push_back(to);
++deg[to];
}
vector<int> order;
for (int i = 0; i < n; ++i) {
if (!deg[i]) {
order.push_back(i);
}
}
for (int i = 0; i < n; ++i) {
int x = order[i];
for (auto y : adj[x]) {
if (!--deg[y]) {
order.push_back(y);
}
}
}
vector<int> last(n + 1, -1);
vector<int> nim(n);
vector<int> sg(n);
for (int i = n - 1; ~i; --i) {
int x = order[i];
for (auto y : adj[x]) {
last[sg[y]] = x;
}
while (last[sg[x]] == x) {
++sg[x];
}
nim[sg[x]] ^= a[x];
}
int high = -1;
for (int i = 0; i < n; ++i) {
if (nim[i]) {
high = i;
}
}
if (high == -1) {
cout << "LOSE"
<< "\n";
} else {
cout << "WIN"
<< "\n";
for (int i = 0; i < n; ++i) {
if (sg[i] == high && a[i] >= (a[i] ^ nim[sg[i]])) {
a[i] ^= nim[sg[i]];
nim[sg[i]] = 0;
for (auto j : adj[i]) {
a[j] ^= nim[sg[j]];
nim[sg[j]] = 0;
}
break;
}
}
for (int i = 0; i < n; ++i) {
if (i) {
cout << " ";
}
cout << a[i];
}
cout << "\n";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int T, n, m, head[200010], o = 0, deg[200010], id[200010], val[200010],
a[200010];
bool vis[200010];
queue<int> q;
struct edge {
int to, link, w;
} e[400010];
void add_edge(int u, int v) {
e[++o].to = v, e[o].link = head[u], head[u] = o, e[o].w = 1;
e[++o].to = u, e[o].link = head[v], head[v] = o, e[o].w = 0;
deg[u]++;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1, u, v; i <= m; i++) scanf("%d%d", &u, &v), add_edge(u, v);
for (int i = 1; i <= n; i++)
if (!deg[i]) q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i; i = e[i].link)
if (e[i].w) vis[id[e[i].to]] = true;
while (vis[id[u]]) id[u]++;
for (int i = head[u]; i; i = e[i].link)
if (e[i].w) vis[id[e[i].to]] = false;
val[id[u]] ^= a[u];
for (int i = head[u]; i; i = e[i].link)
if (!e[i].w) {
if (!(--deg[e[i].to])) q.push(e[i].to);
}
}
int pos = -1;
for (int i = 0; i <= n; i++)
if (val[i]) pos = i;
if (pos < 0) return puts("LOSE"), 0;
for (int i = 1; i <= n; i++)
if (id[i] == pos) {
if ((val[id[i]] ^ a[i]) >= a[i]) continue;
a[i] ^= val[id[i]], val[id[i]] = 0;
for (int j = head[i]; j; j = e[j].link)
if (e[j].w) {
a[e[j].to] ^= val[id[e[j].to]], val[id[e[j].to]] = 0;
}
break;
}
puts("WIN");
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
puts("");
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[200005], in[200005], tag[200005], sg[200005], sum[200005];
vector<int> Ef[200005], Eb[200005], tt[200005];
queue<int> q;
void tpsort() {
for (int i = 1; i <= n; i++)
if (!in[i]) q.push(i), tt[0].push_back(i);
while (!q.empty()) {
int x = q.front();
q.pop();
for (auto y : Eb[x]) {
if (!(--in[y])) {
for (auto z : Ef[y]) tag[sg[z]] = y;
while (tag[sg[y]] == y) ++sg[y];
q.push(y);
tt[sg[y]].push_back(y);
}
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1, u, v; i <= m; i++) {
scanf("%d %d", &u, &v);
Ef[u].push_back(v);
Eb[v].push_back(u);
++in[u];
}
tpsort();
for (int i = 0; i <= n; i++) {
for (auto x : tt[i]) sum[i] ^= a[x];
}
for (int i = n; ~i; i--) {
if (!sum[i]) continue;
int id = 0;
for (auto x : tt[i]) {
if (a[x] > (sum[i] ^ a[x])) {
id = x;
break;
}
}
a[id] ^= sum[i];
for (auto y : Ef[id]) {
a[y] ^= sum[sg[y]];
sum[sg[y]] = 0;
}
puts("WIN");
for (int j = 1; j <= n; j++) printf("%d ", a[j]);
puts("");
return 0;
}
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
vector<int> ve1[maxn], ve2[maxn];
int rd[maxn];
int n, m;
int sm[maxn], h[maxn];
queue<int> q;
int mx[maxn];
int vis[maxn];
vector<int> veo[maxn];
bool mark[maxn];
void ptans() {
for (int i = 1; i <= n; i++) {
printf("%d ", h[i]);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &h[i]);
}
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
ve1[x].push_back(y);
ve2[y].push_back(x);
rd[x]++;
}
for (int i = 1; i <= n; i++) {
if (!rd[i]) q.push(i);
}
while (q.size()) {
int x = q.front();
q.pop();
for (auto y : ve1[x]) {
vis[mx[y]] = x;
}
for (auto y : ve2[x]) {
if (--rd[y] == 0) q.push(y);
}
for (mx[x] = 0; vis[mx[x]] == x; ++mx[x])
;
}
for (int i = 1; i <= n; i++) {
sm[mx[i]] ^= h[i];
veo[mx[i]].push_back(i);
}
for (int p = n; p >= 0; --p) {
if (sm[p]) {
puts("WIN");
for (auto x : veo[p]) {
if ((h[x] ^ sm[p]) < h[x]) {
h[x] ^= sm[p];
for (auto y : ve1[x]) {
if (mark[mx[y]]) continue;
mark[mx[y]] = 1;
h[y] ^= sm[mx[y]];
}
ptans();
return 0;
}
}
}
}
puts("LOSE");
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int h[200000];
vector<int> node[200000];
int done[200000];
vector<int> topo;
void dfs(int p) {
if (done[p]++) return;
for (int i : node[p]) {
dfs(i);
}
topo.push_back(p);
}
int grundy[200000];
int grundy2[200000];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> h[i];
while (m--) {
int a, b;
cin >> a >> b;
a--, b--;
node[a].push_back(b);
}
for (int i = 0; i < n; i++) dfs(i);
for (int p : topo) {
vector<int> v;
for (int i : node[p]) v.push_back(grundy[i]);
sort(v.begin(), v.end());
int x = 0;
while (binary_search(v.begin(), v.end(), x)) x++;
grundy[p] = x;
grundy2[x] ^= h[p];
}
int high = 0;
long long lose = 1;
for (int i = 0; i < n; i++)
if (grundy2[i]) {
lose = 0;
high = max(high, i);
}
if (lose) {
cout << "LOSE" << endl;
return 0;
}
for (int p = 0; p < n; p++) {
int x = grundy[p];
if (x == high && (h[p] >> 31 - __builtin_clz(grundy2[x]) & 1)) {
assert(grundy2[x] >> 31 - __builtin_clz(grundy2[x]) & 1);
h[p] ^= grundy2[x];
grundy2[x] = 0;
for (int i : node[p]) {
h[i] ^= grundy2[grundy[i]];
grundy2[grundy[i]] = 0;
}
cout << "WIN" << endl;
for (int i = 0; i < n; i++) cout << h[i] << ' ';
cout << endl;
return 0;
}
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int read() {
bool f = 1;
int x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = 0;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) - 48 + c;
c = getchar();
}
return f ? x : x * -1;
}
char cr[200];
int tt;
inline void print(register int x, register char k = '\n') {
if (!x) putchar('0');
if (x < 0) putchar('-'), x = -x;
while (x) cr[++tt] = x % 10 + '0', x /= 10;
while (tt) putchar(cr[tt--]);
putchar(k);
}
const int maxn = 2e5 + 7;
vector<int> e[maxn];
queue<int> q;
int a[maxn], mex[maxn], nim[maxn], n, m;
int vis[maxn], wh[maxn];
int d[maxn];
bool dfs(int u) {
vis[u] = -1;
for (int v : e[u]) {
if (vis[v] == -1) return 0;
if (vis[v] == 0)
if (!dfs(v)) return 0;
}
vis[u] = 1;
q.push(u);
return 1;
}
signed main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
}
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
e[u].push_back(v);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) dfs(i);
}
for (int i = 1; i <= n; i++) {
int u = q.front();
q.pop();
mex[u] = 1;
for (int v : e[u]) wh[mex[v]] = 1;
while (wh[mex[u]]) {
mex[u]++;
}
nim[mex[u]] ^= a[u];
for (int v : e[u]) wh[mex[v]] = 0;
}
bool f = 0;
int tmp = 0;
for (int i = n; i; i--) {
if (nim[i]) {
f = 1;
tmp = i;
break;
}
}
if (!f) {
puts("LOSE");
return 0;
}
puts("WIN");
for (int u = 1; u <= n; u++) {
if (mex[u] == tmp && (a[u] ^ nim[tmp]) < a[u]) {
a[u] = nim[mex[u]] ^= a[u];
d[mex[u]] = 1;
for (int v : e[u]) {
if (nim[mex[v]] && !d[mex[v]]) {
a[v] = nim[mex[v]] ^= a[v];
d[mex[v]] = 1;
}
}
for (int i = 1; i <= n; i++) {
print(a[i], ' ');
}
return 0;
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int rd() {
int x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
return x * w;
}
int to[N], nt[N], hd[N], dg[N], tot = 1;
void adde(int x, int y) { ++tot, to[tot] = y, nt[tot] = hd[x], hd[x] = tot; }
int n, m, sg[N], sm[N], a[N], sq[N], ts, vs[N], ti;
queue<int> q;
int main() {
n = rd(), m = rd();
for (int i = 1; i <= n; ++i) a[i] = rd();
for (int i = 1; i <= m; ++i) {
int x = rd(), y = rd();
adde(x, y), ++dg[y];
}
for (int i = 1; i <= n; ++i)
if (!dg[i]) q.push(i);
while (!q.empty()) {
int x = q.front();
q.pop();
sq[++ts] = x;
for (int i = hd[x]; i; i = nt[i]) {
int y = to[i];
--dg[y];
if (!dg[y]) q.push(y);
}
}
for (int i = n; i; --i) {
int x = sq[i];
++ti;
for (int j = hd[x]; j; j = nt[j]) vs[sg[to[j]]] = ti;
while (vs[sg[x]] == ti) ++sg[x];
}
for (int i = 1; i <= n; ++i) sm[sg[i]] ^= a[i];
for (int i = n; ~i; --i)
if (sm[i]) {
int x = 1;
while (sg[x] != i || (a[x] ^ sm[i]) > a[x]) ++x;
a[x] = a[x] ^ sm[i];
++ti;
for (int j = hd[x]; j; j = nt[j]) {
int y = to[j];
if (sg[y] >= i || vs[sg[y]] == ti) continue;
vs[sg[y]] = ti, a[y] = a[y] ^ sm[sg[y]];
}
puts("WIN");
for (int j = 1; j <= n; ++j) printf("%d ", a[j]);
exit(0);
}
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxik = 2e5 + 10;
int g[maxik];
vector<int> rodes[maxik];
void dfs(int curr) {
bool us[rodes[curr].size() + 1];
memset(us, 0, rodes[curr].size() + 1);
for (int i = 0; i < rodes[curr].size(); i++) {
int neighbour = rodes[curr][i];
if (g[neighbour] == -1) {
dfs(neighbour);
}
if (g[neighbour] <= rodes[curr].size()) {
us[g[neighbour]] = 1;
}
}
for (int i = 0; i > -1; i++) {
if (us[i] == 0) {
g[curr] = i;
break;
}
}
}
int main() {
int n, m;
cin >> n >> m;
int tax[n], value[n];
for (int i = 0; i < n; i++) {
cin >> tax[i];
value[i] = 0;
g[i] = -1;
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
rodes[u].push_back(v);
}
for (int i = 0; i < n; i++) {
if (g[i] == -1) {
dfs(i);
}
value[g[i]] = value[g[i]] ^ tax[i];
}
for (int i = n - 1; i >= 0; i--) {
if (value[i]) {
int befor = -1;
for (int j = 0; j < n; j++) {
if (g[j] == i && (value[i] ^ tax[j]) < tax[j]) {
befor = j;
}
}
tax[befor] = value[i] ^ tax[befor];
value[i] = 0;
for (int j = 0; j < rodes[befor].size(); j++) {
int neighbour = rodes[befor][j];
tax[neighbour] = value[g[neighbour]] ^ tax[neighbour];
value[g[neighbour]] = 0;
}
cout << "WIN\n";
for (int j = 0; j < n; j++) {
cout << tax[j] << ' ';
}
return 0;
}
}
cout << "LOSE";
}
| 11 | CPP |
#include <bits/stdc++.h>
const int max_N = 202401;
int n, m, A[max_N], topo[max_N], mex[max_N], xor_sum[max_N];
std::vector<int> G[max_N];
int read_int() {
char c = getchar();
int ans = 0;
bool neg = false;
while (!isdigit(c)) neg |= (c == '-'), c = getchar();
while (isdigit(c)) ans = 10 * ans + c - '0', c = getchar();
return neg ? -ans : ans;
}
void write_int(int x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + '0');
else
write_int(x / 10), putchar(x % 10 + '0');
}
int min(int x, int y) { return x < y ? x : y; }
int max(int x, int y) { return x > y ? x : y; }
void _min(int &x, int y) {
if (x > y) x = y;
}
void _max(int &x, int y) {
if (x < y) x = y;
}
void topo_sort() {
static int deg[max_N];
for (int i = 1; i <= n; i++)
for (int j : G[i]) deg[j]++;
std::queue<int> Q;
for (int i = 1; i <= n; i++)
if (!deg[i]) Q.push(i);
while (!Q.empty()) {
int cur = Q.front();
Q.pop();
topo[++*topo] = cur;
for (int i : G[cur])
if (!--deg[i]) Q.push(i);
}
}
int main() {
n = read_int(), m = read_int();
for (int i = 1; i <= n; i++) A[i] = read_int();
for (int i = 1, u, v; i <= m; i++)
u = read_int(), v = read_int(), G[u].push_back(v);
topo_sort();
for (int i = n; i; i--) {
static int tmp[max_N];
for (int j : G[topo[i]]) tmp[mex[j]]++;
while (tmp[mex[topo[i]]]) mex[topo[i]]++;
for (int j : G[topo[i]]) tmp[mex[j]]--;
xor_sum[mex[topo[i]]] ^= A[topo[i]];
}
if (std::count(xor_sum, xor_sum + n + 1, 0) == n + 1)
puts("LOSE");
else {
puts("WIN");
int X = n, Y = -1;
while (xor_sum[X] == 0) X--;
for (int i = 1; i <= n; i++)
if (mex[i] == X && (A[i] ^ xor_sum[X]) < A[i]) {
Y = i;
break;
}
A[Y] ^= xor_sum[X];
for (int i : G[Y])
if (xor_sum[mex[i]]) A[i] ^= xor_sum[mex[i]], xor_sum[mex[i]] = 0;
for (int i = 1; i <= n; i++) write_int(A[i]), putchar(i == n ? '\n' : ' ');
}
return 0;
}
| 11 | CPP |
#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 = 200005;
int h[N], dp[N], vis[N], to[N], rd[N], q[N];
vector<int> f[N], g[N];
int main() {
int n = read(), m = read();
for (int i = (int)(1); i <= (int)(n); i++) h[i] = read();
for (int i = (int)(1); i <= (int)(m); i++) {
int s = read(), t = read();
f[s].push_back(t);
g[t].push_back(s);
rd[s]++;
}
for (int i = (int)(1); i <= (int)(n); i++)
if (!rd[i]) q[++*q] = i;
for (int i = (int)(1); i <= (int)(*q); i++) {
int t = q[i];
for (auto j : f[t]) vis[dp[j]] = 1;
for (int j = 0;; j++)
if (!vis[j]) {
dp[t] = j;
to[dp[t]] ^= h[t];
break;
}
for (auto j : f[t]) vis[dp[j]] = 0;
for (auto j : g[t])
if (--rd[j] == 0) q[++*q] = j;
}
for (int i = (int)(n); i >= (int)(0); i--)
if (to[i]) {
puts("WIN");
for (int j = (int)(1); j <= (int)(n); j++)
if (dp[j] == i && (h[j] ^ to[i]) < h[j]) {
h[j] ^= to[i];
for (auto k : f[j]) {
h[k] ^= to[dp[k]];
to[dp[k]] = 0;
}
break;
}
for (int i = (int)(1); i <= (int)(n); i++) wri(h[i]);
puts("");
return 0;
}
puts("LOSE");
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 2;
vector<int> adj[N], in[N], idx[N];
int mex[N], val[N], h[N], deg[N];
bool used[N];
queue<int> lis;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, i, j, k, l, max1;
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> h[i];
}
for (i = 1; i <= m; i++) {
cin >> j >> k;
adj[j].push_back(k);
deg[j]++;
in[k].push_back(j);
}
for (i = 1; i <= n; i++) {
if (!deg[i]) {
lis.push(i);
}
}
while (lis.size()) {
int x = lis.front();
lis.pop();
for (i = 0; i < adj[x].size(); i++) {
used[mex[adj[x][i]]] = true;
}
for (i = 0; i < in[x].size(); i++) {
deg[in[x][i]]--;
if (!deg[in[x][i]]) {
lis.push(in[x][i]);
}
}
j = 0;
while (used[j]) {
j++;
}
for (i = 0; i < adj[x].size(); i++) {
used[mex[adj[x][i]]] = false;
}
idx[j].push_back(x);
mex[x] = j;
val[j] ^= h[x];
}
for (i = n; i > -1; i--) {
if (val[i] > 0) {
max1 = i;
break;
} else {
if (i == 0) {
cout << "LOSE";
return 0;
}
}
}
cout << "WIN\n";
for (i = 0; i < idx[max1].size(); i++) {
int x = idx[max1][i];
if (h[x] > (h[x] ^ val[max1])) {
h[x] ^= val[max1];
val[max1] = 0;
for (j = 0; j < adj[x].size(); j++) {
if (val[mex[adj[x][j]]]) {
h[adj[x][j]] ^= val[mex[adj[x][j]]];
val[mex[adj[x][j]]] = 0;
}
}
break;
}
}
for (i = 1; i <= n; i++) {
cout << h[i] << ' ';
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
struct edge {
int to, nxt;
};
edge G[maxn];
int head[maxn], cnt;
int h[maxn], deg[maxn];
queue<int> Q;
int a[maxn];
bool vis[maxn];
int bel[maxn];
int nim[maxn];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", h + i);
int u, v;
while (m--) {
scanf("%d %d", &u, &v);
G[++cnt] = {v, head[u]}, head[u] = cnt;
deg[v]++;
}
for (int i = 1; i <= n; i++)
if (!deg[i]) Q.push(i);
int c = 0;
while (!Q.empty()) {
u = Q.front(), Q.pop();
a[c++] = u;
for (int i = head[u]; i; i = G[i].nxt)
if (!(--deg[G[i].to])) Q.push(G[i].to);
}
int val = 0;
while (c--) {
for (int i = head[a[c]]; i; i = G[i].nxt) vis[bel[G[i].to]] = true;
while (vis[bel[a[c]]]) bel[a[c]]++;
if (bel[a[c]] > val) val = bel[a[c]];
for (int i = head[a[c]]; i; i = G[i].nxt) vis[bel[G[i].to]] = false;
}
for (int i = 1; i <= n; i++) nim[bel[i]] ^= h[i];
int p = -1;
for (int i = val; i >= 0; i--)
if (nim[i]) {
p = i;
break;
}
if (p == -1) {
printf("LOSE\n");
return 0;
}
for (int i = 1; i <= n; i++)
if (bel[i] == p && (nim[bel[i]] ^ h[i]) <= h[i]) {
h[i] ^= nim[bel[i]], vis[bel[i]] = true;
for (int j = head[i]; j; j = G[j].nxt)
if (!vis[bel[G[j].to]])
h[G[j].to] ^= nim[bel[G[j].to]], vis[bel[G[j].to]] = true;
break;
}
printf("WIN\n");
for (int i = 1; i <= n; i++) printf("%d ", h[i]);
printf("\n");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353, N = 210000;
int n, m, dgr[N], cnt, rev[N], lev[N];
long long a[N], sum[N];
vector<int> to[N], pos[N];
priority_queue<int, vector<int>, greater<int> > que;
inline void addEdg(int x, int y) {
to[x].push_back(y), ++dgr[y];
return;
}
void topoSort() {
queue<int> que;
for (register int i = 1; i <= n; ++i)
if (!dgr[i]) que.push(i);
while (que.size()) {
int now = que.front();
que.pop(), rev[++cnt] = now;
for (auto &v : to[now])
if (!--dgr[v]) que.push(v);
}
return;
}
inline int addMod(int a, int b) { return (a += b) >= mod ? a - mod : a; }
inline long long quickpow(long long base, long long pw) {
long long ret = 1;
while (pw) {
if (pw & 1) ret = ret * base % mod;
base = base * base % mod, pw >>= 1;
}
return ret;
}
template <class T>
inline void read(T &x) {
x = 0;
char ch = getchar(), w = 0;
while (!isdigit(ch)) w = (ch == '-'), ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
x = w ? -x : x;
return;
}
int main() {
int x, y;
read(n), read(m);
for (register int i = 1; i <= n; ++i) read(a[i]);
for (register int i = 1; i <= m; ++i) read(x), read(y), addEdg(x, y);
topoSort();
for (register int i = n; i; --i) {
int now = rev[i];
while (que.size()) que.pop();
for (auto &v : to[now]) que.push(lev[v]);
while (que.size()) {
while (que.size() && que.top() != lev[now]) que.pop();
if (que.size()) ++lev[now];
}
sum[lev[now]] ^= a[now];
pos[lev[now]].push_back(now);
}
for (register int i = n; ~i; --i) {
if (!sum[i]) continue;
printf("WIN\n");
int maxP = 0;
for (auto &v : pos[i])
if ((a[v] & sum[i]) >= (a[maxP] & sum[i])) maxP = v;
a[maxP] ^= sum[i];
for (auto &v : to[maxP]) a[v] ^= sum[lev[v]], sum[lev[v]] = 0;
for (register int j = 1; j <= n; ++j) printf("%lld ", a[j]);
return 0;
}
printf("LOSE\n");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int N = 200010;
int n, m;
int a[N], deg[N], sg[N], ans[N];
vector<int> G[N], vec;
inline void topo() {
queue<int> q;
for (int i = (1); i <= (n); ++i)
if (!deg[i]) q.push(i);
while (!q.empty()) {
int f = q.front();
q.pop();
vec.push_back(f);
for (int i = (0); i < (G[f].size()); ++i) {
deg[G[f][i]]--;
if (!deg[G[f][i]]) q.push(G[f][i]);
}
}
bool vis[N] = {0};
for (int i = (n - 1); i >= (0); --i) {
for (int j = (0); j < (G[vec[i]].size()); ++j) vis[sg[G[vec[i]][j]]] = 1;
while (vis[sg[vec[i]]]) sg[vec[i]]++;
for (int j = (0); j < (G[vec[i]].size()); ++j) vis[sg[G[vec[i]][j]]] = 0;
}
}
int main() {
n = read();
m = read();
for (int i = (1); i <= (n); ++i) a[i] = read();
for (int i = (1); i <= (m); ++i) {
int u = read(), v = read();
G[u].push_back(v);
deg[v]++;
}
topo();
int maxx = -1, maxy = 0, id = -1;
for (int i = (1); i <= (n); ++i) {
if (maxx < sg[i]) maxx = sg[i];
ans[sg[i]] ^= a[i];
}
int pd = 0;
for (int i = (0); i <= (n); ++i) pd |= ans[i], maxx = (ans[i] ? i : maxx);
for (int i = (1); i <= (n); ++i)
if (sg[i] == maxx && (ans[maxx] ^ a[i]) < a[i]) {
id = i;
break;
}
if (!pd) return puts("LOSE"), 0;
assert(id != -1);
puts("WIN");
a[id] ^= ans[sg[id]];
for (int i = (0); i < (G[id].size()); ++i)
a[G[id][i]] ^= ans[sg[G[id][i]]], ans[sg[G[id][i]]] = 0;
for (int i = (1); i <= (n); ++i) printf("%d%c", a[i], i == n ? 10 : 32);
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010, M = 200010;
int n, m;
int e, to[M], nxt[M], hd[N], deg[N];
int tag[N], sg[N], val[N], sum[N];
vector<int> vec[N];
void add(int x, int y) {
to[++e] = y;
nxt[e] = hd[x];
hd[x] = e;
}
void topo() {
queue<int> q;
for (int i = 1; i <= n; i++)
if (deg[i] == 0) q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = hd[u]; i; i = nxt[i]) {
int v = to[i];
deg[v]--;
if (deg[v] == 0) q.push(v);
}
for (int i = 0; i < vec[u].size(); i++) {
int v = vec[u][i];
tag[sg[v]] = u;
}
while (tag[sg[u]] == u) sg[u]++;
sum[sg[u]] ^= val[u];
}
return;
}
void solve() {
for (int i = n; i >= 0; i--) {
if (!sum[i]) continue;
int pos = 0;
for (int j = 1; j <= n; j++)
if (sg[j] == i && (val[j] ^ sum[i]) < val[j]) pos = j;
val[pos] ^= sum[i];
for (int j = 0; j < vec[pos].size(); j++) {
int v = vec[pos][j];
val[v] ^= sum[sg[v]];
sum[sg[v]] = 0;
}
puts("WIN");
for (int j = 1; j <= n; j++) printf("%d ", val[j]);
puts("");
return;
}
puts("LOSE");
return;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
vec[u].push_back(v);
add(v, u);
deg[u]++;
}
topo();
solve();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, m;
int h[maxn], in[maxn], q[maxn], sg[maxn], sum[maxn], vis[maxn];
vector<int> G[maxn];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &h[i]);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
++in[v];
}
int l = 1, r = 0;
for (int i = 1; i <= n; ++i)
if (!in[i]) q[++r] = i;
while (l <= r) {
int u = q[l++];
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (!--in[v]) q[++r] = v;
}
}
for (int i = n; i; --i) {
int u = q[i];
for (int j = 0; j < G[u].size(); ++j) {
int v = G[u][j];
vis[sg[v]] = 1;
}
for (; vis[sg[u]]; ++sg[u])
;
for (int j = 0; j < G[u].size(); ++j) {
int v = G[u][j];
vis[sg[v]] = 0;
}
}
for (int i = 1; i <= n; ++i) sum[sg[i]] ^= h[i];
int p = -1;
for (int i = n; ~i; --i)
if (sum[i]) {
p = i;
break;
}
if (p == -1) {
puts("LOSE");
return 0;
}
puts("WIN");
for (int i = 1; i <= n; ++i)
if (sg[i] == p) {
if ((sum[p] ^ h[i]) > h[i]) continue;
h[i] ^= sum[p];
for (int j = 0; j < G[i].size(); ++j) {
int v = G[i][j];
h[v] ^= sum[sg[v]];
sum[sg[v]] = 0;
}
break;
}
for (int i = 1; i <= n; ++i) printf("%d ", h[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, m, eid, cnt, p[N], h[N], d[N], vis[N], sg[N], sum[N], b[N];
struct edge {
int V, nxt;
} e[N << 1];
inline void addedge(int u, int v) { e[++eid] = (edge){v, p[u]}, p[u] = eid; }
inline void tuopu() {
queue<int> q;
while (!q.empty()) q.pop();
for (int i = (1); i <= (n); i++)
if (d[i] == 0) q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop(), b[++cnt] = u;
for (int i = p[u], v = e[i].V; i; i = e[i].nxt, v = e[i].V)
if (!--d[v]) q.push(v);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); i++) scanf("%d", &h[i]);
for (int i = (1); i <= (m); i++) {
int u, v;
scanf("%d%d", &u, &v);
addedge(u, v), d[v]++;
}
tuopu();
for (int i = (cnt); i >= (1); i--) {
int u = b[i];
for (int j = p[u], v = e[j].V; j; j = e[j].nxt, v = e[j].V) vis[sg[v]] = u;
for (int j = (0); j <= (n); j++)
if (vis[j] ^ u) {
sum[sg[u] = j] ^= h[u];
break;
}
}
for (int i = (n - 1); i >= (0); i--)
if (sum[i]) {
puts("WIN");
for (int u = (1); u <= (n); u++)
if (sg[u] == i && (h[u] ^ sum[i]) < h[u]) {
h[u] ^= sum[i];
for (int j = p[u], v = e[j].V; j; j = e[j].nxt, v = e[j].V)
h[v] ^= sum[sg[v]], sum[sg[v]] = 0;
for (int j = (1); j <= (n); j++) printf("%d ", h[j]);
return 0;
}
}
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int w = 1, s = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') w = -1;
ch = getchar();
}
while (isdigit(ch)) {
s = s * 10 + ch - '0';
ch = getchar();
}
return w * s;
}
int n, m, h[1001000], Sum[1010010], Sg[1010010], tag[1010010], du[1010010],
Seq[1010000], cnt;
vector<int> vec[1010100];
queue<int> q;
inline void Top_Sort() {
for (register int i = 1; i <= n; ++i)
if (!du[i]) q.push(i), Seq[++cnt] = i;
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto x : vec[u]) {
du[x]--;
if (!du[x]) q.push(x), Seq[++cnt] = x;
}
}
}
int main() {
n = read(), m = read();
for (register int i = 1; i <= n; ++i) h[i] = read();
for (register int i = 1; i <= m; ++i) {
int u = read(), v = read();
vec[u].push_back(v);
du[v]++;
}
Top_Sort();
for (register int i = n; i >= 1; --i) {
int u = Seq[i];
for (auto x : vec[u]) {
tag[Sg[x]] = i;
}
while (tag[Sg[u]] == i) Sg[u]++;
Sum[Sg[u]] ^= h[u];
}
for (register int i = n; i >= 0; --i) {
if (Sum[i]) {
int xx = 0;
for (register int j = 1; j <= n; ++j)
if ((Sg[j] == i) && (h[j] > (h[j] ^ Sum[i]))) xx = j;
h[xx] = h[xx] ^ Sum[i];
for (auto x : vec[xx]) h[x] = Sum[Sg[x]] ^ h[x], Sum[Sg[x]] = 0;
cout << "WIN\n";
for (register int i = 1; i <= n; ++i) cout << h[i] << " ";
exit(0);
}
}
cout << "LOSE\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
int f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
template <class I>
inline void gi(I &x) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = (x << 1) + (x << 3) + (c & 15);
x *= f;
}
template <class I>
inline void get(I &x) {
for (c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < 'A' || c > 'Z';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
;
x = c;
}
inline void read(char *s) {
for (c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < 'A' || c > 'Z';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
;
for (; c >= 'A' && c <= 'Z';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
*++s = c;
*++s = '\0';
}
template <class I>
inline void print(I x) {
if (!x) putc('0');
if (x < 0) putc('-'), x = -x;
while (x) qu[++qr] = x % 10 + '0', x /= 10;
while (qr) putc(qu[qr--]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::get;
using io ::gi;
using io ::print;
using io ::putc;
using io ::read;
const int N = 2e5 + 5;
vector<int> e[N], v[N];
int deg[N], q[N], num[N], vis[N];
long long h[N], val[N];
int main() {
register int n, m, i, x, y, l, r, cnt;
gi(n);
gi(m);
for (i = 1; i <= n; ++i) gi(h[i]);
while (m--) gi(x), gi(y), ++deg[x], e[y].push_back(x), v[x].push_back(y);
l = 1;
r = 0;
for (i = 1; i <= n; ++i)
if (!deg[i]) q[++r] = i;
cnt = 0;
while (l <= r) {
x = q[l++];
for (auto y : v[x]) vis[num[y]] = 1;
while (vis[num[x]]) ++num[x];
for (auto y : v[x]) vis[num[y]] = 0;
cnt = max(cnt, num[x]);
for (auto y : e[x])
if (!--deg[y]) q[++r] = y;
}
for (i = 1; i <= n; ++i) val[num[i]] ^= h[i];
for (i = cnt; i >= 0; --i)
if (val[i]) {
putc('W');
putc('I');
putc('N');
putc('\n');
for (x = 1; x <= n; ++x)
if (num[x] == i && h[x] > (h[x] ^ val[i])) {
h[x] ^= val[i];
for (auto y : v[x]) h[y] ^= val[num[y]], val[num[y]] = 0;
for (i = 1; i <= n; ++i) print(h[i]), putc(' ');
putc('\n');
return 0;
}
}
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
const int N = 200200;
using namespace std;
int n;
int q;
int h[N];
int m[N];
int t[N];
vector<int> v[N];
void dfs(int x) {
if (t[x]) {
return;
}
set<int> s;
for (int y : v[x]) {
dfs(y);
s.insert(t[y]);
}
t[x] = 1;
while (s.find(t[x]) != s.end()) {
t[x] += 1;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
for (int i = 1; i <= q; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
}
for (int i = 1; i <= n; i++) {
dfs(i);
m[t[i]] ^= h[i];
}
int last = -1;
for (int i = 1; i <= n; i++) {
if (m[i]) {
last = i;
}
}
if (last == -1) {
cout << "LOSE"
<< "\n";
return 0;
}
cout << "WIN"
<< "\n";
for (int i = 1; i <= n; i++) {
if (t[i] == last && (m[t[i]] ^ h[i]) < h[i]) {
h[i] = m[t[i]] ^ h[i];
for (int j : v[i]) {
m[t[j]] ^= h[j];
h[j] = m[t[j]];
m[t[j]] = 0;
}
break;
}
}
for (int i = 1; i <= n; i++) {
cout << h[i] << " \n"[i == n];
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int read();
int n, m;
vector<int> e[200005];
int deg[200005];
void add(int f, int t) { e[f].push_back(t), ++deg[t]; }
queue<int> q;
int h[200005], sg[200005], mx, sum[200005];
vector<int> nx[200005];
void work() {
for (int i = 1; i <= n; ++i)
if (!deg[i]) q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop(), sort(nx[u].begin(), nx[u].end());
for (int x : nx[u])
if (x > sg[u])
break;
else if (x == sg[u])
++sg[u];
sg[u] > mx ? mx = sg[u] : 0;
for (int v : e[u]) nx[v].push_back(sg[u]), --deg[v] ? void() : q.push(v);
}
for (int i = 1; i <= n; ++i) sum[sg[i]] ^= h[i];
for (int i = 0; i <= mx; ++i)
if (sum[i]) return puts("WIN"), void();
puts("LOSE"), void();
}
int vis[200005];
void solve(int d) {
int u;
for (u = 1; u <= n; ++u)
if (sg[u] == d && h[u] > (sum[d] ^ h[u])) break;
h[u] = sum[d] ^ h[u];
for (int v = 1; v <= n; ++v) {
if (sum[sg[v]]) {
int flg = 0;
for (int t : e[v])
if (t == u) flg = 1, h[v] = sum[sg[v]] ^ h[v];
if (!flg) continue;
sum[sg[v]] = 0;
}
}
for (int i = 1; i <= n; ++i) printf("%d ", h[i]);
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; ++i) h[i] = read();
for (int i = 1; i <= m; ++i) add(read(), read());
work();
for (int i = mx; i >= 0; --i)
if (sum[i]) return solve(i), 0;
return 0;
}
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') f = (c == '-') ? -1 : f, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m, h[N], q[N], d[N], s[N], vis[N], sg[N];
vector<int> g[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &h[i]);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
d[v]++;
}
int ql = 1, qr = 0;
for (int i = 1; i <= n; i++)
if (!d[i]) q[++qr] = i;
while (ql <= qr) {
int x = q[ql++];
for (int i = 0; i < g[x].size(); i++)
if (!--d[g[x][i]]) q[++qr] = g[x][i];
}
for (int i = n; i; i--) {
int x = q[i];
for (int j = 0; j < g[x].size(); j++) vis[sg[g[x][j]]] = i;
while (vis[sg[x]] == i) sg[x]++;
s[sg[x]] ^= h[x];
}
for (int i = n; ~i; i--)
if (s[i]) {
int x;
for (int j = 1; j <= n; j++)
if (sg[j] == i && h[j] > (s[i] ^ h[j])) x = j;
h[x] ^= s[sg[x]];
for (int j = 0; j < g[x].size(); j++)
h[g[x][j]] ^= s[sg[g[x][j]]], s[sg[g[x][j]]] = 0;
puts("WIN");
for (int j = 1; j <= n; j++) printf("%d ", h[j]);
return 0;
}
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
vector<int> E[N];
int n, m, h[N], deg[N], vis[N], sg[N], sum[N], sq[N], tt = 0;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> h[i];
for (int i = 1, u, v; i <= m; i++) cin >> u >> v, ++deg[v], E[u].push_back(v);
queue<int> q;
for (int i = 1; i <= n; i++)
if (!deg[i]) q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop();
sq[++tt] = u;
for (auto v : E[u])
if (!--deg[v]) q.push(v);
}
for (int i = tt, u; i; i--) {
u = sq[i];
for (auto v : E[u]) vis[sg[v]] = u;
for (int j = 0;; j++)
if (vis[j] ^ u) {
sum[sg[u] = j] ^= h[u];
break;
}
}
for (int i = n - 1; ~i; i--)
if (sum[i]) {
puts("WIN");
for (int u = 1; u <= n; u++)
if (sg[u] == i && (h[u] ^ sum[i]) < h[u]) {
h[u] ^= sum[i];
for (auto v : E[u]) h[v] ^= sum[sg[v]], sum[sg[v]] = 0;
for (int v = 1; v <= n; v++) cout << h[v] << ' ';
return 0;
}
}
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int v[500500];
vector<int> L[500500];
int xl[500500];
int lvl[500500];
void go(int x) {
if (lvl[x]) return;
map<int, int> mp;
for (int i = 0; i < L[x].size(); i++) {
go(L[x][i]);
mp[lvl[L[x][i]]] = 1;
}
lvl[x] = 1;
while (mp[lvl[x]]) lvl[x]++;
xl[lvl[x]] ^= v[x];
}
int has(int a, int b) { return (a | b) == a; }
int bit(int a) {
while (a != (a & -a)) a -= a & -a;
return a;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", v + i);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b), a--, b--;
L[a].push_back(b);
}
for (int i = 0; i < n; i++) go(i);
for (int i = 0; i < n; i++) ("%d ", lvl[i]);
("\n");
int u = n;
while (u > 0 && xl[u] == 0) u--;
if (u == 0) {
printf("LOSE\n");
return 0;
}
printf("WIN\n");
int vx = 0;
while (lvl[vx] != u || !has(v[vx], bit(xl[u]))) vx++;
("u %d vx %d\n", u, vx);
v[vx] ^= xl[u];
for (int i = 0; i < L[vx].size(); i++) {
int to = L[vx][i];
v[to] ^= xl[lvl[to]];
xl[lvl[to]] = 0;
}
for (int i = 0; i < n; i++) printf("%d ", v[i]);
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 1;
int read() {
int x = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return x;
}
vector<int> to[maxn];
int h[maxn], SG[maxn], sum[maxn];
int c[maxn], deg[maxn], que[maxn];
int n, m, hd = 1, tl = 1;
int main() {
n = read(), m = read();
for (int i = 1; i <= n; ++i) h[i] = read();
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
to[u].push_back(v);
++deg[v];
}
for (int i = 1; i <= n; ++i)
if (!deg[i]) que[tl++] = i;
while (hd ^ tl) {
int u = que[hd++];
for (auto v : to[u])
if (!--deg[v]) que[tl++] = v;
}
for (int i = n; i; --i) {
int u = que[i];
for (auto v : to[u]) ++c[SG[v]];
while (c[SG[u]]) ++SG[u];
sum[SG[u]] ^= h[u];
for (auto v : to[u]) --c[SG[v]];
}
for (int i = n, u; ~i; --i)
if (sum[i]) {
for (int j = 1; j <= n; ++j)
if (SG[j] == i && h[j] > (h[j] ^ sum[i])) u = j;
h[u] ^= sum[i];
for (auto v : to[u]) h[v] ^= sum[SG[v]], sum[SG[v]] = 0;
puts("WIN");
for (int j = 1; j <= n; ++j) printf("%d ", h[j]);
return 0;
}
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200500;
vector<int> side[maxn];
int n, m, val[maxn];
long long h[maxn], x[maxn], mx;
void dfs(int u) {
if (val[u] != -1) return;
bool vis[705] = {0};
for (int i = 0; i < side[u].size(); i++) {
int v = side[u][i];
dfs(v);
vis[val[v]] = 1;
}
for (int i = 0; i < 705; i++) {
if (!vis[i]) {
val[u] = i;
break;
}
}
x[val[u]] ^= h[u];
mx = max(val[u] * 1ll, mx);
}
int main() {
memset(val, -1, sizeof(val));
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%lld", &h[i]);
for (int i = 1, u, v; i <= m; i++)
scanf("%d%d", &u, &v), side[u].push_back(v);
for (int i = 1; i <= n; i++) dfs(i);
for (int i = mx; i >= 0; i--) {
if (x[i]) {
printf("WIN\n");
for (int j = 1; j <= n; j++) {
if (val[j] == i && (h[j] ^ x[i]) < h[j]) {
h[j] = h[j] ^ x[i];
x[i] = 0;
for (int k = 0; k < side[j].size(); k++) {
int v = side[j][k];
if (!x[val[v]]) continue;
h[v] = h[v] ^ x[val[v]];
x[val[v]] = 0;
}
break;
}
}
for (int j = 1; j <= n; j++) printf("%lld ", h[j]);
return 0;
}
}
printf("LOSE\n");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
register long long x = 0, f = 1;
register char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = 0;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + (ch ^ '0');
ch = getchar();
}
return f ? x : -x;
}
const int N = 2e5 + 5;
int n, m, id[N], vis[N];
long long h[N], sum[N];
vector<int> E[N];
void dfs(int u) {
for (int v : E[u])
if (!id[v]) dfs(v);
for (int v : E[u]) vis[id[v]] = 1;
for (id[u] = 1; vis[id[u]]; ++id[u])
;
sum[id[u]] ^= h[u];
for (int v : E[u]) vis[id[v]] = 0;
}
int main() {
n = read(), m = read();
for (int i = (1), _ed = (n); i <= _ed; ++i) h[i] = read();
for (int i = (1), _ed = (m); i <= _ed; ++i) {
int u = read(), v = read();
E[u].push_back(v);
}
for (int i = (1), _ed = (n); i <= _ed; ++i)
if (!id[i]) dfs(i);
int p = 0;
for (int i = (n), _ed = (1); i >= _ed; --i)
if (sum[i]) {
p = i;
break;
}
if (!p)
return puts("LOSE"), 0;
else
puts("WIN");
int rt = 0;
for (int i = (1), _ed = (n); i <= _ed; ++i) {
if (id[i] ^ p) continue;
if (h[i] > (h[i] ^ sum[p])) {
rt = i;
break;
}
}
h[rt] = h[rt] ^ sum[p], sum[p] = 0;
for (int v : E[rt]) {
if (!sum[id[v]]) continue;
h[v] = h[v] ^ sum[id[v]], sum[id[v]] = 0;
}
for (int i = (1), _ed = (n); i <= _ed; ++i)
printf("%lld%c", h[i], " \n"[i == n]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int n, m, i, j, t, k, s, head[maxn], N, in[maxn], b[maxn], sg[maxn];
long long a[maxn], val[maxn];
bool vis[maxn];
struct Edge {
int nxt, aim;
} edge[maxn];
inline void add_edge(int x, int y) {
edge[++N] = (Edge){head[x], y};
head[x] = N;
}
queue<int> Q;
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) scanf("%lld", &a[i]);
for (i = 1; i <= m; ++i) {
scanf("%d%d", &t, &k);
add_edge(t, k);
++in[k];
}
for (i = 1; i <= n; ++i)
if (!in[i]) Q.push(i);
k = 0;
while (!Q.empty()) {
t = Q.front();
Q.pop();
b[++k] = t;
for (i = head[t]; i; i = edge[i].nxt) {
int des = edge[i].aim;
--in[des];
if (!in[des]) Q.push(des);
}
}
for (i = n; i > 0; --i) {
for (j = head[b[i]]; j; j = edge[j].nxt) vis[sg[edge[j].aim]] = 1;
t = 0;
while (vis[t]) ++t;
sg[b[i]] = t;
val[t] ^= a[b[i]];
for (j = head[b[i]]; j; j = edge[j].nxt) vis[sg[edge[j].aim]] = 0;
}
t = -1;
for (i = 0; i <= n; ++i)
if (val[i] > 0) t = i;
if (t == -1) {
printf("LOSE\n");
return 0;
}
printf("WIN\n");
for (i = 1; i <= n; ++i)
if (sg[i] == t && (a[i] ^ val[sg[i]]) < a[i]) {
a[i] ^= val[sg[i]];
val[sg[i]] = 0;
for (j = head[i]; j; j = edge[j].nxt) {
a[edge[j].aim] ^= val[sg[edge[j].aim]];
val[sg[edge[j].aim]] = 0;
}
break;
}
for (i = 1; i <= n; ++i) printf("%lld%c", a[i], (i == n ? '\n' : ' '));
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> a[200005];
struct edge {
int to, nxt;
} e[200005];
int hed[200005], cnt;
inline void add(int u, int v) {
e[++cnt] = (edge){v, hed[u]};
hed[u] = cnt;
}
int num[200005], ru[200005];
int sg[200005], tag[200005], dep[200005];
inline void topo() {
queue<int> q;
for (int i = 1; i <= n; ++i)
if (!ru[i]) q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < a[u].size(); ++i) tag[dep[a[u][i]]] = u;
while (tag[dep[u]] == u) dep[u]++;
sg[dep[u]] ^= num[u];
for (int i = hed[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (--ru[v] == 0) q.push(v);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", num + i);
int u, v;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &u, &v);
a[u].push_back(v), add(v, u), ru[u]++;
}
topo();
for (int i = n; i >= 0; --i) {
if (sg[i] == 0) continue;
for (int j = 1; j <= n; ++j) {
if (dep[j] == i && num[j] > (num[j] ^ sg[i])) {
u = j;
break;
}
}
num[u] ^= sg[i];
for (int j = 0; j < a[u].size(); ++j) {
int v = a[u][j];
num[v] ^= sg[dep[v]], sg[dep[v]] = 0;
}
printf("WIN\n");
for (int j = 1; j <= n; ++j) printf("%d ", num[j]);
return 0;
}
printf("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
int f = 0;
x = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) f |= (ch == '-');
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
if (f) x = -x;
}
const int N = 200005;
int h[N], q[N], dp[N], in[N], f[N], vis[N];
int n, m, l, r, u, v, p;
vector<int> e[N];
int main() {
read(n), read(m), p = n;
for (int i = (1); i <= (n); i++) read(h[i]);
for (int i = (1); i <= (m); i++) read(u), read(v), e[u].push_back(v), in[v]++;
for (int i = (1); i <= (n); i++)
if (!in[i]) q[r++] = i;
for (int u = q[l++]; l <= r; u = q[l++])
for (auto v : e[u])
if (!(--in[v])) q[r++] = v;
for (int i = (n - 1); i >= (0); i--) {
int u = q[i];
for (auto v : e[u]) vis[dp[v]] = 1;
while (vis[dp[u]]) dp[u]++;
for (auto v : e[u]) vis[dp[v]] = 0;
f[dp[u]] ^= h[u];
}
while (p >= 0 && !f[p]) p--;
if (p == -1) return puts("LOSE"), 0;
for (int u = (1); u <= (n); u++)
if (dp[u] == p && (h[u] ^ f[p]) < h[u]) {
h[u] ^= f[p], f[p] = 0;
for (auto v : e[u]) h[v] ^= f[dp[v]], f[dp[v]] = 0;
}
puts("WIN");
for (int i = (1); i <= (n); i++) printf("%d ", h[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int Q = 1 << 18;
struct gra {
int las[Q], e[Q], nn[Q], inc;
void ins(int x, int y) {
e[++inc] = y;
nn[inc] = las[x];
las[x] = inc;
}
} g, f;
int mex[Q];
int vis[Q];
int h[Q], sm[Q];
int q[Q];
int in[Q];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &h[i]);
for (int i = 1, x, y; i <= m; i++)
scanf("%d%d", &x, &y), g.ins(x, y), f.ins(y, x), ++in[x];
int hd = 1, tl = 0;
for (int i = 1; i <= n; i++)
if (!in[i]) q[++tl] = i;
for (int t = 1; t <= n; t++) {
int x = q[hd++];
for (int t = g.las[x]; t; t = g.nn[t]) {
int y = g.e[t];
vis[mex[y]] = x;
}
for (mex[x] = 0; vis[mex[x]] == x; ++mex[x])
;
for (int t = f.las[x]; t; t = f.nn[t]) {
int y = f.e[t];
--in[y];
if (!in[y]) q[++tl] = y;
}
}
int flag = 0;
for (int i = 1; i <= n; i++) sm[mex[i]] ^= h[i];
for (int p = n; p >= 0; --p)
if (sm[p]) {
puts("WIN");
for (int i = 1; i <= n; i++)
if (mex[i] == p && (h[i] ^ sm[p]) < h[i]) {
h[i] ^= sm[p];
for (int t = g.las[i]; t; t = g.nn[t]) {
int y = g.e[t];
if (vis[mex[y]] == n + 1) continue;
vis[mex[y]] = n + 1;
h[y] ^= sm[mex[y]];
}
for (int j = 1; j <= n; j++) printf("%d ", h[j]);
return 0;
}
}
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &item) {
out << '(' << item.first << ", " << item.second << ')';
return out;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
for (const auto &item : v) out << item << ' ';
return out;
}
const int NMAX = 200010;
int h[NMAX];
int mex[NMAX], xorMex[NMAX];
vector<int> adj[NMAX];
void dfs(int v) {
set<int> s;
for (auto u : adj[v]) {
if (mex[u] == -1) dfs(u);
s.insert(mex[u]);
}
int i;
for (i = 0; s.count(i); ++i)
;
mex[v] = i;
xorMex[i] ^= h[v];
}
int main() {
ios_base::sync_with_stdio(false);
int i, n, m, a, b;
cin >> n >> m;
for (i = 1; i <= n; ++i) cin >> h[i];
for (i = 1; i <= m; ++i) {
cin >> a >> b;
adj[a].push_back(b);
}
memset(mex, -1, sizeof mex);
for (i = 1; i <= n; ++i)
if (mex[i] == -1) dfs(i);
for (i = n; i >= 0; --i) {
if (!xorMex[i]) continue;
cout << "WIN\n";
for (int v = 1; v <= n; ++v)
if (mex[v] == i && h[v] >= (h[v] ^ xorMex[i])) {
h[v] ^= xorMex[i];
for (auto u : adj[v]) {
h[u] ^= xorMex[mex[u]];
xorMex[mex[u]] = 0;
}
break;
}
for (int v = 1; v <= n; ++v) cout << h[v] << ' ';
cout << '\n';
return 0;
}
cout << "LOSE\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int level[200005];
int h[200005];
int val[200005];
bool vis[200005];
bool num[200005];
vector<int> E[200005];
void dfs(int x) {
if (vis[x]) return;
vis[x] = true;
if (E[x].size() == 0) level[x] = 0;
int sz = E[x].size();
for (int v : E[x]) {
if (!vis[v]) {
dfs(v);
}
}
for (int i = 0; i <= sz + 1; i++) num[i] = true;
for (int v : E[x]) num[level[v]] = false;
for (int i = 0; i <= sz + 1; i++) {
if (num[i]) {
level[x] = i;
return;
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &h[i]);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
E[u].push_back(v);
}
for (int i = 1; i <= n; i++) level[i] = -1;
for (int i = 1; i <= n; i++) vis[i] = false;
for (int i = 1; i <= n; i++) {
if (!vis[i]) dfs(i);
}
int mx = 0;
for (int i = 0; i <= mx; i++) val[i] = 0;
int choose = 0;
for (int i = 1; i <= n; i++) {
val[level[i]] ^= h[i];
}
for (int i = 1; i <= n; i++) {
if (val[level[i]] != 0) mx = max(mx, level[i]);
}
bool flag = true;
for (int i = 0; i <= mx; i++)
if (val[i] != 0) flag = false;
if (flag) {
puts("LOSE");
return 0;
}
for (int i = 1; i <= n; i++) {
if (level[i] == mx) {
if ((val[mx] ^ h[i]) < h[i]) {
choose = i;
break;
}
}
}
h[choose] = val[mx] ^ h[choose];
for (int v : E[choose]) {
int x = level[v];
if (val[x] != 0) {
h[v] = val[x] ^ h[v];
val[x] = 0;
}
}
puts("WIN");
for (int i = 1; i <= n; i++) {
printf("%d ", h[i]);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, m, num[200100], sy[200100], ds[200100], bj[200100], sum[200100];
vector<long long> to[200100], pre[200100];
queue<long long> que;
int main() {
long long i, j, t, p, q;
cin >> n >> m;
for (i = 1; i <= n; i++) scanf("%lld", &num[i]);
for (i = 1; i <= m; i++) {
scanf("%lld%lld", &p, &q);
pre[q].push_back(p);
to[p].push_back(q);
ds[p]++;
}
for (i = 1; i <= n; i++)
if (!ds[i]) que.push(i);
for (; !que.empty();) {
q = que.front();
que.pop();
for (i = 0; i < pre[q].size(); i++) {
t = pre[q][i];
ds[t]--;
if (!ds[t]) que.push(t);
}
for (i = 0; i < to[q].size(); i++) {
t = to[q][i];
bj[sy[t]] = q;
}
for (i = 0; bj[i] == q; i++)
;
sy[q] = i;
sum[sy[q]] ^= num[q];
}
for (i = n; i >= 0; i--) {
if (!sum[i]) continue;
puts("WIN");
for (j = 1; j <= n; j++)
if (sy[j] == i && (num[j] ^ sum[i]) < num[j]) break;
q = j, num[q] ^= sum[i];
for (j = 0; j < to[q].size(); j++) {
t = to[q][j];
if (sum[sy[t]] && bj[sy[t]] != -1) {
bj[sy[t]] = -1;
num[t] ^= sum[sy[t]];
}
}
for (i = 1; i <= n; i++) printf("%lld ", num[i]);
return 0;
}
puts("LOSE");
}
| 11 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.