solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
inline void read(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
inline void readc(char &x) {
char c;
while ((c = getchar()) == ' ')
;
x = c;
}
inline void writes(string s) { puts(s.c_str()); }
inline void writeln() { writes(""); }
inline void writei(int x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
inline void writell(long long x) {
if (x < 0) {
putchar('-');
x = abs(x);
}
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
int n, m, i, j, a[200005], f[200005], s[200005], vis[200005], ti, mx;
vector<int> e[200005];
int dfs(int x);
void mex(int x) {
for (__typeof((e[x]).begin()) it = (e[x]).begin(); it != (e[x]).end(); it++)
dfs(*it);
ti++;
for (__typeof((e[x]).begin()) it = (e[x]).begin(); it != (e[x]).end(); it++)
vis[dfs(*it)] = ti;
for (f[x] = 0; vis[f[x]] == ti; f[x]++)
;
}
int dfs(int x) {
if (f[x] != -1) return f[x];
mex(x);
return f[x];
}
void solve(int x) {
a[x] ^= s[mx];
s[mx] = 0;
for (__typeof((e[x]).begin()) it = (e[x]).begin(); it != (e[x]).end(); it++) {
a[*it] ^= s[f[*it]];
s[f[*it]] = 0;
}
for (((i)) = (1); ((i)) <= ((n)); ((i))++) printf("%d ", a[i]);
}
int main() {
read(n);
read(m);
for (((i)) = (1); ((i)) <= ((n)); ((i))++) read(a[i]);
for (((i)) = (1); ((i)) <= ((m)); ((i))++) {
int x, y;
read(x);
read(y);
e[x].push_back(y);
}
memset(f, -1, sizeof(f));
for (((i)) = (1); ((i)) <= ((n)); ((i))++) {
mx = max(mx, dfs(i));
s[dfs(i)] ^= a[i];
}
while (mx >= 0) {
for (((i)) = (1); ((i)) <= ((n)); ((i))++)
if (f[i] == mx && (s[mx] ^ a[i]) < a[i]) {
puts("WIN");
solve(i);
return 0;
}
mx--;
}
{
cout << "LOSE";
return 0;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[200009], h[200009], q[200009], d[200009], s[200009], sg[200009],
bo[200009];
vector<int> e[200009];
bool vis[200009];
int read() {
int x = 0;
char ch = getchar();
bool flag = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') flag = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return flag ? -x : x;
}
long long readll() {
long long x = 0;
char ch = getchar();
bool flag = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') flag = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return flag ? -x : x;
}
int dfs(int x) {
if (vis[x]) return sg[x];
vis[x] = 1;
for (int y : e[x]) sg[y] = dfs(y);
for (int y : e[x]) bo[sg[y]] = x;
for (sg[x] = 0; bo[sg[x]] == x; sg[x]++)
;
s[sg[x]] ^= a[x];
return sg[x];
}
int main() {
scanf("%d%d", &n, &m);
int i, x, y;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
e[x].push_back(y);
d[y]++;
}
for (i = 1; i <= n; i++) sg[i] = dfs(i);
for (i = n; i >= 0; i--)
if (s[i]) break;
if (i == -1) {
puts("LOSE");
return 0;
}
x = i;
memset(vis, 0, sizeof(vis));
for (i = 1; i <= n; i++)
if (sg[i] == x && (a[i] ^ s[x]) < a[i]) {
a[i] ^= s[x];
for (int p : e[i]) {
if (vis[sg[p]]) continue;
vis[sg[p]] = 1;
a[p] ^= s[sg[p]];
}
break;
}
puts("WIN");
for (i = 1; i <= n; i++) printf("%d%c", a[i], i < n ? ' ' : '\n');
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
using vint = vector<long long>;
using pint = pair<long long, long long>;
using vpint = vector<pint>;
template <typename A, typename B>
inline void chmin(A& a, B b) {
if (a > b) a = b;
}
template <typename A, typename B>
inline void chmax(A& a, B b) {
if (a < b) a = b;
}
template <class A, class B>
ostream& operator<<(ostream& ost, const pair<A, B>& p) {
ost << "{" << p.first << "," << p.second << "}";
return ost;
}
template <class T>
ostream& operator<<(ostream& ost, const vector<T>& v) {
ost << "{";
for (long long i = 0; i < v.size(); i++) {
if (i) ost << ",";
ost << v[i];
}
ost << "}";
return ost;
}
long long N, M;
vint G[222222];
long long topbit(long long a) { return 63 - __builtin_clzll(a); }
signed main() {
scanf("%lld%lld", &N, &M);
vint A(N);
for (long long i = 0; i < (N); i++) scanf("%lld", &A[i]);
for (long long i = 0; i < (M); i++) {
long long a, b;
scanf("%lld%lld", &a, &b);
a--;
b--;
G[a].push_back(b);
}
vint ord;
vint deg(N);
for (long long i = 0; i < (N); i++)
for (auto u : G[i]) deg[u]++;
for (long long i = 0; i < (N); i++)
if (deg[i] == 0) ord.push_back(i);
for (long long i = 0; i < (N); i++) {
long long v = ord[i];
for (auto u : G[v]) {
if (--deg[u] == 0) ord.push_back(u);
}
}
reverse((ord).begin(), (ord).end());
vint q(N);
for (auto v : ord) {
set<long long> s;
for (auto u : G[v]) s.insert(q[u]);
q[v] = 0;
while (s.find(q[v]) != s.end()) q[v]++;
}
vint x(N);
for (long long i = 0; i < (N); i++) x[q[i]] ^= A[i];
long long w = -1;
for (long long i = 0; i < (N); i++)
if (x[i]) w = i;
if (w == -1) {
puts("LOSE");
return 0;
}
for (long long i = 0; i < (N); i++) {
if (q[i] != w) continue;
if (!(A[i] >> topbit(x[w]) & 1)) continue;
A[i] ^= x[w];
for (auto u : G[i]) {
A[u] ^= x[q[u]];
x[q[u]] = 0;
}
break;
}
puts("WIN");
for (long long i = 0; i < (N); i++) {
if (i) printf(" ");
printf("%lld", A[i]);
}
puts("");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int h[200200];
struct data {
int to, nxt;
} mp[200200];
int head[200200], cnt;
void link(int x, int y) {
mp[++cnt].to = y;
mp[cnt].nxt = head[x];
head[x] = cnt;
}
int d[200200];
queue<int> q;
vector<int> nx[200200];
int id[200200];
int val[200200];
void Topsort() {
for (int i = 1; i <= n; ++i)
if (!d[i]) q.push(i);
int u, v, la, siz;
while (!q.empty()) {
u = q.front();
q.pop();
sort(nx[u].begin(), nx[u].end());
id[u] = la = -1;
siz = nx[u].size();
for (int i = 0; i < siz; ++i) {
if (nx[u][i] > la + 1) {
id[u] = la + 1;
break;
}
la = nx[u][i];
}
if (id[u] == -1) id[u] = la + 1;
val[id[u]] ^= h[u];
for (int i = head[u]; i; i = mp[i].nxt) {
v = mp[i].to;
d[v]--;
nx[v].push_back(id[u]);
if (!d[v]) q.push(v);
}
}
}
vector<int> ed[200200];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &h[i]);
int xx, yy;
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &xx, &yy);
link(yy, xx);
d[xx]++;
ed[xx].push_back(yy);
}
Topsort();
int fl = 0;
for (int i = 1; i <= n; ++i)
if (val[id[i]]) {
fl = 1;
break;
}
if (!fl) {
puts("LOSE");
return 0;
}
puts("WIN");
int mv = 0, v;
for (int i = 1; i <= n; ++i)
if (val[id[i]]) mv = max(mv, id[i]);
for (int i = 1; i <= n; ++i)
if (id[i] == mv) {
if ((h[i] ^ val[mv]) > h[i]) continue;
h[i] ^= val[mv];
for (int e = 0; e < ed[i].size(); ++e) {
v = ed[i][e];
h[v] ^= val[id[v]];
val[id[v]] = 0;
}
break;
}
for (int i = 1; i <= n; ++i) printf("%d ", h[i]);
puts("");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0;
bool flg = false;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') flg = true;
for (; isdigit(ch); ch = getchar()) x = (x << 3) + (x << 1) + (ch ^ 48);
return flg ? -x : x;
}
int n, m, h[200010], g[200010];
vector<int> e[200010];
int d[200010];
int p[200010], hd, tl;
int sg[200010];
int get(int o) {
static int vis[200010];
for (const int &v : e[o]) vis[sg[v]] = o;
int z = 0;
while (vis[z] == o) ++z;
return z;
}
void work(int o) {
h[o] ^= g[sg[o]];
g[sg[o]] = 0;
for (const int &v : e[o]) {
if (sg[v] >= sg[o]) continue;
int w = g[sg[v]];
h[v] ^= w;
g[sg[v]] ^= w;
}
for (int i(1), _i(n); i <= _i; i++) printf("%d ", h[i]);
puts("");
}
void solve() {
n = read(), m = read();
for (int i(1), _i(n); i <= _i; i++) h[i] = read();
while (m--) {
int u = read(), v = read();
e[u].push_back(v), ++d[v];
}
for (int i(1), _i(n); i <= _i; i++)
if (!d[i]) p[++tl] = i;
while (hd < tl) {
int u = p[++hd];
for (const int &v : e[u])
if (!--d[v]) p[++tl] = v;
}
for (int i(n), _i(1); i >= _i; i--)
sg[p[i]] = get(p[i]), g[sg[p[i]]] ^= h[p[i]];
int q = -1;
for (int i(n), _i(0); i >= _i; i--)
if (g[i]) {
q = i;
break;
}
if (!~q) return puts("LOSE"), void();
puts("WIN");
for (int i(1), _i(n); i <= _i; i++)
if (sg[i] == q && (g[sg[i]] ^ h[i]) < h[i]) {
work(i);
return;
}
assert(0);
}
int main() {
for (int T = 1; T--;) solve();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5, maxm = 2e5 + 5;
int head[maxn], nume;
struct edge {
int v, w, c, next;
} e[maxm];
inline void init_edge() {
memset(head, -1, sizeof head);
nume = 0;
}
inline void add_edge(int u, int v, int w = 0, int c = 0) {
e[nume].v = v;
e[nume].w = w;
e[nume].c = c;
e[nume].next = head[u];
head[u] = nume++;
}
int c[maxn], h[maxn];
long long sg[maxn], a[maxn];
void dfs(int u) {
if (h[u] >= 0) return;
for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].v;
dfs(v);
}
for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].v;
c[h[v]]++;
}
for (int i = 0;; i++) {
if (c[i] == 0) {
h[u] = i;
break;
}
}
for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].v;
c[h[v]]--;
}
}
int n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
init_edge();
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
add_edge(u, v);
}
for (int i = 1; i <= n; i++) h[i] = -1;
for (int i = 1; i <= n; i++) {
if (h[i] == -1) dfs(i);
}
for (int i = 1; i <= n; i++) {
sg[h[i]] ^= a[i];
}
for (int i = n; i >= 0; i--) {
if (sg[i] != 0) {
printf("WIN\n");
for (int j = 1; j <= n; j++) {
if (h[j] == i && (a[j] ^ sg[i]) < a[j]) {
a[j] ^= sg[i];
sg[i] = 0;
for (int k = head[j]; ~k; k = e[k].next) {
int v = e[k].v;
a[v] ^= sg[h[v]];
sg[h[v]] = 0;
}
break;
}
}
for (int j = 1; j <= n; j++) printf("%lld ", a[j]);
break;
}
if (i == 0) {
printf("LOSE");
break;
}
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T read(register T& t) {
register T f = 1;
register char ch = getchar();
t = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -f;
ch = getchar();
}
while (ch >= '0' && ch <= '9') t = t * 10 + ch - '0', ch = getchar();
t *= f;
return t;
}
template <typename T, typename... Args>
inline void read(T& t, Args&... args) {
read(t);
read(args...);
}
const long long p = 998244353;
inline long long power(register long long x, register long long k = p - 2) {
register long long re = 1;
for (; k; k >>= 1, x = x * x % p)
if (k & 1) re = re * x % p;
return re;
}
int n, m;
vector<int> to[200005];
int deg[200005];
int st[200005], st_top;
int id[200005];
long long xum[200005];
long long h[200005];
int main() {
read(n, m);
for (int i = 1; i <= n; i++) read(h[i]);
for (int i = 1, x, y; i <= m; i++) read(x, y), deg[y]++, to[x].push_back(y);
queue<int> q;
for (int i = 1; i <= n; i++)
if (deg[i] == 0) q.push(i);
while (q.size()) {
int now = q.front();
q.pop();
st[++st_top] = now;
for (int i : to[now]) {
deg[i]--;
if (deg[i] == 0) q.push(i);
}
}
static bool vis[200005];
for (int tp = n; tp >= 1; tp--) {
int i = st[tp];
for (int j : to[i]) vis[id[j]] = 1;
while (vis[id[i]]) id[i]++;
for (int j : to[i]) vis[id[j]] = 0;
xum[id[i]] ^= h[i];
}
int pos = -1;
for (int i = 0; i <= n; i++)
if (xum[i]) pos = i;
if (pos == -1) return printf("LOSE\n"), 0;
for (int i = 1; i <= n; i++)
if (id[i] == pos) {
int tp = xum[pos] ^ h[i];
if (tp >= h[i]) continue;
h[i] = tp;
xum[pos] = 0;
for (int j : to[i])
if (xum[id[j]]) {
h[j] = xum[id[j]] ^ h[j];
xum[id[j]] = 0;
}
break;
}
printf("WIN\n");
for (int i = 1; i <= n; i++) printf("%lld ", h[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
vector<int> G[maxn];
int topo[maxn];
int sg[maxn], deg[maxn], mem[maxn];
int Xor[maxn];
long long h[maxn];
int main(void) {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) scanf("%lld", &h[i]);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
deg[v]++;
}
queue<int> q;
int cnt = 1;
for (int i = 1; i <= n; ++i)
if (deg[i] == 0) q.push(i);
while (!q.empty()) {
int p = q.front();
q.pop();
topo[cnt++] = p;
for (auto c : G[p]) {
deg[c]--;
if (deg[c] == 0) q.push(c);
}
}
for (int i = n; i >= 1; --i) {
int u = topo[i];
for (auto c : G[u]) mem[sg[c]] = i;
while (mem[sg[u]] == i) sg[u]++;
Xor[sg[u]] ^= h[u];
}
int index = -1;
for (int i = 0; i < maxn; ++i)
if (Xor[i] != 0) index = i;
if (index == -1) return 0 * puts("LOSE");
for (int i = 1; i <= n; ++i) {
if (sg[i] == index && ((h[i] ^ Xor[index]) < h[i])) {
h[i] ^= Xor[index];
for (auto c : G[i]) {
h[c] ^= Xor[sg[c]];
Xor[sg[c]] = 0;
}
break;
}
}
puts("WIN");
for (int i = 1; i <= n; ++i) printf("%lld ", h[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
std::vector<std::vector<int>> ad;
std::vector<int> fm;
std::vector<bool> tmp;
int f(int x) {
if (fm[x] >= 0) return fm[x];
for (int y : ad[x]) f(y);
for (int y : ad[x]) tmp[fm[y]] = true;
fm[x] = int(std::find(begin(tmp), end(tmp), false) - begin(tmp));
for (int y : ad[x]) {
tmp[fm[y]] = false;
}
return fm[x];
}
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int n, m;
std::cin >> n >> m;
std::vector<int> h(n);
for (int& x : h) std::cin >> x;
ad.resize(n);
for (int z = m; z--;) {
int u, v;
std::cin >> u >> v;
--u;
--v;
ad[u].push_back(v);
}
std::vector<int> val(n);
fm.assign(n, -1);
tmp.resize(n);
for (int i = n; i--;) val[f(i)] ^= h[i];
while (!val.empty() && val.back() == 0) val.pop_back();
if (val.empty()) {
std::cout << "LOSE\n";
return 0;
}
std::cout << "WIN\n";
int i = 0;
while (fm[i] != val.size() - 1 || (h[i] ^ val.back()) > h[i]) {
++i;
}
h[i] ^= val.back();
std::vector<bool> ok(val.size() - 1);
for (int j : ad[i])
if ((unsigned)fm[j] < ok.size() && !ok[fm[j]]) {
ok[fm[j]] = true;
h[j] ^= val[fm[j]];
}
for (auto x : h) std::cout << x << ' ';
std::cout << '\n';
}
| 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;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
template <typename T>
struct hash_map_t {
vector<T> v, val, nxt;
vector<int> head;
int mod, tot, lastv;
T lastans;
bool have_ans;
hash_map_t(int md = 0) {
head.clear();
v.clear();
val.clear();
nxt.clear();
tot = 0;
mod = md;
nxt.resize(1);
v.resize(1);
val.resize(1);
head.resize(mod);
have_ans = 0;
}
void clear() { *this = hash_map_t(mod); }
bool count(int x) {
int u = x % mod;
for (register int i = head[u]; i; i = nxt[i]) {
if (v[i] == x) {
have_ans = 1;
lastv = x;
lastans = val[i];
return 1;
}
}
return 0;
}
void ins(int x, int y) {
int u = x % mod;
nxt.push_back(head[u]);
head[u] = ++tot;
v.push_back(x);
val.push_back(y);
}
int qry(int x) {
if (have_ans && lastv == x) return lastans;
count(x);
return lastans;
}
};
const int N = 2e5 + 5;
struct edge_t {
int u, v, next;
} G[N];
int head[N], h[N], sg[N], sum[N], vis[N], deg[N], q[N];
int n, m, tot, dfn, maxn, hd = 1, tl = 0;
inline void addedge(int u, int v) {
G[++tot] = (edge_t){u, v, head[u]}, head[u] = tot;
}
int main() {
read(n);
read(m);
for (register int i = 1; i <= n; i++) read(h[i]);
for (register int i = 1; i <= m; i++) {
int u, v;
read(u);
read(v);
addedge(u, v);
++deg[v];
}
for (register int i = 1; i <= n; i++)
if (!deg[i]) q[++tl] = i;
while (hd <= tl) {
int u = q[hd++];
for (register int i = head[u]; i; i = G[i].next) {
int v = G[i].v;
--deg[v];
if (!deg[v]) q[++tl] = v;
}
}
for (register int j = n; j >= 1; j--) {
int u = q[j];
++dfn;
for (register int i = head[u]; i; i = G[i].next) vis[sg[G[i].v]] = dfn;
for (register int i = 0; i <= n; i++) {
if (vis[i] != dfn) {
sg[u] = i;
sum[i] ^= h[u];
break;
}
}
maxn = max(maxn, sg[u]);
}
for (register int i = maxn; i >= 0; i--) {
if (sum[i]) {
printf("WIN\n");
for (register int j = 1; j <= n; j++) {
if (sg[j] == i && (h[j] ^ sum[i]) < h[j]) {
h[j] ^= sum[i];
for (register int k = head[j]; k; k = G[k].next) {
int v = G[k].v;
if (sum[sg[v]]) {
h[v] ^= sum[sg[v]];
sum[sg[v]] = 0;
}
}
for (register int k = 1; k <= n; k++)
print(h[k], k == n ? '\n' : ' ');
break;
}
}
return 0;
}
}
printf("LOSE\n");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
const int MM = 998244353;
const long double PI = acos(-1);
template <typename T, typename U>
static inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T &x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << '(' << p.first << "," << p.second << ')';
}
const int N = 200005;
vector<int> v[N];
long long h[N];
int mex[N];
bitset<N> vis;
vector<int> mexv[N];
void dfs(int s) {
vis[s] = 1;
set<int> st;
for (auto &j : v[s]) {
if (!vis[j]) dfs(j);
st.insert(mex[j]);
}
for (int i = 0;; ++i) {
if (!st.count(i)) {
mex[s] = i;
break;
}
}
mexv[mex[s]].push_back(s);
}
int _runtimeTerror_() {
int n, m;
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;
v[x].push_back(y);
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) dfs(i);
}
int win = -1;
for (int i = 0;; ++i) {
if (mexv[i].empty()) break;
long long Xor = 0;
for (auto &j : mexv[i]) Xor ^= h[j];
if (Xor != 0) amax(win, i);
}
if (win == -1) {
cout << "LOSE\n";
return 0;
}
cout << "WIN\n";
vector<long long> ans(n + 1);
for (int i = 1; i <= n; ++i) ans[i] = h[i];
long long Xor = 0;
for (auto &j : mexv[win]) Xor ^= h[j];
for (auto &j : mexv[win]) {
if ((Xor ^ h[j]) < h[j]) {
ans[j] = Xor ^ h[j];
vector<int> x(win, -1);
for (int i : v[j]) {
if (mex[i] > win) continue;
if (x[mex[i]] == -1) x[mex[i]] = i;
}
for (int i = win - 1; i >= 0; --i) {
long long y = 0;
for (auto &k : mexv[i]) y ^= h[k];
ans[x[i]] = y ^ h[x[i]];
}
break;
}
}
for (int i = 1; i <= n; ++i) cout << ans[i] << " ";
cout << "\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) _runtimeTerror_();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
const int N = 200054, M = N;
int V, E;
int w[N], W[N], deg[N];
int to[M], first[N], next[M];
int topo[N], mark[N], sg[N];
inline void up(int &x, const int y) { x < y ? x = y : 0; }
inline void addedge(int u, int v, int id) {
to[id] = v, next[id] = first[u], first[u] = id, ++deg[v];
}
int main() {
int i, j, u, v, x, y, h, t = 0;
scanf("%d%d", &V, &E);
for (i = 1; i <= V; ++i) scanf("%d", w + i);
for (i = 1; i <= E; ++i) scanf("%d%d", &u, &v), addedge(u, v, i);
for (i = 1; i <= V; ++i)
if (!deg[i]) topo[t++] = i;
for (h = 0; h < t; ++h)
for (i = first[x = topo[h]]; i; i = next[i])
if (!--deg[y = to[i]]) topo[t++] = y;
assert(t == V), v = 0;
for (j = V - 1; j >= 0; --j) {
for (i = first[x = topo[j]]; i; i = next[i]) mark[sg[y = to[i]]] = x;
for (i = 0; mark[i] == x; ++i)
;
up(v, sg[x] = i), W[i] ^= w[x];
}
for (i = v; i >= 0 && !W[i]; --i)
;
if (!~i) return puts("LOSE"), 0;
for (x = 1; x <= V; ++x)
if (sg[x] == i && (w[x] ^ W[i]) < w[x]) break;
assert(x <= V), w[x] ^= W[i], puts("WIN");
for (i = first[x]; i; i = next[i])
y = to[i], j = sg[y], w[y] ^= W[j], W[j] ^= W[j];
for (i = 1; i <= V; ++i) printf("%d%c", w[i], i == V ? 10 : 32);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
inline long long gi() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) f ^= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? x : -x;
}
int h[200010], SG[200010], sum[200010];
int fir[200010], nxt[200010], dis[200010], id;
inline void link(int a, int b) { nxt[++id] = fir[a], fir[a] = id, dis[id] = b; }
int que[200010], hd = 1, tl = 1, in[200010];
int c[200010];
int main() {
int n = gi(), m = gi(), a, b;
for (int i = 1; i <= n; ++i) h[i] = gi();
while (m--) a = gi(), b = gi(), link(a, b), ++in[b];
for (int i = 1; i <= n; ++i)
if (!in[i]) que[tl++] = i;
while (hd ^ tl) {
int x = que[hd++];
for (int i = fir[x]; i; i = nxt[i])
if (!--in[dis[i]]) que[tl++] = dis[i];
}
for (int o = n, x; o; --o) {
x = que[o];
for (int i = fir[x]; i; i = nxt[i]) ++c[SG[dis[i]]];
while (c[SG[x]]) ++SG[x];
sum[SG[x]] ^= h[x];
for (int i = fir[x]; i; i = nxt[i]) --c[SG[dis[i]]];
}
for (int i = n, x; ~i; --i)
if (sum[i]) {
for (int j = 1; j <= n; ++j)
if (SG[j] == i && h[j] > (h[j] ^ sum[i])) x = j;
h[x] ^= sum[i];
for (int j = fir[x]; j; j = nxt[j])
h[dis[j]] ^= sum[SG[dis[j]]], sum[SG[dis[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;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch - '0' < 0 || ch - '0' > 9) {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch - '0' >= 0 && ch - '0' <= 9) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m, top, mx;
int head[200010], nxt[200010], to[200010], tot;
void add(int u, int v) {
tot++;
nxt[tot] = head[u];
head[u] = tot;
to[tot] = v;
}
long long a[200010], val[200010];
int deg[200010], p[200010], vis[200010], id[200010];
queue<int> q;
void top_sort() {
for (int i = 1; i <= n; i++)
if (!deg[i]) q.push(i);
while (q.size()) {
int now = q.front();
q.pop();
p[++top] = now;
for (int i = head[now]; i; i = nxt[i]) {
deg[to[i]]--;
if (!deg[to[i]]) q.push(to[i]);
}
}
for (int i = n; i >= 1; i--) {
int x = p[i];
for (int j = head[x]; j; j = nxt[j]) vis[id[to[j]]] = 1;
while (vis[id[x]]) id[x]++;
val[id[x]] ^= a[x];
mx = max(mx, id[x]);
for (int j = head[x]; j; j = nxt[j]) vis[id[to[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 q = read(), w = read();
add(q, w);
deg[w]++;
}
top_sort();
int pos = -1;
for (int i = 0; i <= mx; i++)
if (val[i]) pos = i;
if (pos == -1) return puts("LOSE"), 0;
puts("WIN");
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 = nxt[j])
a[to[j]] ^= val[id[to[j]]], val[id[to[j]]] = 0;
}
}
for (int i = 1; i <= n; i++) printf("%lld ", a[i]);
puts("");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename _tp>
inline void read(_tp& x) {
char ch = getchar(), ob = 0;
x = 0;
while (ch != '-' && !isdigit(ch)) ch = getchar();
if (ch == '-') ob = 1, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
if (ob) x = -x;
}
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) m = max(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;
const int prime = 999983;
const int INF = 0x7FFFFFFF;
const long long INFF = 0x7FFFFFFFFFFFFFFF;
const double pi = acos(-1.0);
const double inf = 1e18;
const double eps = 1e-6;
const long long mod = 1e9 + 7;
long long qpow(long long a, long long b) {
long long s = 1;
while (b > 0) {
if (b & 1) s = s * a % mod;
a = a * a % mod;
b >>= 1;
}
return s;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int dr[2][4] = {1, -1, 0, 0, 0, 0, -1, 1};
const int maxn = 2e5 + 10;
vector<int> G[maxn];
int topo[maxn];
int sg[maxn], deg[maxn], mem[maxn];
int Xor[maxn];
long long h[maxn];
int main(void) {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) scanf("%lld", &h[i]);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
deg[v]++;
}
queue<int> q;
int cnt = 1;
for (int i = 1; i <= n; ++i)
if (deg[i] == 0) q.push(i);
while (!q.empty()) {
int p = q.front();
q.pop();
topo[cnt++] = p;
for (auto c : G[p]) {
deg[c]--;
if (deg[c] == 0) q.push(c);
}
}
for (int i = n; i >= 1; --i) {
int u = topo[i];
for (auto c : G[u]) mem[sg[c]] = i;
while (mem[sg[u]] == i) sg[u]++;
Xor[sg[u]] ^= h[u];
}
int index = -1;
for (int i = 0; i < maxn; ++i)
if (Xor[i] != 0) index = i;
if (index == -1) return 0 * puts("LOSE");
for (int i = 1; i <= n; ++i) {
if (sg[i] == index && ((h[i] ^ Xor[index]) < h[i])) {
h[i] ^= Xor[index];
for (auto c : G[i]) {
h[c] ^= Xor[sg[c]];
Xor[sg[c]] = 0;
}
break;
}
}
puts("WIN");
for (int i = 1; i <= n; ++i) printf("%lld ", h[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int h[212345];
vector<vector<int> > graph;
vector<int> mex;
vector<int> xors;
int get_mex(int v) {
if (mex[v] != -1) return mex[v];
vector<bool> seen(graph[v].size(), false);
for (auto u : graph[v]) {
int val = get_mex(u);
if (val < seen.size()) seen[val] = true;
}
for (mex[v] = 0; mex[v] < seen.size(); mex[v]++) {
if (!seen[mex[v]]) break;
}
return mex[v];
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &h[i]);
graph.resize(n);
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
graph[a].push_back(b);
}
mex.resize(n, -1);
for (int i = 0; i < n; i++) {
get_mex(i);
}
xors.resize(n, 0);
int maxmex = 0;
for (int i = 0; i < n; i++) {
maxmex = max(maxmex, mex[i]);
xors[mex[i]] ^= h[i];
}
int non_zero_mex = -1;
for (int i = maxmex; i >= 0; i--) {
if (xors[i] != 0) {
non_zero_mex = i;
break;
}
}
if (non_zero_mex == -1) {
printf("LOSE\n");
return 0;
}
int v;
for (v = 0; v < n; v++) {
if (mex[v] == non_zero_mex)
if ((xors[mex[v]] ^ h[v]) < h[v]) break;
}
h[v] ^= xors[mex[v]];
xors[mex[v]] = 0;
for (auto u : graph[v]) {
if (xors[mex[u]] != 0) {
h[u] ^= xors[mex[u]];
xors[mex[u]] = 0;
}
}
printf("WIN\n");
for (int i = 0; i < n; i++) {
printf("%d%c", h[i], (i + 1) == n ? '\n' : ' ');
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
constexpr int inf32 = 0x3f3f3f3f;
constexpr long long inf64 = 0x3f3f3f3f3f3f3f3f;
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
vector<long long> a(n);
for (int u = 0; u < (n); ++u) cin >> a[u];
vector<vector<int> > adj(n);
for (int i = 0; i < (m); ++i) {
int u, v;
cin >> u >> v, --u, --v;
adj[u].push_back(v);
}
int k = 1;
vector<int> g(n, 0), vis(n, 0);
function<void(int)> dfs = [&](int u) {
if (vis[u]) return;
vis[u] = true;
for (const int &v : adj[u]) dfs(v);
vector<int> use(k, 0);
for (const int &v : adj[u]) use[g[v]] = true;
while (g[u] < k && use[g[u]]) ++g[u];
if (g[u] >= k) ++k;
};
for (int u = 0; u < (n); ++u) dfs(u);
vector<long long> f(k, 0);
for (int u = 0; u < (n); ++u) f[g[u]] ^= a[u];
int mx = -1;
for (int i = 0; i < (k); ++i)
if (f[i]) mx = i;
if (!~mx) return !(cout << "LOSE\n");
cout << "WIN\n";
for (int u = 0; u < (n); ++u)
if (g[u] == mx && (a[u] ^ f[mx]) < a[u]) {
a[u] ^= f[mx], f[mx] = 0;
for (const int &v : adj[u]) a[v] ^= f[g[v]], f[g[v]] = 0;
break;
}
for (int u = 0; u < (n); ++u) cout << a[u] << ' ';
cout << '\n';
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)998244353;
const int MAXN = (int)2e5 + 3;
const int infint = (int)1e9 + 3;
const long long inf = (long long)1e18;
int n, m, M[MAXN], visited[MAXN], h[MAXN], t[MAXN];
vector<int> G[MAXN], topol;
void dfs(int u) {
visited[u] = 1;
for (auto v : G[u])
if (!visited[v]) dfs(v);
topol.push_back(u);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> h[i];
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
}
for (int i = 1; i <= n; i++)
if (!visited[i]) dfs(i);
reverse(topol.begin(), topol.end());
for (int i = n - 1; i >= 0; i--) {
if (G[topol[i]].size() == 0)
M[topol[i]] = 0;
else {
vector<int> cur;
for (auto v : G[topol[i]]) cur.push_back(M[v]);
sort(cur.begin(), cur.end());
int ptr = 0;
for (auto v : cur)
if (v == ptr) ptr++;
M[topol[i]] = ptr;
}
}
for (int i = 1; i <= n; i++) t[M[i]] ^= h[i];
int mika = -1;
for (int i = 0; i < n; i++)
if (t[i] > 0) mika = i;
if (mika == -1) return cout << "LOSE\n", 0;
cout << "WIN\n";
int id = -1;
for (int i = 1; i <= n; i++)
if (M[i] == mika && (h[i] ^ t[mika]) < h[i]) id = i;
h[id] ^= t[mika];
memset(visited, 0, sizeof visited);
for (auto v : G[id])
if (!visited[M[v]]) h[v] = h[v] ^ t[M[v]], visited[M[v]] = 1;
for (int i = 1; i <= n; i++) cout << h[i] << " ";
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int MAXN = 200010;
vector<int> x[MAXN], y[MAXN];
int v[MAXN], out[MAXN], sg[MAXN];
int xr[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> v[i];
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
x[a].push_back(b);
y[b].push_back(a);
++out[a];
}
queue<int> Q;
for (int i = 0; i < n; ++i) {
if (out[i] == 0) Q.push(i);
}
int maxsg = 0;
while (!Q.empty()) {
int a = Q.front();
Q.pop();
for (int b : y[a]) {
--out[b];
if (out[b] == 0) {
Q.push(b);
}
}
set<int> s;
for (int b : x[a]) s.insert(sg[b]);
for (int i = 0; i < n; ++i) {
if (s.find(i) == s.end()) {
sg[a] = i;
break;
}
}
maxsg = max(maxsg, sg[a]);
}
for (int i = 0; i < n; ++i) {
xr[sg[i]] ^= v[i];
}
bool win = false;
for (int i = maxsg; i >= 0; --i) {
if (xr[i] != 0) {
win = true;
int p = -1;
for (int j = 0; j < n; ++j) {
if (sg[j] != i) continue;
if (p == -1) {
p = j;
continue;
}
if ((v[j] ^ xr[i]) <= v[j]) p = j;
}
xr[i] ^= v[p];
v[p] = xr[i];
xr[i] = 0;
for (int b : x[p]) {
if (xr[sg[b]] != 0) {
v[b] ^= xr[sg[b]];
xr[sg[b]] = 0;
}
}
break;
}
}
if (win) {
cout << "WIN\n";
for (int i = 0; i < n; ++i) cout << v[i] << " ";
cout << '\n';
} else {
cout << "LOSE\n";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename tp>
inline void read(tp &x) {
x = 0;
char c = getchar();
int f = 0;
for (; c < '0' || c > '9'; f |= c == '-', c = getchar())
;
for (; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + c - '0', c = getchar())
;
if (f) x = -x;
}
const int N = 3e5 + 233;
int n, m, h[N], vis[N], sg[N], sum[N];
vector<int> G[N];
inline void dfs(int u) {
if (vis[u]) return;
vis[u] = true;
vector<int> mark(G[u].size() + 1, 0);
for (int v : G[u]) {
dfs(v);
if (sg[v] < mark.size()) mark[sg[v]] = true;
}
while (mark[sg[u]]) sg[u]++;
sum[sg[u]] ^= h[u];
}
int main(void) {
read(n);
read(m);
for (register int i = 1; i <= (n); i++) read(h[i]);
for (register int i = 1; i <= (m); i++) {
int x, y;
read(x);
read(y);
G[x].push_back(y);
}
for (register int i = 1; i <= (n); i++)
if (!vis[i]) dfs(i);
for (int i = n; i >= 0; i--)
if (sum[i]) {
cout << "WIN\n";
for (register int k = 1; k <= (n); k++)
if (sg[k] == i && h[k] > (h[k] ^ sum[i])) {
auto flip = [](int x) {
h[x] ^= sum[sg[x]];
sum[sg[x]] = 0;
};
flip(k);
for (int v : G[k]) flip(v);
break;
}
for (register int k = 1; k <= (n); k++) cout << h[k] << " \n"[k == n];
return 0;
}
cout << "LOSE\n";
}
| 11 | CPP |
#include <bits/stdc++.h>
const int MAXN = 200010;
int head[MAXN], nxt[MAXN], to[MAXN], ind[MAXN], tot;
void adde(int b, int e) {
nxt[++tot] = head[b];
to[head[b] = tot] = e;
++ind[e];
}
int A[MAXN], mx[MAXN];
std::set<int> S;
int n, m;
std::queue<int> q;
int bfn[MAXN], idx;
int B[MAXN];
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n >> m;
for (int i = 1; i <= n; ++i) std::cin >> A[i];
for (int i = 1, b, e; i <= m; ++i) std::cin >> b >> e, adde(b, e);
for (int i = 1; i <= n; ++i)
if (!ind[i]) q.push(i);
while (!q.empty()) {
int t = q.front();
q.pop();
bfn[++idx] = t;
for (int i = head[t]; i; i = nxt[i])
if (!--ind[to[i]]) q.push(to[i]);
}
for (int T = idx; T; --T) {
const int u = bfn[T];
for (int i = head[u]; i; i = nxt[i]) S.insert(mx[to[i]]);
while (S.count(mx[u])) ++mx[u];
S.clear();
B[mx[u]] ^= A[u];
}
int cur = n;
while (cur >= 0 && !B[cur]) --cur;
if (cur < 0) return std::cout << "LOSE" << std::endl, 0;
for (int u = 1; u <= n; ++u)
if (mx[u] == cur) {
if ((A[u] ^ B[cur]) > A[u]) continue;
A[u] ^= B[cur], B[cur] = 0;
for (int i = head[u]; i; i = nxt[i])
A[to[i]] ^= B[mx[to[i]]], B[mx[to[i]]] = 0;
break;
}
std::cout << "WIN" << std::endl;
for (int i = 1; i <= n; ++i) std::cout << A[i] << ' ';
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> E;
vector<int> G;
vector<int> h;
void dfs(int cur) {
if (G[cur] != -1) return;
set<int> S;
for (int i = 0; i < (E[cur].size()); ++i) {
int to = E[cur][i];
dfs(to);
S.insert(G[to]);
}
for (int i = 0; i < (1000000001); ++i) {
if (!(S.count(i))) {
G[cur] = i;
break;
}
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
h.resize(n);
for (int i = 0; i < (n); ++i) scanf("%d", &h[i]);
E.resize(n);
G.resize(n, -1);
for (int i = 0; i < (m); ++i) {
int u, v;
scanf("%d %d", &u, &v);
u--;
v--;
E[u].push_back(v);
}
for (int i = 0; i < (n); ++i) {
dfs(i);
}
vector<int> Gs(1000, 0);
for (int i = 0; i < (n); ++i) {
Gs[G[i]] ^= h[i];
}
for (int i = 999; i >= 0; i--) {
if (Gs[i] == 0) continue;
int maxi = -1, ind = -1;
for (int j = 0; j < (n); ++j) {
if (G[j] == i) {
if ((Gs[i] ^ h[j]) < h[j]) {
h[j] = Gs[i] ^ h[j];
Gs[i] = 0;
ind = j;
break;
}
}
}
h[ind] = Gs[i] ^ h[ind];
Gs[i] = 0;
for (int j = 0; j < (E[ind].size()); ++j) {
int to = E[ind][j];
h[to] = Gs[G[to]] ^ h[to];
Gs[G[to]] = 0;
}
cout << "WIN" << endl;
for (int j = 0; j < (n); ++j) {
if (j != 0) printf(" ");
printf("%d", h[j]);
}
cout << endl;
return 0;
}
cout << "LOSE" << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class n, class second>
ostream &operator<<(ostream &p, pair<n, second> x) {
return p << "<" << x.first << ", " << x.second << ">";
}
template <class n>
auto operator<<(ostream &p, n y) ->
typename enable_if<!is_same<n, string>::value,
decltype(y.begin(), p)>::type {
int o = 0;
p << "{";
for (auto c : y) {
if (o++) p << ", ";
p << c;
}
return p << "}";
}
void dor() { cerr << endl; }
template <class n, class... second>
void dor(n p, second... y) {
cerr << p << " ";
dor(y...);
}
template <class n, class second>
void mini(n &p, second y) {
if (p > y) p = y;
}
template <class n, class second>
void maxi(n &p, second y) {
if (p < y) p = y;
}
const int M = 1024 * 256;
int H[M], mex[M];
int n, m, out[M], xo[M], xo2[M];
vector<int> V[M], T[M];
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 a, b;
scanf("%d%d", &a, &b);
V[a].push_back(b);
T[b].push_back(a);
out[a]++;
}
queue<int> Q;
for (int i = (1); i <= (int)(n); ++i) {
if (out[i] == 0) {
Q.push(i);
}
}
while (!Q.empty()) {
int v = Q.front();
Q.pop();
vector<int> X;
for (auto x : V[v]) {
X.push_back(mex[x]);
}
sort((X).begin(), (X).end());
X.resize(unique((X).begin(), (X).end()) - X.begin());
X.push_back(1e9);
for (int i = (0); i <= (int)((int)(X).size() - 1); ++i) {
if (X[i] != i) {
mex[v] = i;
break;
}
}
for (auto x : T[v]) {
out[x]--;
if (out[x] == 0) {
Q.push(x);
}
}
xo[mex[v]] ^= H[v];
}
int t = -1;
for (int i = (0); i <= (int)(n); ++i) {
if (xo[i] != 0) {
t = i;
}
}
if (t == -1) {
printf("LOSE\n");
return 0;
}
printf("WIN\n");
bool boo = false;
for (int i = (1); i <= (int)(n); ++i) {
if (mex[i] != t || (xo[t] ^ H[i]) >= H[i]) {
continue;
}
boo = true;
H[i] = xo[t] ^ H[i];
for (auto x : V[i]) {
if (xo[mex[x]] != 0) {
H[x] = xo[mex[x]] ^ H[x];
xo[mex[x]] = 0;
}
}
break;
}
assert(boo);
for (int i = (1); i <= (int)(n); ++i) {
printf("%d ", H[i]);
xo2[mex[i]] ^= H[i];
}
for (int i = (0); i <= (int)(n); ++i) {
assert(xo2[i] == 0);
}
printf("\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;
}
puts("WIN");
for (int j = 1; j <= n; ++j) printf("%d ", num[j]);
return 0;
}
return puts("LOSE"), 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct node {
int t, next;
} a[200010], a1[200010];
vector<int> v[200010];
queue<int> q;
int head[200010], head1[200010], num[200010], out[200010], f[200010],
sum[200010], n, m, tot, tot1;
bool vis[200010];
inline int rd() {
int x = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x;
}
inline void print(int x) {
static char s[233];
if (!x) {
putchar('0');
putchar(' ');
return;
}
int tot = 0;
for (; x; x /= 10) s[++tot] = x % 10 + '0';
for (; tot; tot--) putchar(s[tot]);
putchar(' ');
}
inline void add(int x, int y) {
a[++tot].t = y;
a[tot].next = head[x];
head[x] = tot;
}
inline void add1(int x, int y) {
a1[++tot1].t = y;
a1[tot1].next = head1[x];
head1[x] = tot1;
}
int main() {
n = rd();
m = rd();
tot = tot1 = 0;
for (int i = 1; i <= n; i++) num[i] = rd();
for (int i = 1; i <= m; i++) {
int x = rd(), y = rd();
add(x, y);
add1(y, x);
out[x]++;
}
for (int i = 1; i <= n; i++)
if (!out[i]) q.push(i);
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = head[x]; i; i = a[i].next) vis[f[a[i].t]] = true;
for (int i = 0; i <= n; i++)
if (!vis[i]) {
f[x] = i;
break;
}
for (int i = head[x]; i; i = a[i].next) vis[f[a[i].t]] = false;
v[f[x]].push_back(x);
sum[f[x]] ^= num[x];
for (int i = head1[x]; i; i = a1[i].next) {
int t = a1[i].t;
if (!(--out[t])) q.push(t);
}
}
for (int i = n; ~i; i--)
if (sum[i]) {
puts("WIN");
for (int x : v[i])
if (num[x] >= (sum[i] ^ num[x])) {
num[x] = sum[i] ^ num[x];
for (int j = head[x]; j; j = a[j].next) {
int t = a[j].t;
if (vis[f[t]]) continue;
vis[f[t]] = true;
num[t] = sum[f[t]] ^ num[t];
}
break;
}
for (int j = 1; j <= n; j++) print(num[j]);
putchar('\n');
return 0;
}
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int read() {
char c = getchar();
int x = 0;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - 48, c = getchar();
return x;
}
int n, m;
const int _ = 2e5 + 7;
int val[_], v[_];
vector<int> E[_];
int deg[_];
int st[_], top;
int q[_], h[_];
bool used[_];
int main() {
n = read(), m = read();
for (int i = 1; i <= n; ++i) v[i] = read();
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
E[u].push_back(v);
deg[v]++;
}
int l = 1, r = 0;
for (int i = 1; i <= n; ++i)
if (!deg[i]) q[++r] = i;
while (l <= r) {
int x = q[l++];
st[++top] = x;
for (int i = 0; i < (int)E[x].size(); ++i) {
int y = E[x][i];
deg[y]--;
if (!deg[y]) q[++r] = y;
}
}
while (top) {
int x = st[top];
top--;
for (int i = 0; i < (int)E[x].size(); ++i) {
int y = E[x][i];
used[val[y]] = 1;
}
for (int i = 0; i <= m; ++i) {
if (used[i]) continue;
val[x] = i;
break;
}
for (int i = 0; i < (int)E[x].size(); ++i) {
int y = E[x][i];
used[val[y]] = 0;
}
}
int tag = 0;
for (int i = 1; i <= n; ++i) h[val[i]] ^= v[i];
for (int i = 0; i <= m; ++i) tag |= h[i];
if (!tag) return puts("LOSE"), 0;
puts("WIN");
int mx = 0;
for (int i = 0; i <= m; ++i) {
if (h[i]) mx = i;
}
for (int u = 1; u <= n; ++u) {
if (val[u] == mx && (h[mx] ^ v[u]) < v[u]) {
v[u] = h[mx] ^ v[u];
h[mx] = 0;
for (int i = 0; i < (int)E[u].size(); ++i) {
int y = E[u][i];
if (h[val[y]]) {
v[y] = h[val[y]] ^ v[y];
h[val[y]] = 0;
}
}
break;
}
}
for (int i = 1; i <= n; ++i) printf("%d%c", v[i], " \n"[i == n]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int gi() {
int x = 0, w = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') w = 0, ch = getchar();
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return w ? x : -x;
}
const int N = 2e5 + 5;
int n, m, h[N], in[N], q[N], hd, tl, mrk[N], sg[N], sum[N], vis[N];
vector<int> E[N];
int main() {
n = gi();
m = gi();
for (int i = 1; i <= n; ++i) h[i] = gi();
for (int i = 1, x, y; i <= m; ++i)
x = gi(), ++in[y = gi()], E[x].push_back(y);
for (int i = 1; i <= n; ++i)
if (!in[i]) q[++tl] = i;
while (hd < tl) {
int u = q[++hd];
for (int v : E[u])
if (!--in[v]) q[++tl] = v;
}
for (int i = n; i; --i) {
int u = q[i];
for (int v : E[u]) mrk[sg[v]] = u;
while (mrk[sg[u]] == u) ++sg[u];
sum[sg[u]] ^= h[u];
}
for (int i = n - 1; ~i; --i)
if (sum[i]) {
puts("WIN");
for (int j = 1; j <= n; ++j)
if (sg[j] == i && h[j] > (h[j] ^ sum[i])) {
h[j] ^= sum[i];
for (int v : E[j]) h[v] ^= sum[sg[v]], sum[sg[v]] = 0;
break;
}
for (int j = 1; j <= n; ++j) printf("%d ", h[j]);
return puts(""), 0;
}
return puts("LOSE"), 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long h[200005], s[200005];
int n, m, a, b, ru[200006], mex[200005], fu[200005], ma;
vector<int> x[200005];
int dfs(int now) {
if (mex[now]) return mex[now];
for (int i = 0; i < x[now].size(); i++) dfs(x[now][i]);
for (int i = 0; i < x[now].size(); i++) fu[mex[x[now][i]]] = now;
for (int i = 0; i <= n; i++)
if (fu[i] != now) return mex[now] = i;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%lld", h + i);
for (int j = 1; j <= m; j++) {
scanf("%d%d", &a, &b);
x[a].push_back(b);
ru[b]++;
}
for (int i = 1; i <= n; i++)
if (ru[i] == 0) dfs(i);
for (int i = 1; i <= n; i++) s[mex[i]] ^= h[i];
int ans = 0;
ma = -1;
memset(fu, 0, sizeof(fu));
for (int i = 1; i <= n; i++)
if (s[mex[i]] != 0) fu[mex[i]] = 1, ma = max(ma, mex[i]);
if (~ma) {
puts("WIN");
for (int i = 1; i <= n; i++) {
if (mex[i] == ma && (h[i] ^ s[mex[i]]) < h[i]) {
h[i] ^= s[mex[i]];
for (int j = 0; j < x[i].size(); j++)
if (fu[mex[x[i][j]]])
h[x[i][j]] ^= s[mex[x[i][j]]], fu[mex[x[i][j]]] = 0;
for (int i = 1; i <= n; i++) printf("%lld ", h[i]);
return 0;
}
}
} else
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005, maxm = 200005;
int n, m, e, stp;
int h[maxn], SG[maxn], start[maxn], to[maxm], then[maxm], xorsum[maxn],
deg[maxn], vis[maxn];
vector<int> v[maxn], revg[maxn], g[maxn];
queue<int> q;
inline void add(int x, int y) {
g[x].push_back(y), deg[x]++;
revg[y].push_back(x);
}
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);
add(x, y);
}
for (int i = 1; i <= n; i++)
if (deg[i] == 0) q.push(i);
while (!q.empty()) {
int x = q.front();
q.pop(), stp++;
for (int i = 0; i < revg[x].size(); i++) {
int y = revg[x][i];
deg[y]--;
if (deg[y] == 0) q.push(y);
}
for (int i = 0; i < g[x].size(); i++) vis[SG[g[x][i]]] = stp;
while (vis[SG[x]] == stp) SG[x]++;
xorsum[SG[x]] ^= h[x], v[SG[x]].push_back(x);
}
for (int i = n; i >= 0; i--) {
if (xorsum[i] == 0) continue;
puts("WIN");
int x;
for (int j = 0; j < v[i].size(); j++)
if ((h[v[i][j]] ^ xorsum[i]) < h[v[i][j]]) {
x = v[i][j];
break;
}
h[x] ^= xorsum[SG[x]], xorsum[SG[x]] = 0;
for (int j = 0; j < g[x].size(); j++) {
int y = g[x][j];
h[y] ^= xorsum[SG[y]], xorsum[SG[y]] = 0;
}
for (int j = 1; j <= n; j++) printf("%d%c", h[j], i == n ? '\n' : ' ');
return 0;
}
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int mod = 998244353;
int sum(int a, int b) {
int c = a + b;
if (c >= mod) {
c -= mod;
}
return c;
}
int dif(int a, int b) {
int c = a - b;
if (c < 0) {
c += mod;
}
return c;
}
int mlt(int a, int b) {
long long c = a * 1LL * b;
return c % mod;
}
int ibit(int n, int i) { return ((n >> i) & 1); }
void outp1(vector<long long> &ou, string s = " ") {
cerr << s << endl;
for (int i = 0; i < ou.size(); i++) {
cerr << ou[i] << ' ';
}
cerr << endl;
}
void outp1(vector<int> &ou, string s = " ") {
cerr << s << endl;
for (int i = 0; i < ou.size(); i++) {
cerr << ou[i] << ' ';
}
cerr << endl;
}
void outp2(vector<vector<int>> &ou, string s = " ") {
cerr << s << endl;
for (int i = 0; i < ou.size(); i++) {
for (int j = 0; j < ou[i].size(); j++) {
cerr << ou[i][j] << ' ';
}
cerr << '\n';
}
}
int bp(int x, int y) {
if (y == 0) {
return 1;
}
int a = 0;
if (!(y % 2)) {
a = bp(x, y / 2);
}
return (y % 2) ? mlt(bp(x, y - 1), x) : mlt(a, a);
}
int obr(int x) { return bp(x, mod - 2); }
const int maxn = 301;
int fact[maxn], ofact[maxn];
void prec() {
fact[0] = 1;
ofact[0] = 1;
for (int i = 1; i < maxn; i++) {
fact[i] = mlt(fact[i - 1], i);
}
ofact[maxn - 1] = obr(fact[maxn - 1]);
for (int i = maxn - 2; i > 0; i--) {
ofact[i] = mlt(ofact[i + 1], i + 1);
}
}
int c(int a, int b) {
return ((a <= b) && (a >= 0)) ? mlt(fact[b], mlt(ofact[a], ofact[b - a])) : 0;
}
int inf = 1e9 + 110;
void reverse(vector<vector<int>> &v, vector<int> &sign, long long &sumx,
long long &sumy, int pos, vector<int> &init) {
if (sumx <= 1e6 + 1 && sumx >= -1e6 - 2)
if (sumy <= 1e6 + 1 && sumy >= -1e6 - 2) {
vector<int> reals(v.size());
for (int i = 0; i < v.size(); i++) {
reals[v[i][2]] = sign[i];
}
for (int i = 0; i < v.size(); i++) cout << reals[i] * init[i] << ' ';
cout << '\n';
exit(0);
}
if (sign[pos] == 1) {
sign[pos] = -1;
sumx -= 2 * v[pos][0];
sumy -= 2 * v[pos][1];
} else {
sign[pos] = 1;
sumx += 2 * v[pos][0];
sumy += 2 * v[pos][1];
}
if (sumx <= 1e6 + 2 && sumx >= -1e6 - 2)
if (sumy <= 1e6 + 2 && sumy >= -1e6 - 2) {
vector<int> reals(v.size());
for (int i = 0; i < v.size(); i++) {
reals[v[i][2]] = sign[i];
}
for (int i = 0; i < v.size(); i++) cout << reals[i] * init[i] << ' ';
cout << '\n';
exit(0);
}
}
int mexx(vector<int> &v) {
vector<int> u(v.size() + 2);
for (auto it : v) {
if (it < u.size()) u[it] = 1;
}
for (int i = 0; i < u.size(); i++)
if (u[i] == 0) return i;
}
void solve(istream &cin = std::cin, ostream &cout = std::cout) {
int n, m;
cin >> n >> m;
vector<vector<int>> gr(n), revgr(n);
vector<int> grundy(n, -1), degs(n);
vector<long long> vals(n);
for (int i = 0; i < n; i++) cin >> vals[i];
set<int> zerodeg;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
degs[x]++;
gr[x].push_back(y);
revgr[y].push_back(x);
}
for (int i = 0; i < n; i++)
if (!degs[i]) zerodeg.insert(i);
while (!zerodeg.empty()) {
int a = *zerodeg.begin();
vector<int> v;
for (auto g : gr[a]) v.push_back(grundy[g]);
grundy[a] = mexx(v);
for (auto g : revgr[a]) {
degs[g]--;
if (degs[g] == 0) zerodeg.insert(g);
}
zerodeg.erase(a);
}
vector<int> xors(n + 1);
vector<vector<int>> verts(n + 1);
for (int i = 0; i < n; i++) {
xors[grundy[i]] ^= vals[i];
verts[grundy[i]].push_back(i);
}
int pos = -1;
for (int i = n; i >= 0; i--)
if (xors[i] != 0) {
pos = i;
break;
}
if (pos == -1)
cout << "LOSE" << '\n';
else {
int p1 = -1;
for (auto ver : verts[pos]) {
long long need = vals[ver] ^ xors[pos];
if (need < vals[ver]) {
p1 = ver;
break;
}
}
assert(p1 != -1);
cout << "WIN" << '\n';
vals[p1] = vals[p1] ^ xors[pos];
for (auto ver : gr[p1]) {
int cal = grundy[ver];
vals[ver] = xors[cal] ^ vals[ver];
xors[cal] = 0;
}
for (auto it : vals) cout << it << ' ';
cout << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tests = 1;
for (int i = 0; i < tests; i++) solve();
}
| 11 | CPP |
#include <bits/stdc++.h>
const int N = 200005;
int n, m, sg[N];
bool r[N];
long long a[N], sum[N];
std::vector<int> g[N];
bool vis[N];
int dfs(int x) {
if (~sg[x]) return sg[x];
for (int p : g[x]) dfs(p);
for (int p : g[x]) vis[dfs(p)] = 1;
for (int i = 0;; ++i)
if (!vis[i]) {
sg[x] = i;
break;
}
for (int p : g[x]) vis[dfs(p)] = 0;
return sg[x];
}
void print(int col) {
std::cout << "WIN\n";
int pos = 0;
for (int i = 1; i <= n; ++i)
if (sg[i] == col && (sum[col] ^ a[i]) < a[i]) pos = i;
a[pos] ^= sum[col], sum[col] = 0;
for (int p : g[pos]) a[p] ^= sum[sg[p]], sum[sg[p]] = 0;
for (int i = 1; i <= n; ++i) std::cout << a[i] << ' ';
std::cout << '\n', std::exit(0);
}
int main() {
std::ios::sync_with_stdio(0), std::cin.tie(0);
std::cin >> n >> m;
for (int i = 1; i <= n; ++i) std::cin >> a[i], sg[i] = -1;
for (int i = 0, x, y; i < m; ++i) std::cin >> x >> y, g[x].emplace_back(y);
for (int i = 1; i <= n; ++i) sum[dfs(i)] ^= a[i];
for (int i = n - 1; ~i; --i)
if (sum[i]) print(i);
std::cout << "LOSE\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200005;
long long ver[N << 1], nxt[N << 1], head[N], deg[N], tot;
long long h[N], st[N], vis[N << 1], id[N], t[N << 1], Max, top, n, m;
queue<long long> q;
inline long long read() {
long long x = 0, ff = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') ff = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * ff;
}
void add(long long x, long long y) {
ver[++tot] = y;
nxt[tot] = head[x];
head[x] = tot;
deg[y]++;
}
signed main() {
n = read();
m = read();
for (long long i = 1; i <= n; i++) h[i] = read();
for (long long i = 1; i <= m; i++) {
long long u, v;
u = read();
v = read();
add(u, v);
}
for (long long i = 1; i <= n; i++)
if (!deg[i]) q.push(i);
while (q.size()) {
long long x = q.front();
q.pop();
st[++top] = x;
for (long long i = head[x]; i; i = nxt[i]) {
long long y = ver[i];
deg[y]--;
if (!deg[y]) q.push(y);
}
}
for (long long i = top; i >= 1; i--) {
long long now = st[i];
for (long long j = head[now]; j; j = nxt[j]) vis[id[ver[j]]] = 1;
for (long long nw = 0;; nw++) {
if (!vis[nw]) {
id[now] = nw;
break;
}
}
t[id[now]] ^= h[now];
Max = max(Max, id[now]);
for (long long j = head[now]; j; j = nxt[j]) vis[id[ver[j]]] = 0;
}
long long maxx = -1;
for (long long i = 0; i <= Max; i++) {
if (t[i]) maxx = max(maxx, i);
}
if (maxx == -1) {
puts("LOSE");
return 0;
}
for (long long i = 1; i <= n; i++) {
if (id[i] == maxx && (t[id[i]] ^ h[i]) < h[i]) {
h[i] ^= t[id[i]];
for (long long j = head[i]; j; j = nxt[j]) {
long long y = ver[j];
if (t[id[y]]) {
h[y] ^= t[id[y]];
t[id[y]] = 0;
}
}
break;
}
}
puts("WIN");
for (long long i = 1; i <= n; i++) printf("%lld ", h[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int mod = 998244353;
int sum(int a, int b) {
int c = a + b;
if (c >= mod) {
c -= mod;
}
return c;
}
int dif(int a, int b) {
int c = a - b;
if (c < 0) {
c += mod;
}
return c;
}
int mlt(int a, int b) {
long long c = a * 1LL * b;
return c % mod;
}
int ibit(int n, int i) { return ((n >> i) & 1); }
void outp1(vector<long long> &ou, string s = " ") {
cerr << s << endl;
for (int i = 0; i < ou.size(); i++) {
cerr << ou[i] << ' ';
}
cerr << endl;
}
void outp1(vector<int> &ou, string s = " ") {
cerr << s << endl;
for (int i = 0; i < ou.size(); i++) {
cerr << ou[i] << ' ';
}
cerr << endl;
}
void outp2(vector<vector<int>> &ou, string s = " ") {
cerr << s << endl;
for (int i = 0; i < ou.size(); i++) {
for (int j = 0; j < ou[i].size(); j++) {
cerr << ou[i][j] << ' ';
}
cerr << '\n';
}
}
int bp(int x, int y) {
if (y == 0) {
return 1;
}
int a = 0;
if (!(y % 2)) {
a = bp(x, y / 2);
}
return (y % 2) ? mlt(bp(x, y - 1), x) : mlt(a, a);
}
int obr(int x) { return bp(x, mod - 2); }
const int maxn = 301;
int fact[maxn], ofact[maxn];
void prec() {
fact[0] = 1;
ofact[0] = 1;
for (int i = 1; i < maxn; i++) {
fact[i] = mlt(fact[i - 1], i);
}
ofact[maxn - 1] = obr(fact[maxn - 1]);
for (int i = maxn - 2; i > 0; i--) {
ofact[i] = mlt(ofact[i + 1], i + 1);
}
}
int c(int a, int b) {
return ((a <= b) && (a >= 0)) ? mlt(fact[b], mlt(ofact[a], ofact[b - a])) : 0;
}
int inf = 1e9 + 110;
void reverse(vector<vector<int>> &v, vector<int> &sign, long long &sumx,
long long &sumy, int pos, vector<int> &init) {
if (sumx <= 1e6 + 1 && sumx >= -1e6 - 2)
if (sumy <= 1e6 + 1 && sumy >= -1e6 - 2) {
vector<int> reals(v.size());
for (int i = 0; i < v.size(); i++) {
reals[v[i][2]] = sign[i];
}
for (int i = 0; i < v.size(); i++) cout << reals[i] * init[i] << ' ';
cout << '\n';
exit(0);
}
if (sign[pos] == 1) {
sign[pos] = -1;
sumx -= 2 * v[pos][0];
sumy -= 2 * v[pos][1];
} else {
sign[pos] = 1;
sumx += 2 * v[pos][0];
sumy += 2 * v[pos][1];
}
if (sumx <= 1e6 + 2 && sumx >= -1e6 - 2)
if (sumy <= 1e6 + 2 && sumy >= -1e6 - 2) {
vector<int> reals(v.size());
for (int i = 0; i < v.size(); i++) {
reals[v[i][2]] = sign[i];
}
for (int i = 0; i < v.size(); i++) cout << reals[i] * init[i] << ' ';
cout << '\n';
exit(0);
}
}
int mexx(vector<int> &v) {
vector<int> u(v.size() + 2);
for (auto it : v) {
if (it < u.size()) u[it] = 1;
}
for (int i = 0; i < u.size(); i++)
if (u[i] == 0) return i;
}
void solve(istream &cin = std::cin, ostream &cout = std::cout) {
int n, m;
cin >> n >> m;
vector<vector<int>> gr(n), revgr(n);
vector<int> grundy(n, -1), degs(n);
vector<long long> vals(n);
for (int i = 0; i < n; i++) cin >> vals[i];
set<int> zerodeg;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
degs[x]++;
gr[x].push_back(y);
revgr[y].push_back(x);
}
for (int i = 0; i < n; i++)
if (!degs[i]) zerodeg.insert(i);
while (!zerodeg.empty()) {
int a = *zerodeg.begin();
vector<int> v;
for (auto g : gr[a]) v.push_back(grundy[g]);
grundy[a] = mexx(v);
for (auto g : revgr[a]) {
degs[g]--;
if (degs[g] == 0) zerodeg.insert(g);
}
zerodeg.erase(a);
}
vector<long long> xors(n + 1);
vector<vector<int>> verts(n + 1);
for (int i = 0; i < n; i++) {
xors[grundy[i]] ^= vals[i];
verts[grundy[i]].push_back(i);
}
int pos = -1;
for (int i = n; i >= 0; i--)
if (xors[i] != 0) {
pos = i;
break;
}
if (pos == -1)
cout << "LOSE" << '\n';
else {
int p1 = -1;
for (auto ver : verts[pos]) {
long long need = vals[ver] ^ xors[pos];
if (need < vals[ver]) {
p1 = ver;
break;
}
}
assert(p1 != -1);
cout << "WIN" << '\n';
vals[p1] = vals[p1] ^ xors[pos];
for (auto ver : gr[p1]) {
int cal = grundy[ver];
vals[ver] = xors[cal] ^ vals[ver];
xors[cal] = 0;
}
for (auto it : vals) cout << it << ' ';
cout << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tests = 1;
for (int i = 0; i < tests; i++) solve();
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
struct edge {
int to, nxt;
} e[N];
vector<int> G[N];
int deg[N], n, head[N], cnt, m, h[N], mex[N], X[N];
bool vis[N];
queue<int> q;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", h + i);
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
e[++cnt] = (edge){v, head[u]}, head[u] = cnt, ++deg[u];
G[v].push_back(u);
}
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 = head[u]; i; i = e[i].nxt) vis[mex[e[i].to]] = 1;
while (vis[mex[u]]) ++mex[u];
for (int i = head[u]; i; i = e[i].nxt) vis[mex[e[i].to]] = 0;
for (int to : G[u])
if (!--deg[to]) q.push(to);
}
for (int i = 1; i <= n; ++i) X[mex[i]] ^= h[i];
for (int i = n; ~i; --i)
if (X[i]) {
puts("WIN");
for (int j = 1; j <= n; ++j)
if (mex[j] == i && (h[j] ^ X[i]) < h[j]) {
h[j] ^= X[i], X[i] = 0;
for (int k = head[j]; k; k = e[k].nxt) {
int to = e[k].to;
h[to] ^= X[mex[to]], X[mex[to]] = 0;
}
}
for (int i = 1; i <= n; ++i) printf("%d ", h[i]);
return 0;
}
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) {
if (ch == '-') f = -1;
}
for (; isdigit(ch); ch = getchar()) {
x = x * 10 + ch - 48;
}
return x * f;
}
const int mxN = 2e5;
struct Edge {
int v, nxt;
} e[(mxN << 1) + 3];
int fe[mxN + 3];
int a[mxN + 3];
int f[mxN + 3], sg[mxN + 3];
int ind[mxN + 3];
bool vis[mxN + 3];
int n, m, en;
void addedge(int u, int v) {
en++;
e[en].v = v;
e[en].nxt = fe[u];
fe[u] = en;
}
void dfs(int u) {
if (vis[u]) return;
vis[u] = true;
vector<int> apr;
for (int i = fe[u]; i; i = e[i].nxt) {
int v = e[i].v;
dfs(v);
apr.push_back(f[v]);
}
sort(apr.begin(), apr.end());
f[u] = 0;
for (int i = 0; i < apr.size(); i++) {
if (apr[i] == f[u]) {
f[u]++;
} else if (apr[i] > f[u]) {
break;
}
}
}
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();
ind[v]++;
addedge(u, v);
}
for (int i = 1; i <= n; i++) {
if (ind[i] == 0) {
dfs(i);
}
}
for (int i = 1; i <= n; i++) {
sg[f[i]] ^= a[i];
}
for (int i = n; i >= 0; i--)
if (sg[i]) {
puts("WIN");
for (int u = 1; u <= n; u++)
if (f[u] == i && (a[u] ^ sg[i]) < a[u]) {
a[u] ^= sg[i];
for (int o = fe[u]; o; o = e[o].nxt) {
int v = e[o].v;
a[v] ^= sg[f[v]];
sg[f[v]] = 0;
}
break;
}
for (int u = 1; u <= n; u++) printf("%d ", a[u]);
puts("");
return 0;
}
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
const int N = 200005;
int n, m, t = -1, he, ta, sg[N], d[N], s[N], q[N];
bool vis[N];
long long h[N];
struct ed {
ed* nxt;
int to;
} pool[N], *p = pool, *lnk[N];
void ae(int u, int v) { *++p = (ed){lnk[u], v}, ++d[v], lnk[u] = p; }
void dfs(int u) {}
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); ++i) scanf("%lld", h + i);
for (int i = (1); i <= (m); ++i) {
int u, v;
scanf("%d%d", &u, &v);
ae(u, v);
}
for (int i = (1); i <= (n); ++i)
if (!d[i]) q[++ta] = i;
while (he != ta) {
int u = q[++he];
for (ed* i = lnk[u]; i; i = i->nxt)
if (!--d[i->to]) q[++ta] = i->to;
}
for (int i = (n); i >= (1); --i) {
int u = q[i];
for (ed* i = lnk[u]; i; i = i->nxt) vis[sg[i->to]] = 1;
while (vis[sg[u]]) ++sg[u];
for (ed* i = lnk[u]; i; i = i->nxt) vis[sg[i->to]] = 0;
s[sg[u]] ^= h[u];
}
for (int i = (0); i <= (n); ++i)
if (s[i]) t = i;
if (t == -1) return 0 & puts("LOSE");
for (int i = (1); i <= (n); ++i) {
if (sg[i] == t && ((h[i] ^ s[t]) < h[i])) {
h[i] ^= s[t];
for (ed* j = lnk[i]; j; j = j->nxt) {
h[j->to] ^= s[sg[j->to]];
s[sg[j->to]] = 0;
}
break;
}
}
puts("WIN");
for (int i = (1); i <= (n); ++i) printf("%lld ", h[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 400005;
int n, m, i, j, k, h[N], head[N], adj[N], nxt[N], sg[N], q[N], bg, ed, d[N],
s[N];
bool v[N];
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) scanf("%d", h + i);
for (i = 1; i <= m; ++i) {
scanf("%d%d", &j, &k);
adj[i] = k;
nxt[i] = head[j];
head[j] = i;
++d[k];
}
for (i = 1; i <= n; ++i)
if (!d[i]) q[++ed] = i;
bg = 1;
while (bg <= ed) {
for (i = head[q[bg]]; i; i = nxt[i]) {
--d[adj[i]];
if (d[adj[i]] == 0) q[++ed] = adj[i];
}
++bg;
}
for (i = n; i >= 1; --i) {
for (j = head[q[i]]; j; j = nxt[j]) v[sg[adj[j]]] = true;
for (j = 0; v[j]; ++j)
;
sg[q[i]] = j;
for (j = head[q[i]]; j; j = nxt[j]) v[sg[adj[j]]] = false;
}
for (i = 1; i <= n; ++i) s[sg[i]] ^= h[i];
for (i = n; i >= 0; --i)
if (s[i]) {
puts("WIN");
for (j = 1; j <= n; ++j)
if (sg[j] == i && (s[i] ^ h[j]) <= h[j]) {
h[j] = s[i] ^ h[j];
for (k = 0; k <= n; ++k) v[k] = false;
for (k = head[j]; k; k = nxt[k])
if (!v[sg[adj[k]]]) {
v[sg[adj[k]]] = true;
h[adj[k]] = s[sg[adj[k]]] ^ h[adj[k]];
}
for (k = 1; k <= n; ++k) printf("%d ", h[k]);
return 0;
}
}
printf("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
inline int gi() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while ('0' <= c && c <= '9') sum = sum * 10 + c - 48, c = getchar();
return sum;
}
int n, m, val[maxn], Id[maxn], sum[maxn], vis[maxn];
vector<int> to[maxn];
int dfs(int u) {
if (vis[u]) return Id[u];
vector<int> t;
vis[u] = 1;
for (int v : to[u]) t.push_back(dfs(v));
sort(t.begin(), t.end());
int lst = -1;
Id[u] = -1;
for (int i = 0; i < t.size(); ++i)
if (t[i] > lst + 1) {
Id[u] = lst + 1;
break;
} else
lst = t[i];
if (Id[u] == -1) Id[u] = lst + 1;
return Id[u];
}
int main() {
n = gi();
m = gi();
for (int i = 1; i <= n; ++i) val[i] = gi();
for (int u, v, i = 1; i <= m; ++i) u = gi(), v = gi(), to[u].push_back(v);
for (int i = 1; i <= n; ++i)
if (!vis[i]) dfs(i);
for (int i = 1; i <= n; ++i) sum[Id[i]] ^= val[i];
int pos = -1;
for (int i = 0; i <= n; ++i)
if (sum[i]) pos = i;
if (~pos) {
puts("WIN");
for (int i = 1; i <= n; ++i)
if (Id[i] == pos && (val[i] ^ sum[pos]) < val[i]) {
val[i] = val[i] ^ sum[pos];
sum[pos] = 0;
for (int v : to[i]) val[v] = sum[Id[v]] ^ val[v], sum[Id[v]] = 0;
}
for (int i = 1; i <= n; ++i) printf("%d ", val[i]);
} else
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int head[200005], ver[200005], nxt[200005], cnt;
void add(int a, int b) { ver[++cnt] = b, nxt[cnt] = head[a], head[a] = cnt; }
vector<int> e[200005], has[200005];
int n, m, cd[200005];
long long a[200005], sg[200005];
int pos[200005], mex[200005], mx;
bool vis[200005];
queue<int> q;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1, a, b; i <= m; i++) {
scanf("%d%d", &a, &b);
add(a, b), e[b].push_back(a), cd[a]++;
}
for (int i = 1; i <= n; i++)
if (!cd[i]) q.push(i);
while (!q.empty()) {
int now = q.front();
q.pop(), cnt = 0;
for (int i = head[now]; i; i = nxt[i]) mex[++cnt] = pos[ver[i]];
pos[now] = 1;
sort(mex + 1, mex + 1 + cnt);
for (int 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 (int i = 0; i < e[now].size(); i++) {
cd[e[now][i]]--;
if (!cd[e[now][i]]) q.push(e[now][i]);
}
}
for (int o = mx; o >= 1; o--) {
if (sg[o] != 0) {
int now;
for (int 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 (int i = head[now]; i; i = nxt[i]) {
int to = ver[i];
if (vis[pos[to]]) continue;
vis[pos[to]] = 1;
a[to] = sg[pos[to]] ^ a[to];
}
printf("WIN\n");
for (int i = 1; i <= n; i++) printf("%lld ", a[i]);
return 0;
}
}
printf("LOSE");
}
| 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;
const int N = 2e5 + 7;
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, x, y; i <= m; i++)
scanf("%d%d", &x, &y), G[x].push_back(y), d[y]++;
int qs = 1, qe = 1;
for (int i = 1; i <= n; i++)
if (!d[i]) q[qe++] = i;
while (qs < qe) {
int u = q[qs++];
for (int i = 0; i < G[u].size(); i++)
if (!--d[G[u][i]]) q[qe++] = G[u][i];
}
for (int i = n; i; i--) {
int u = q[i];
for (int j = 0; j < G[u].size(); j++) vis[sg[G[u][j]]] = i;
while (vis[sg[u]] == i) sg[u]++;
s[sg[u]] ^= h[u];
}
for (int i = n, u; ~i; i--)
if (s[i]) {
for (int j = 1; j <= n; j++)
if (sg[j] == i && h[j] > (s[i] ^ h[j])) u = j;
h[u] ^= s[i];
for (int j = 0; j < G[u].size(); j++)
h[G[u][j]] ^= s[sg[G[u][j]]], s[sg[G[u][j]]] = 0;
puts("WIN");
for (int j = 1; j <= n; j++) printf("%d ", h[j]);
puts("");
return 0;
}
puts("LOSE");
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
const char lf = '\n';
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t) return EOF;
}
return *s++;
}
inline long long ty() {
long long a = 0;
int b = 1, c = fetch();
while (!isdigit(c)) b ^= c == '-', c = fetch();
while (isdigit(c)) a = a * 10 + c - 48, c = fetch();
return b ? a : -a;
}
} // namespace ae86
using ae86::ty;
const int _ = 200007;
vector<int> e[_];
int n, m, sg[_], mxsg = 0;
long long val[_] = {0}, sval[_] = {0};
void dfs(int x) {
if (sg[x] >= 0) return;
unordered_set<int> got;
for (auto b : e[x]) dfs(b), got.emplace(sg[b]);
sg[x] = 0;
while (got.count(sg[x])) sg[x]++;
mxsg = max(mxsg, sg[x]), sval[sg[x]] ^= val[x];
}
int main() {
ios::sync_with_stdio(0), cout.tie(nullptr);
n = ty(), m = ty();
for (int i = 1; i <= n; i++) val[i] = ty();
for (int i = 1, a, b; i <= m; i++) a = ty(), b = ty(), e[a].emplace_back(b);
memset(sg, -1, sizeof(sg));
for (int i = 1; i <= n; i++) dfs(i);
for (int i = mxsg; i >= 0; i--) {
if (!sval[i]) continue;
cout << "WIN" << lf;
for (int j = 1; j <= n; j++) {
if (sg[j] == i && (val[j] ^ sval[i]) < val[j]) {
val[j] ^= sval[i], sval[i] = 0;
for (auto b : e[j])
if (sval[sg[b]]) val[b] ^= sval[sg[b]], sval[sg[b]] = 0;
break;
}
}
for (int j = 1; j <= n; j++) cout << val[j] << " \n"[j == n];
return 0;
}
cout << "LOSE" << lf;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
int n, m, h[N], f[N];
vector<int> G[N];
int d[N], S[N];
int main() {
cin >> 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), ++d[v], G[u].push_back(v);
static int q[N];
int hd = 1, tl = 0;
for (int i = 1; i <= n; i++)
if (d[i] == 0) q[++tl] = i;
while (hd <= tl) {
int x = q[hd++];
for (int v : G[x])
if (--d[v] == 0) q[++tl] = v;
}
for (int i = tl, x; i; i--) {
x = q[i];
static int ex[N], tim;
++tim;
for (int v : G[x]) ex[f[v]] = tim;
for (int j = 0;; j++)
if (ex[j] != tim) {
f[x] = j;
break;
}
S[f[x]] ^= h[x];
}
bool ok = true;
for (int i = 0; i <= n; i++)
if (S[i]) ok = false;
if (ok) return puts("LOSE"), 0;
for (int i = n; ~i; i--)
if (S[i]) {
int x = 0;
for (int j = 1; j <= n; j++)
if (f[j] == i && (h[j] ^ S[i]) < h[j]) {
x = j;
break;
}
h[x] = h[x] ^ S[i], S[i] = 0;
for (int v : G[x])
if (S[f[v]]) h[v] ^= S[f[v]], S[f[v]] = 0;
}
puts("WIN");
for (int i = 1; i <= n; i++) cout << h[i] << " ";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007LL;
long long large = 2000000000000000000LL;
vector<int> dp;
vector<vector<int> > adj;
int f(int u) {
if (dp[u] != -1) return dp[u];
vector<int> ch;
for (int j = 0; j < (int)adj[u].size(); j++) {
int v = adj[u][j];
ch.push_back(f(v));
}
sort(ch.begin(), ch.end());
int re = 0;
for (int i = 0; i < (int)ch.size(); i++) {
if (ch[i] == re)
re++;
else if (ch[i] > re)
break;
}
dp[u] = re;
return dp[u];
}
int main() {
int n, m;
cin >> n >> m;
vector<int> h(n, 0);
for (int i = 0; i < n; i++) scanf("%d", &h[i]);
adj.assign(n, vector<int>());
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
adj[x].push_back(y);
}
dp.assign(n, -1);
int ans = 0;
int sz = 0;
for (int i = 0; i < n; i++) sz = max(sz, f(i) + 1);
vector<int> tp(sz, 0);
for (int i = 0; i < n; i++) tp[f(i)] ^= h[i];
for (int i = 0; i < sz; i++) ans |= tp[i];
if (ans == 0) {
cout << "LOSE" << endl;
return 0;
}
int p = -1;
for (int i = 0; i < sz; i++) {
if (tp[i]) p = i;
}
for (int i = 0; i < n; i++)
if (f(i) == p && (h[i] ^ tp[p]) < h[i]) {
h[i] ^= tp[p];
tp[p] = 0;
for (int j = 0; j < (int)adj[i].size(); j++) {
int v = adj[i][j];
h[v] ^= tp[f(v)];
tp[f(v)] = 0;
}
break;
}
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;
const int maxn = 2e5 + 5;
vector<int> G[maxn];
int sg[maxn], deg[maxn], Xor[maxn], topo[maxn], mem[maxn], cnt;
long long h[maxn], XOR[maxn];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%lld", &h[i]);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
++deg[v];
}
queue<int> q;
for (int i = 1; i <= n; ++i)
if (deg[i] == 0) q.push(i);
while (!q.empty()) {
int t = q.front();
q.pop();
topo[++cnt] = t;
for (int i = 0; i < G[t].size(); ++i) {
int c = G[t][i];
--deg[c];
if (!deg[c]) q.push(c);
}
}
for (int i = n; i >= 1; --i) {
int u = topo[i];
for (int j = 0; j < G[u].size(); ++j) {
int c = G[u][j];
mem[sg[c]] = i;
}
while (mem[sg[u]] == i) ++sg[u];
XOR[sg[u]] ^= h[u];
}
long long sghigh = -1;
for (int i = 0; i < maxn; ++i)
if (XOR[i] > 0) sghigh = i;
if (sghigh == -1) return 0 * puts("LOSE");
for (int i = 1; i <= n; ++i)
if (sg[i] == sghigh && (XOR[sghigh] ^ h[i]) < h[i]) {
h[i] ^= XOR[sghigh];
for (int j = 0; j < G[i].size(); ++j) {
int c = G[i][j];
h[c] ^= XOR[sg[c]];
XOR[sg[c]] = 0;
}
break;
}
printf("WIN\n");
for (int i = 1; i <= n; ++i) printf("%lld ", h[i]);
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;
}
for (int j : adj[i]) {
DFS(j);
}
for (int j : adj[i]) {
c[mex[j]] = 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;
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 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
vector<int> V[maxn], H[maxn];
int n, m;
long long a[maxn];
int SG[maxn];
int h[maxn];
int maxx = 0;
int dfs(int u) {
if (SG[u] != -1) return SG[u];
vector<int> tmp;
for (auto v : V[u]) {
tmp.push_back(dfs(v));
}
sort(tmp.begin(), tmp.end());
int j = 0;
for (int i = 0;; i++) {
if (tmp.size() == 0 || tmp[j] != i || j >= tmp.size()) {
SG[u] = i;
break;
}
while (j < tmp.size() && tmp[j] == i) j++;
}
maxx = max(maxx, SG[u]);
return SG[u];
}
int c[maxn];
void solve(int x) {
for (auto i : H[x]) {
if ((a[i] ^ h[x]) < a[i]) {
a[i] = a[i] ^ h[x];
for (auto j : V[i]) {
if (c[SG[j]]) continue;
c[SG[j]] = 1;
a[j] ^= h[SG[j]];
}
break;
}
}
}
int main() {
memset(SG, -1, sizeof(SG));
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
V[u].push_back(v);
}
for (int i = 1; i <= n; i++) {
if (SG[i] == -1) dfs(i);
}
for (int i = 1; i <= n; i++) {
h[SG[i]] ^= a[i];
H[SG[i]].push_back(i);
}
int p;
int flag = 0;
for (int i = maxx; i >= 0; i--) {
if (h[i]) {
flag = 1;
p = i;
solve(i);
break;
}
}
if (flag) {
puts("WIN");
for (int i = 1; i <= n; i++) cout << a[i] << " ";
} else
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, h[200205];
int info[200205], Prev[200205], to[200205], cnt_e;
void Node(int u, int v) {
Prev[++cnt_e] = info[u], info[u] = cnt_e, to[cnt_e] = v;
}
int in[200205], Q[200205], L, R, SG[200205], S[200205];
int vis[200205], tim, Mx;
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), Node(u, v), in[v]++;
for (int i = 1; i <= n; i++)
if (!in[i]) Q[R++] = i;
for (int now; L < R;) {
now = Q[L++];
for (int i = info[now]; i; i = Prev[i]) {
in[to[i]]--;
if (!in[to[i]]) Q[R++] = to[i];
}
}
for (int i = R - 1; i >= 0; i--) {
tim++;
int u = Q[i];
for (int j = info[u]; j; j = Prev[j]) vis[SG[to[j]]] = tim;
for (SG[u] = 0; vis[SG[u]] == tim; SG[u]++)
;
S[SG[u]] ^= h[u];
}
bool flg = 0;
for (int i = 0; i <= n; i++)
if (S[i] != 0) flg = 1;
if (!flg)
puts("LOSE");
else {
puts("WIN");
int loc = 0, Maxloc = 0;
for (int i = n; i >= 0; i--)
if (S[i] != 0) {
loc = i;
break;
}
for (int i = 1; i <= n; i++)
if (SG[i] == loc && (S[loc] ^ h[i]) < h[i]) Maxloc = i;
h[Maxloc] ^= S[loc];
for (int i = info[Maxloc]; i; i = Prev[i])
h[to[i]] ^= S[SG[to[i]]], S[SG[to[i]]] = 0;
for (int i = 1; i <= n; i++) printf("%d%c", h[i], i == n ? '\n' : ' ');
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int h[200000];
vector<int> adjList[200000];
int nim[200000];
int doDFS(int u) {
if (nim[u] != -1) return 0;
int i, j = 0;
vector<int> s;
for (i = 0; i < adjList[u].size(); i++) {
int v = adjList[u][i];
doDFS(v), s.push_back(nim[v]);
}
sort(s.begin(), s.end());
for (i = 0; i <= adjList[u].size(); i++) {
while ((j < s.size()) && (s[j] < i)) j++;
if ((j == s.size()) || (s[j] > i)) break;
}
nim[u] = i;
return 0;
}
int x[200000], y[200000];
int main() {
int i;
int n, m, u, v;
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++) scanf("%d", &h[i]);
for (i = 0; i < m; i++) {
scanf("%d %d", &u, &v);
adjList[u - 1].push_back(v - 1);
}
int c = 0;
fill(nim, nim + n, -1);
for (i = 0; i < n; i++) doDFS(i), x[nim[i]] ^= h[i];
for (i = 0; i < n; i++) {
if (x[i] > 0) c++;
}
if (c == 0) {
printf("LOSE\n");
return 0;
}
int j;
for (i = 0; i < n; i++) {
if ((x[nim[i]] ^ h[i]) < h[i]) {
int c2 = 1;
for (j = 0; j < adjList[i].size(); j++) {
int v = adjList[i][j];
if ((x[nim[v]] > 0) && !y[nim[v]]) c2++;
y[nim[v]] = 1;
}
if (c == c2) {
h[i] ^= x[nim[i]];
for (j = 0; j < adjList[i].size(); j++) {
int v = adjList[i][j];
h[v] ^= x[nim[v]], x[nim[v]] = 0;
}
printf("WIN\n");
for (j = 0; j < n; j++)
printf("%d%c", h[j], (j == (n - 1)) ? '\n' : ' ');
break;
} else {
for (j = 0; j < adjList[i].size(); j++) y[nim[adjList[i][j]]] = 0;
}
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2.1e5;
int N, M;
uint64_t H[MAXN];
int outDeg[MAXN];
vector<int> outEdges[MAXN];
vector<int> inEdges[MAXN];
int omegaPow[MAXN];
uint64_t totalNimber[MAXN];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> N >> M;
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--;
inEdges[v].push_back(u);
outEdges[u].push_back(v);
outDeg[u]++;
}
stack<int> q;
for (int i = 0; i < N; i++) {
if (outDeg[i] == 0) q.push(i);
}
while (!q.empty()) {
int cur = q.top();
q.pop();
assert(outDeg[cur] == 0);
set<int> nxtOmegas;
for (int nxt : outEdges[cur]) {
nxtOmegas.insert(omegaPow[nxt]);
}
omegaPow[cur] = 0;
while (nxtOmegas.count(omegaPow[cur])) omegaPow[cur]++;
totalNimber[omegaPow[cur]] ^= H[cur];
for (int prv : inEdges[cur]) {
if (--outDeg[prv] == 0) {
q.push(prv);
}
}
}
bool isZero = true;
for (int i = 0; i <= N; i++) {
if (totalNimber[i]) {
isZero = false;
}
}
if (isZero) {
cout << "LOSE" << '\n';
exit(0);
} else {
cout << "WIN" << '\n';
int biggestPow = N + 1;
while (biggestPow >= 0 && totalNimber[biggestPow] == 0) biggestPow--;
assert(biggestPow != -1);
int cur;
for (cur = 0; cur < N; cur++) {
if (omegaPow[cur] == biggestPow &&
(totalNimber[omegaPow[cur]] ^ H[cur]) < H[cur]) {
break;
}
}
assert(cur != N);
vector<int> nxtOmegas(omegaPow[cur] + 1, -1);
nxtOmegas[omegaPow[cur]] = cur;
for (int nxt : outEdges[cur]) {
assert(omegaPow[nxt] != omegaPow[cur]);
if (omegaPow[nxt] < omegaPow[cur]) {
nxtOmegas[omegaPow[nxt]] = nxt;
}
}
for (int p = 0; p <= omegaPow[cur]; p++) {
H[nxtOmegas[p]] ^= totalNimber[p];
totalNimber[p] = 0;
}
for (int i = 0; i < N; i++) {
cout << H[i] << " \n"[i + 1 == N];
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int M = 2e5 + 5;
int n, m;
long long h[N];
long long ans[N];
struct Edge {
int num;
int next;
} edge[M];
int tot, last[N];
int du[N];
int sg[N];
queue<int> L;
int node[N], cnt;
int mem[N];
void Add(int i, int j) {
tot++;
edge[tot].num = j;
edge[tot].next = last[i];
last[i] = tot;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%lld", &h[i]);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d %d", &u, &v);
Add(u, v);
du[v]++;
}
for (int i = 1; i <= n; i++)
if (du[i] == 0) {
L.push(i);
node[++cnt] = i;
}
while (!L.empty()) {
int u = L.front();
L.pop();
for (int k = last[u]; k != 0; k = edge[k].next) {
int v = edge[k].num;
du[v]--;
if (du[v] == 0) {
L.push(v);
node[++cnt] = v;
}
}
}
for (int i = n; i >= 1; i--) {
int u = node[i];
for (int k = last[u]; k != 0; k = edge[k].next) {
int v = edge[k].num;
mem[sg[v]] = i;
}
while (mem[sg[u]] == i) ++sg[u];
}
for (int i = 1; i <= n; i++) ans[sg[i]] ^= h[i];
for (int i = n; i >= 0; i--)
if (ans[i] != 0) {
printf("WIN\n");
for (int j = 1; j <= n; j++) {
if (sg[j] != i) continue;
if ((h[j] ^ ans[i]) >= h[j]) continue;
h[j] = h[j] ^ ans[i];
for (int k = last[j]; k != 0; k = edge[k].next) {
int v = edge[k].num;
h[v] ^= ans[sg[v]];
ans[sg[v]] = 0;
}
break;
}
for (int j = 1; j <= n; j++) printf("%lld ", h[j]);
return 0;
}
printf("LOSE");
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
using ll = long long;
int n, m, top;
vector<int> v[N];
ll a[N], val[N];
int deg[N], p[N], vis[N], id[N], mx;
queue<int> q;
void toposort() {
for (int i = 1; i <= n; i++)
if (!deg[i]) q.push(i);
while (!q.empty()) {
int nd = q.front();
q.pop();
p[++top] = nd;
for (auto &i : v[nd])
if (!--deg[i]) q.push(i);
}
for (int i = n; i > 0; --i) {
int x = p[i];
for (auto &j : v[x]) vis[id[j]] = 1;
while (vis[id[x]]) ++id[x];
val[id[x]] ^= a[x];
mx = max(mx, id[x]);
for (auto &j : v[x]) vis[id[j]] = 0;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) {
int q, w;
cin >> q >> w;
v[q].push_back(w);
++deg[w];
}
toposort();
int pos = -1;
for (int i = 0; i <= mx; i++)
if (val[i]) pos = i;
if (pos == -1) {
puts("LOSE");
return 0;
}
cout << "WIN" << endl;
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 (auto &j : v[i]) a[j] ^= val[id[j]], val[id[j]] = 0;
}
for (int i = 1; i <= n; i++) printf("%lld ", a[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, m, h[maxn], u, v, d[maxn], sg[maxn], vis[maxn], chc[maxn], hed[maxn], ed,
s[maxn], cnt;
struct edge {
int to, nex;
edge(int _ = 0, int __ = 0) : to(_), nex(__) {}
} e[maxn];
inline void add(int u, int v) {
e[++ed] = edge(v, hed[u]);
hed[u] = ed;
}
void topsort() {
queue<int> Q;
for (int i = (1); i <= (n); ++i)
if (!d[i]) Q.push(i);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
s[++cnt] = u;
for (int i = hed[u], v = e[i].to; i; i = e[i].nex, v = e[i].to)
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) scanf("%d%d", &u, &v), add(u, v), ++d[v];
topsort();
for (int w = (n); w >= (1); --w) {
int u = s[w];
for (int i = hed[u], v = e[i].to; i; i = e[i].nex, v = e[i].to)
vis[sg[v]] = u;
sg[u] = 0;
while (vis[sg[u]] == u) ++sg[u];
chc[sg[u]] ^= h[u];
}
for (int i = (n); i >= (0); --i)
if (chc[i]) {
puts("WIN");
int u = 0;
for (int j = (1); j <= (n); ++j)
if (sg[j] == i && (h[j] > (h[j] ^ chc[i]))) {
u = j, h[j] ^= chc[i], chc[i] = 0;
break;
}
for (int j = hed[u], v = e[j].to; j; j = e[j].nex, v = e[j].to)
h[v] ^= chc[sg[v]], chc[sg[v]] = 0;
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;
const int maxN = 200002;
int mex(vector<int>& cands) {
static bool flags[maxN];
for (int i = 0; i <= cands.size(); ++i) {
flags[i] = false;
}
for (int x : cands) {
flags[x] = true;
}
int res = 0;
while (flags[res]) {
++res;
}
return res;
}
static bool used[maxN];
static int level[maxN];
static int xorSum[maxN];
static vector<int> edge[maxN];
static int h[maxN];
static int maxLevel = 0;
void dfs(int u) {
if (used[u]) {
return;
}
used[u] = true;
vector<int> cands;
for (int v : edge[u]) {
dfs(v);
cands.push_back(level[v]);
}
level[u] = mex(cands);
}
int main(int argc, char** argv) {
std::ios::sync_with_stdio(false);
for (int i = 0; i < maxN; ++i) {
used[i] = false;
level[i] = 0;
xorSum[i] = 0;
}
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> h[i];
}
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
edge[--x].push_back(--y);
}
for (int i = 0; i < n; ++i) {
dfs(i);
}
for (int i = 0; i < n; ++i) {
xorSum[level[i]] ^= h[i];
}
int maxLevel = n - 1;
while (maxLevel >= 0 && xorSum[maxLevel] == 0) {
--maxLevel;
}
if (maxLevel < 0) {
cout << "LOSE" << endl;
return 0;
}
int u = 0;
while (level[u] != maxLevel || h[u] < (xorSum[maxLevel] ^ h[u])) {
++u;
}
h[u] = xorSum[maxLevel] ^ h[u];
xorSum[maxLevel] = 0;
for (int v : edge[u]) {
if (xorSum[level[v]] != 0) {
h[v] ^= xorSum[level[v]];
xorSum[level[v]] = 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;
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];
sum[p] = 0;
for (int j = 0; j < G[i].size(); ++j) {
int v = G[i][j];
h[v] ^= sum[sg[v]];
sum[sg[v]] = 0;
}
}
for (int i = 1; i <= n; ++i) printf("%d ", h[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
#pragma optimize("unroll-loops,no-stack-protector")
using namespace std;
namespace io {
struct eof {
eof() {}
};
const int L = (1 << 21) | 5;
char ibuf[L], *iS, *iT, obuf[L], *oS = obuf, *oT = obuf + L - 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, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
(c < '0' || c > '9') && (c != EOF);
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
if (c == EOF) throw eof();
for (x = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (c & 15);
x *= f;
}
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--]);
}
inline void ps(const char *s) {
int l = strlen(s), x;
for (x = 0; x < l; x++) putc(s[x]);
}
struct IOC {
~IOC() { flush(); }
} ioc;
inline double readld() {
double x = 0, y = 1;
for (c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') y = -1;
assert(c != '.');
for (; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (c & 15);
x *= y;
assert(c != 'e');
if (c == '.')
for (c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
y *= 0.1, x += y * (c & 15);
return x;
}
inline void printld(double x, int y) {
if (x < 0) putc('-'), x = -x;
x += .5 * pow(.1, y);
print((unsigned long long)x), putc('.');
for (x -= (unsigned long long)x; y; --y)
x *= 10, putc((int)x + '0'), x -= (int)x;
}
} // namespace io
using io::gi;
using io::print;
using io::putc;
template <class T>
int ctz(T a) {
return sizeof(T) > 4 ? __builtin_ctzll(a) : __builtin_ctz(a);
}
template <class T>
inline T gcd(T a, T b) {
int shift = ctz(a | b);
for (b >>= ctz(b), a >>= ctz(a); a; a -= b, a >>= ctz(a))
if (a < b) swap(a, b);
return b << shift;
}
template <class T>
void exgcd(T a, T b, T &x, T &y) {
if (!b) return (void)(x = 1, y = 0);
exgcd(b, a % b, y, x), y -= a / b * x;
}
template <class T>
T Inv(T a, T p) {
T x, y;
exgcd(a, p, x, y);
return (x % p + p) % p;
}
inline int fpow(int a, int t, int p) {
static int r;
for (r = 1; t; a = (long long)a * a % p, t >>= 1)
if (t & 1) r = (long long)r * a % p;
return r;
}
string to_string(string s) { return '"' + s + '"'; };
string to_string(const char *s) { return to_string(string(s)); }
string to_string(bool f) { return f ? "true" : "false"; }
template <class A, class B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <class T>
string to_string(T v) {
string s = "{", e = "";
for (auto &x : v) s += e + to_string(x), e = ", ";
s += "}";
return s;
}
void debug_out() { cerr << endl; }
template <class A, class... B>
void debug_out(A x, B... y) {
cerr << " " << to_string(x), debug_out(y...);
}
void scan() {}
template <class A, class... B>
void scan(A &a, B &...b) {
gi(a), scan(b...);
}
template <class T>
void read(T first, T last) {
for (; first != last; ++first) gi(*first);
}
template <class T>
void write(T first, T last) {
for (; first != last; putc(++first == last ? '\n' : ' ')) print(*first);
}
template <class T>
void show(T x) {
print(x), putc('\n');
}
template <class A, class... B>
void show(A a, B... b) {
print(a), putc(' '), show(b...);
}
template <class T>
inline T abs(T x) {
return x < 0 ? -x : x;
}
template <class T>
bool chkmin(T &x, T y) {
return y < x ? x = y, true : false;
}
template <class T>
bool chkmax(T &x, T y) {
return x < y ? x = y, true : false;
}
const int N = 2e5 + 5;
int n, m, in[N], sg[N];
long long h[N], layer[N];
vector<int> adj[N];
int main() {
int u, v;
scan(n, m);
read(h + 1, h + n + 1);
queue<int> q;
vector<int> topo;
for (int i = 1; i <= m; ++i) scan(u, v), adj[u].emplace_back(v), in[v]++;
for (int i = 1; i <= n; ++i)
if (!in[i]) q.push(i);
while (q.size()) {
u = q.front();
topo.emplace_back(u);
q.pop();
for (int v : adj[u])
if (!--in[v]) q.push(v);
}
reverse(topo.begin(), topo.end());
for (int x : topo) {
set<int> nxt;
for (int y : adj[x]) nxt.insert(sg[y]);
while (nxt.count(sg[x])) ++sg[x];
layer[sg[x]] ^= h[x];
}
for (u = n; u >= 0; --u)
if (layer[u]) {
puts("WIN");
for (v = 1; v <= n; ++v)
if (sg[v] == u && (h[v] ^ layer[u]) < h[v]) break;
h[v] ^= layer[u];
layer[u] = 0;
for (int x : adj[v]) h[x] ^= layer[sg[x]], layer[sg[x]] = 0;
write(h + 1, h + n + 1);
exit(0);
}
puts("LOSE");
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MX = 200005;
int n, m, u, v, a[MX], b[MX], ex[MX], x[MX];
vector<int> adj[MX], in[MX];
void dfs(int u) {
if (b[u] != -1) return;
for (int v : adj[u]) dfs(v);
for (int v : adj[u]) ex[b[v]] = u;
b[u] = 0;
while (ex[b[u]] == u) b[u]++;
in[b[u]].push_back(u);
x[b[u]] ^= a[u];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i + 1];
while (m--) {
cin >> u >> v;
adj[u].push_back(v);
}
memset(b, -1, sizeof(b));
for (int i = 0; i < n; i++) dfs(i + 1);
for (int i = n; i + 1; i--)
if (x[i]) {
int s = 0;
for (int j = 0; j < 30; j++)
if (x[i] & (1 << j)) s = j;
for (int u : in[i])
if (a[u] & (1 << s)) {
a[u] ^= x[i];
for (int v : adj[u]) ex[b[v]] = v;
for (int j = 0; j < i; j++) a[ex[j]] ^= x[j];
break;
}
cout << "WIN" << '\n';
for (int i = 0; i < n; i++) cout << a[i + 1] << " ";
cout << '\n';
return 0;
}
cout << "LOSE" << '\n';
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) {
for (int j : adj[i]) {
if (mex[j] >= 0) {
continue;
}
DFS(j);
}
for (int j : adj[i]) {
c[mex[j]] = 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) {
if (mex[i] >= 0) {
continue;
}
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;
struct ahowwogaw {
int v, next;
} _[1000005];
int head[1000005], tot = 1, zyl[200005], yihuo[1000005], a[1000005];
bool qwer[1000005];
int fyr(int iakioi) {
if (zyl[iakioi] >= 0) {
return zyl[iakioi];
}
int i, ykb = 0, t;
for (i = head[iakioi]; i; i = _[i].next) {
ykb++;
}
bool have[ykb + 3];
memset(have, 0, sizeof(have));
for (i = head[iakioi]; i; i = _[i].next) {
t = fyr(_[i].v);
if (t <= ykb) {
have[t] = 1;
}
}
for (i = 0; have[i]; i++) {
}
zyl[iakioi] = i;
return i;
}
int main() {
memset(zyl, -1, sizeof(zyl));
int n, m, i, A, B, ykb, maxzyl = 0, maxid, win = -1;
cin >> n >> m;
for (i = 1; i <= n; i++) {
scanf("%d", a + i);
}
for (i = 0; i < m; i++) {
scanf("%d %d", &A, &B);
_[tot].v = B;
_[tot].next = head[A];
head[A] = tot++;
}
for (i = 1; i <= n; i++) {
ykb = fyr(i);
yihuo[ykb] ^= a[i];
if (ykb > maxzyl) {
maxzyl = ykb;
maxid = i;
}
}
for (i = maxzyl; i >= 0; i--) {
if (yihuo[i]) {
win = i;
break;
}
}
if (win < 0) {
cout << "LOSE";
return 0;
}
for (i = 1; i <= n; i++) {
if (zyl[i] == win && (yihuo[zyl[i]] ^ a[i]) < a[i]) {
a[i] ^= yihuo[zyl[i]];
win = i;
break;
}
}
for (i = head[win]; i; i = _[i].next) {
if (!qwer[zyl[_[i].v]]) {
a[_[i].v] ^= yihuo[zyl[_[i].v]];
qwer[zyl[_[i].v]] = 1;
}
}
cout << "WIN" << endl;
for (i = 1; i <= n; i++) {
cout << a[i] << " ";
}
return 0;
}
| 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 ll = long long;
int const nmax = 200000;
int v[1 + nmax];
std::vector<int> g[1 + nmax];
int mex(std::vector<int> aux) {
std::sort(aux.begin(), aux.end());
aux.erase(std::unique(aux.begin(), aux.end()), aux.end());
for (int i = 0; i < aux.size(); i++)
if (aux[i] != i) return i;
return aux.size();
}
int color[1 + nmax], dp[1 + nmax];
void dfs(int node) {
std::vector<int> aux;
for (int h = 0; h < g[node].size(); h++) {
int to = g[node][h];
if (color[to] == -1) dfs(to);
aux.push_back(color[to]);
}
color[node] = mex(aux);
}
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int n, m;
std::cin >> n >> m;
for (int i = 1; i <= n; i++) std::cin >> v[i];
for (int i = 1; i <= n; i++) color[i] = -1;
for (int i = 1; i <= m; i++) {
int x, y;
std::cin >> x >> y;
g[x].push_back(y);
}
for (int i = 1; i <= n; i++)
if (color[i] == -1) dfs(i);
for (int i = 1; i <= n; i++) dp[color[i]] ^= v[i];
int result = 0;
for (int i = 0; i <= n; i++) result += (dp[i] != 0);
if (result == 0)
std::cout << "LOSE\n";
else {
for (int i = n; 0 <= i; i--)
if (dp[i] != 0) {
std::cout << "WIN\n";
for (int j = 1; j <= n; j++)
if (color[j] == i) {
if (0 < dp[i] && (v[j] ^ dp[i]) < v[j]) {
v[j] ^= dp[i];
dp[i] ^= dp[i];
for (int h = 0; h < g[j].size(); h++) {
int to = g[j][h];
if (0 < dp[color[to]]) {
v[to] ^= dp[color[to]];
dp[color[to]] = 0;
}
}
break;
}
}
for (int j = 1; j <= n; j++) std::cout << v[j] << " ";
std::cout << '\n';
return 0;
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = (int)2e5 + 5;
int n, m;
vector<int> v[MAX];
int h[MAX];
set<int> s[MAX];
set<int> t[MAX];
int dep[MAX];
int xors[MAX];
vector<pair<int, int> > mxx[MAX];
int bio[MAX];
int p[1000];
void dfs(int cx) {
if (bio[cx]) return;
bio[cx] = 1;
for (int i = (0), _for = (1000); i < _for; ++i) p[i] = 0;
for (auto first : v[cx]) {
p[dep[first]] = 1;
}
for (int i = (0), _for = (1000); i < _for; ++i) {
if (!p[i]) {
dep[cx] = i;
xors[i] ^= h[cx];
mxx[i].push_back({h[cx], cx});
break;
}
}
for (auto nx : t[cx]) {
s[nx].erase(cx);
if (s[nx].empty()) dfs(nx);
}
}
int find_cx(int i) {
int xr = xors[i];
for (auto cx : mxx[i]) {
if ((cx.first ^ xr) <= cx.first) return cx.second;
}
return -1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (0), _for = (n); i < _for; ++i) scanf("%d", h + i);
for (int i = (0), _for = (m); i < _for; ++i) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
v[a].push_back(b);
s[a].insert(b);
t[b].insert(a);
}
for (int i = (0), _for = (n); i < _for; ++i)
if (s[i].empty()) dfs(i);
for (int i = 999; i >= 0; --i)
if (xors[i]) {
puts("WIN");
int cx = find_cx(i);
h[cx] ^= xors[i];
for (auto nx : v[cx]) {
int d = dep[nx];
h[nx] ^= xors[d];
xors[d] = 0;
}
for (int i = (0), _for = (n); i < _for; ++i) {
printf("%d ", h[i]);
}
printf("\n");
return 0;
}
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
const int N = 200005;
using namespace std;
long long n, m, num[N], sy[N], ds[N], bj[N], sum[N];
vector<long long> to[N], pre[N];
queue<long long> que;
int main() {
long long i, j, t, p, q;
scanf("%d%d", &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);
while (!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 |
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
const int N = 2e5 + 5;
long long h[N], s[N];
int w[N];
vector<int> g[N];
bool used[N];
void dfs(int node) {
if (used[node]) return;
used[node] = 1;
vector<int> t;
for (int to : g[node]) {
dfs(to);
t.push_back(w[to]);
}
sort(t.begin(), t.end());
t.erase(unique(t.begin(), t.end()), t.end());
while (w[node] < t.size() && t[w[node]] == w[node]) w[node]++;
s[w[node]] ^= h[node];
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
}
for (int i = 0; i < n; i++) {
dfs(i);
}
int mx = -1;
for (int i = 0; i < n; i++) {
if (s[i] != 0) {
mx = max(mx, i);
}
}
if (mx != -1) {
cout << "WIN\n";
for (int i = 0; i < n; i++) {
if (w[i] == mx && (s[mx] ^ h[i]) < h[i]) {
h[i] = s[mx] ^ h[i];
for (int to : g[i]) {
if (s[w[to]] != 0) {
h[to] = s[w[to]] ^ h[to];
s[w[to]] = 0;
}
}
break;
}
}
for (int i = 0; i < n; i++) cout << h[i] << " ";
} else {
cout << "LOSE";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int n, m, h[N], nxt[N], adj[N], rd[N], u, v, t, id[N], mx, q[N], top1, top2;
long long a[N], val[N];
bool vs[N];
inline void add() { nxt[++t] = h[u], h[u] = t, adj[t] = v; }
int main() {
scanf("%d%d", &n, &m);
register int i;
for (i = 1; i <= n; ++i) scanf("%lld", &a[i]);
while (m--) scanf("%d%d", &u, &v), add(), ++rd[v];
for (i = 1; i <= n; ++i)
if (!rd[i]) q[++top2] = i;
while (top1 < top2)
for (i = h[u = q[++top1]]; i; i = nxt[i])
if (!--rd[adj[i]]) q[++top2] = adj[i];
for (i = n; i; --i) {
for (v = h[u = q[i]]; v; v = nxt[v]) vs[id[adj[v]]] = 1;
while (vs[id[u]]) ++id[u];
id[u] > mx ? mx = id[u] : 0, val[id[u]] ^= a[u];
for (v = h[u]; v; v = nxt[v]) vs[id[adj[v]]] = 0;
}
for (i = mx; ~i; --i)
if (val[i]) break;
if (i < 0) return puts("LOSE"), 0;
puts("WIN"), u = i;
for (i = 1; i <= n; ++i)
if (id[i] == u) {
if ((val[id[i]] ^ a[i]) > a[i]) continue;
a[i] ^= val[id[i]], val[id[i]] = 0;
for (v = h[i]; v; v = nxt[v])
a[adj[v]] ^= val[id[adj[v]]], val[id[adj[v]]] = 0;
}
for (i = 1; i <= n; ++i) printf("%lld ", a[i]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 200200;
vector<int> g[N];
int ord[N];
int ordSz;
bool used[N];
int n, m;
int a[N];
int b[N];
int c[N];
bool mex[N];
void dfs(int v) {
used[v] = 1;
for (int u : g[v]) {
if (used[u]) continue;
dfs(u);
}
ord[ordSz++] = v;
}
void printAns(int v) {
a[v] ^= c[b[v]];
c[b[v]] = 0;
for (int u : g[v]) {
a[u] ^= c[b[u]];
c[b[u]] = 0;
}
for (int i = 0; i < n; i++) printf("%d ", a[i]);
printf("\n");
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
while (m--) {
int v, u;
scanf("%d%d", &v, &u);
v--;
u--;
g[v].push_back(u);
}
for (int i = 0; i < n; i++) {
if (used[i]) continue;
dfs(i);
}
for (int i = 0; i < n; i++) {
int v = ord[i];
for (int j = 0; j <= (int)g[v].size(); j++) mex[j] = 0;
for (int u : g[v]) mex[b[u]] = 1;
b[v] = 0;
while (mex[b[v]]) b[v]++;
}
for (int i = 0; i < n; i++) c[b[i]] ^= a[i];
int mx = -1;
for (int i = 0; i < n; i++) {
if (c[i] != 0) mx = i;
}
if (mx == -1) {
printf("LOSE\n");
return 0;
}
printf("WIN\n");
for (int v = 0; v < n; v++) {
if (b[v] != mx) continue;
if ((a[v] ^ c[mx]) > a[v]) continue;
printAns(v);
return 0;
}
throw;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
struct city {
int estart;
long long int tax;
bool visited;
int mex;
} v[200003];
struct edge {
int enext, to;
} e[200003];
int n, m;
void dfs(int i) {
v[i].visited = true;
std::vector<int> temp;
for (int j = v[i].estart; j != -1; j = e[j].enext) {
int to = e[j].to;
if (!v[to].visited) {
dfs(to);
}
temp.push_back(v[to].mex);
}
std::sort(temp.begin(), temp.end());
int mex = 0;
for (int i = 0; i < temp.size(); ++i) {
if (temp[i] > mex) break;
if (temp[i] == mex) ++mex;
}
v[i].mex = mex;
}
long long int w[200003];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%I64d", &v[i].tax);
v[i].estart = -1;
}
for (int i = 0; i < m; ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
e[i].enext = v[a].estart;
e[i].to = b;
v[a].estart = i;
}
int maxm = 0;
for (int i = 0; i < n; ++i) {
if (!v[i].visited) {
dfs(i);
}
if (v[i].mex > maxm) maxm = v[i].mex;
w[v[i].mex] ^= v[i].tax;
}
int i = maxm;
while (i >= 0 && w[i] == 0) --i;
if (i == -1) {
printf("LOSE\n");
return 0;
}
int x = -1;
for (int j = 0; j < n; ++j)
if (v[j].mex == i && (v[j].tax ^ w[i]) < v[j].tax) {
x = j;
break;
}
v[x].tax ^= w[i];
w[i] = 0;
for (int j = v[x].estart; j != -1; j = e[j].enext) {
int to = e[j].to;
if (v[to].mex < i) {
v[to].tax ^= w[v[to].mex];
w[v[to].mex] = 0;
}
}
printf("WIN\n");
for (int i = 0; i < n; ++i) {
printf("%I64d ", v[i].tax);
}
printf("\n");
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct node {
int to, nxt;
} edge[200100];
int val[200100], maxn, cnt, head[200100], n, m;
long long h[200100], X[710];
void addedge(int x, int y) {
edge[++cnt].to = y;
edge[cnt].nxt = head[x];
head[x] = cnt;
}
void dfs(int x) {
if (val[x] != -1) return;
bool vis[710] = {0};
for (int i = head[x]; i; i = edge[i].nxt) {
int upup = edge[i].to;
dfs(upup);
vis[val[upup]] = 1;
}
for (int i = 0;; i++)
if (!vis[i]) {
val[x] = i;
break;
}
maxn = max(maxn, val[x]);
X[val[x]] ^= h[x];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%lld", &h[i]);
memset(val, -1, sizeof(val));
for (int i = 1, x, y; i <= m; i++) {
scanf("%d%d", &x, &y);
addedge(x, y);
}
for (int i = 1; i <= n; i++) dfs(i);
for (int i = maxn; i >= 0; i--)
if (X[i]) {
puts("WIN");
for (int j = 1; j <= n; j++)
if (val[j] == i && (h[j] ^ X[i]) < h[j]) {
h[j] ^= X[i];
X[i] = 0;
for (int k = head[j]; k; k = edge[k].nxt) {
int upup = edge[k].to;
if (X[val[upup]]) {
h[upup] = X[val[upup]] ^ h[upup];
X[val[upup]] = 0;
}
}
break;
}
for (int j = 1; j <= n; j++) printf("%lld ", h[j]);
puts("");
return 0;
}
puts("LOSE");
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
int n, m;
const int NN = 200011;
int h[NN];
VI adj[NN];
map<int, int> g;
int tot[NN];
inline int get(int u) {
if (g.count(u)) return g[u];
map<int, int> vst;
for (int v : adj[u]) {
vst[get(v)] = 1;
}
for (int i = 0;; i++)
if (vst.count(i) == 0) return g[u] = i;
}
int solve() {
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%d", h + i);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
}
for (int i = 1; i <= n; i++) tot[get(i)] ^= h[i];
int id = n;
while (id >= 0 and tot[id] == 0) id--;
if (id < 0) return puts("LOSE");
for (int i = 1; i <= n; i++)
if (g[i] == id) {
int u = tot[id] ^ h[i];
if (u < h[i]) {
h[i] = u;
for (int v : adj[i]) {
h[v] ^= tot[g[v]];
tot[g[v]] = 0;
}
puts("WIN");
for (int i = 1; i <= n; i++) printf("%d ", h[i]);
return 0;
}
}
}
int main() { solve(); }
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10, mod = 1e9 + 7;
const long long inf = 1e18;
int a[maxn];
bool mark[maxn];
vector<int> v[maxn], vec;
vector<int> vv[maxn];
int p[maxn], xr[maxn], C;
void dfs(int u) {
mark[u] = 1;
for (int y : v[u]) {
if (!mark[y]) dfs(y);
}
vec.push_back(u);
}
void add(int u) {
for (int y : v[u]) {
mark[p[y]] = 1;
}
for (int i = 0; i <= C; i++) {
if (mark[i] == 0) {
p[u] = i;
vv[i].push_back(u);
xr[i] ^= a[u];
if (i == C) C++;
break;
}
}
for (int y : v[u]) {
mark[p[y]] = 0;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
}
for (int i = 1; i <= n; i++) {
if (!mark[i]) dfs(i);
}
memset(mark, 0, sizeof mark);
for (int i = 0; i < n; i++) {
add(vec[i]);
}
int lst = -1;
for (int i = 0; i < C; i++) {
if (xr[i] != 0) lst = i;
}
if (lst == -1) return cout << "LOSE\n", 0;
int bt = 31 - __builtin_clz(xr[lst]), who = 0;
for (int u : vv[lst]) {
if ((((a[u]) >> (bt)) & 1)) {
who = u;
}
}
assert(who != -1);
a[who] ^= xr[lst];
for (int y : v[who]) {
if (mark[p[y]]) continue;
mark[p[y]] = 1;
a[y] ^= xr[p[y]];
}
cout << "WIN\n";
for (int i = 1; i <= n; i++) {
cout << a[i] << " ";
}
return cout << endl, 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9;
const long double eps = 0.00000000001;
int n, m;
vector<int> E[300000];
int tab[300000];
int vis[300000];
int levelId[300000];
int levelXor[300000];
void dfs(int a) {
vis[a] = true;
vector<int> L;
for (int v : E[a]) {
if (!vis[v]) {
dfs(v);
}
L.push_back(levelId[v]);
}
L.push_back(inf);
sort(L.begin(), L.end());
L.resize(unique(L.begin(), L.end()) - L.begin());
int level = 0;
while (level == L[level]) {
level++;
}
levelId[a] = level;
levelXor[level] ^= tab[a];
}
void countMove(int level) {
int high = 0;
for (int i = 0; i <= 30; i++) {
if (((1 << i) & levelXor[level]) != 0) {
high = i;
}
}
int a = -1;
for (int i = 1; i <= n; i++) {
if (levelId[i] == level) {
if (((1 << high) & tab[i]) != 0) {
a = i;
}
}
}
tab[a] ^= levelXor[level];
levelXor[level] = 0;
for (int v : E[a]) {
if (levelXor[levelId[v]] != 0) {
tab[v] ^= levelXor[levelId[v]];
levelXor[levelId[v]] = 0;
}
}
}
void solve() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> tab[i];
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
E[u].push_back(v);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i);
}
}
int level = -1;
for (int i = 0; i <= n; i++) {
if (levelXor[i] != 0) {
level = i;
}
}
if (level == -1) {
cout << "LOSE"
<< "\n";
return;
}
countMove(level);
cout << "WIN"
<< "\n";
for (int i = 1; i <= n; i++) {
cout << tab[i] << " ";
}
cout << "\n";
}
void clear() {}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
int z = 1;
for (int i = 0; i < z; i++) {
solve();
clear();
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m;
vector<int> edges[N];
bool vis[N];
int mex[N];
int getMex(int u) {
if (~mex[u]) return mex[u];
vector<bool> vis(edges[u].size() + 1, false);
for (int v : edges[u]) {
vis[min(getMex(v), (int)edges[u].size())] = true;
}
mex[u] = 0;
while (vis[mex[u]]) ++mex[u];
return mex[u];
}
long long h[N];
long long x[N];
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%lld", &h[i]);
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
edges[--u].push_back(--v);
}
memset(mex, -1, sizeof mex);
for (int i = 0; i < n; ++i) {
x[getMex(i)] ^= h[i];
}
for (int i = n - 1; i >= 0; --i) {
if (x[i] == 0) continue;
printf("WIN\n");
for (int j = 0; j < n; ++j) {
if (getMex(j) != i) continue;
if ((x[i] ^ h[j]) >= h[j]) continue;
h[j] = (x[i] ^ h[j]);
vector<bool> vis(i + 1, false);
for (int v : edges[j]) {
if (getMex(v) < i && !vis[getMex(v)]) {
h[v] = (x[getMex(v)] ^ h[v]);
vis[getMex(v)] = true;
}
}
break;
}
for (int j = 0; j < n; ++j) printf("%lld ", h[j]);
printf("\n");
return 0;
}
printf("LOSE\n");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
const long long INF = 1e18;
const int inf = 1e9;
const int MAXN = 3e5 + 200;
const long double eps = 1e-16;
const long double pi = acos(-1.0);
using namespace std;
int dx[] = {0, 1, 1, 1, -1, -1, -1};
int dy[] = {1, -1, 0, 1, -1, 0, 1, -1};
int n, m;
long long a[MAXN], H[MAXN];
int M[MAXN];
vector<int> g[MAXN];
void dfs(int v) {
set<int> st;
int kol = 1;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (M[to]) {
st.insert(M[to]);
continue;
}
dfs(to);
st.insert(M[to]);
}
while (st.find(kol) != st.end()) kol++;
M[v] = kol;
}
void solve() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
}
for (int i = 0; i < n; i++)
if (!M[i]) dfs(i);
for (int i = 0; i < n; i++) H[M[i]] ^= a[i];
int top = 0;
for (int i = 0; i < MAXN; i++)
if (H[i]) top = i;
if (top == 0) {
cout << "LOSE\n";
return;
}
cout << "WIN\n";
int ind = -1;
for (int i = 0; i < n; i++) {
if (M[i] == top) {
if ((a[i] ^ H[top]) < a[i]) {
ind = i;
break;
}
}
}
a[ind] ^= H[top];
for (int i = 0; i < g[ind].size(); i++) {
int to = g[ind][i];
H[M[to]] ^= a[to];
a[to] = H[M[to]];
H[M[to]] = 0;
}
for (int i = 0; i < n; i++) cout << a[i] << " ";
}
int main() {
ios::sync_with_stdio(NULL), cin.tie(0), cout.tie(0);
int step;
step = 1;
for (int i = 1; i <= step; i++) {
solve();
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, h[200012], cnt = 0, a[200012], f[200012], b[200012], c[200012];
bool vis[200012];
struct Edge {
int to, next;
} e[200012];
inline void AddEdge(int x, int y) {
e[++cnt] = (Edge){y, h[x]};
h[x] = cnt;
}
void dfs(int x) {
if (vis[x]) return;
vis[x] = 1;
int i;
for (i = h[x]; i; i = e[i].next) dfs(e[i].to);
for (i = h[x]; i; i = e[i].next) b[f[e[i].to]] = x;
for (f[x] = 0; b[f[x]] == x; ++f[x])
;
}
int main() {
scanf("%d%d", &n, &m);
int i, x, y, p, o = 0;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
AddEdge(x, y);
}
for (i = 1; i <= n; i++) dfs(i), c[f[i]] ^= a[i];
for (i = n; i >= 0; i--)
if (c[i]) break;
p = i;
if (p == (-1)) {
printf("LOSE");
return 0;
}
printf("WIN\n");
for (x = 1; x <= n; x++)
if ((f[x] == p) && ((a[x] ^ c[p]) < a[x])) a[x] ^= c[p], c[p] = 0, o = x;
for (i = h[o]; i; i = e[i].next)
if (f[y = e[i].to] < p) a[y] ^= c[f[y]], c[f[y]] = 0;
for (x = 1; x <= n; x++) printf("%d ", a[x]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
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++) h[i] = gi();
for (int i = 1, u, v; i <= m; i++)
u = gi(), ++deg[v = gi()], 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>
int h[200010], SG[200010], sum[200010];
int fir[200010], nxt[200010], dis[200010], id;
void link(int a, int b) { nxt[++id] = fir[a], fir[a] = id, dis[id] = b; }
int que[200010], hd = 1, tl = 1, in[200010];
int c[200010];
int main() {
int n, m, a, b;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &h[i]);
while (m--) scanf("%d%d", &a, &b), link(a, b), ++in[b];
for (int i = 1; i <= n; ++i)
if (!in[i]) que[tl++] = i;
while (hd ^ tl)
for (int i = fir[que[hd++]]; i; i = nxt[i])
if (!--in[dis[i]]) que[tl++] = dis[i];
for (int o = n, x; o; --o) {
x = que[o];
for (int i = fir[x]; i; i = nxt[i]) ++c[SG[dis[i]]];
while (c[SG[x]]) ++SG[x];
sum[SG[x]] ^= h[x];
for (int i = fir[x]; i; i = nxt[i]) --c[SG[dis[i]]];
}
for (int i = n, x; ~i; --i)
if (sum[i]) {
for (int j = 1; j <= n; ++j)
if (SG[j] == i && h[j] > (h[j] ^ sum[i])) x = j;
h[x] ^= sum[i];
for (int j = fir[x]; j; j = nxt[j])
h[dis[j]] ^= sum[SG[dis[j]]], sum[SG[dis[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;
struct edge {
int to, nxxt;
} e[200005 << 1];
queue<int> q;
vector<int> v[200005];
bool vis[200005];
int head[200005], cnt = 1, n, m, a[200005], id[200005], b[200005], tot,
rd[200005], tb[200005], xr[200005], mx;
inline void ins(int u, int v) {
e[cnt] = (edge){v, head[u]};
head[u] = cnt++;
}
int main() {
memset(id, -1, sizeof(id));
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
ins(x, y);
rd[y]++;
}
for (int i = 1; i <= n; i++)
if (!rd[i]) q.push(i);
while (!q.empty()) {
int a1 = q.front();
q.pop();
b[++tot] = a1;
for (int i = head[a1]; i; i = e[i].nxxt) {
int j = e[i].to;
rd[j]--;
if (!rd[j]) q.push(j);
}
}
for (int i = n; i; i--) {
int x = b[i];
tot = 0;
for (int j = head[x]; j; j = e[j].nxxt) {
tb[++tot] = id[e[j].to];
}
sort(tb + 1, tb + 1 + tot);
if (tb[1] > 0 || !tot)
id[x] = 0;
else {
for (int j = 1; j < tot; j++)
if (tb[j] + 1 < tb[j + 1]) {
id[x] = tb[j] + 1;
break;
}
if (id[x] < 0) id[x] = tb[tot] + 1;
}
}
for (int i = 1; i <= n; i++) xr[id[i]] ^= a[i];
bool flag = false;
for (int i = 0; i <= n; i++)
if (xr[i]) {
flag = true;
break;
}
if (!flag) {
puts("LOSE");
return 0;
}
puts("WIN");
for (int i = 1; i <= n; i++) mx = max(mx, id[i]);
for (int i = 1; i <= n; i++) v[id[i]].push_back(i);
for (int i = mx; ~i; i--)
if (xr[i]) {
int te;
for (int j = 0; j < v[i].size(); j++) {
int to = v[i][j];
if ((xr[i] ^ a[to]) < a[to]) {
te = v[i][j];
break;
}
}
a[te] ^= xr[i];
for (int j = head[te]; j; j = e[j].nxxt) {
int to = e[j].to;
if (!vis[id[to]]) {
a[to] ^= xr[id[to]];
vis[id[to]] = 1;
}
}
break;
}
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
puts("");
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
struct fastio {
char s[100000];
int it, len;
fastio() { it = len = 0; }
inline char get() {
if (it < len) return s[it++];
it = 0;
len = fread(s, 1, 100000, stdin);
if (len == 0)
return EOF;
else
return s[it++];
}
bool notend() {
char c = get();
while (c == ' ' || c == '\n') c = get();
if (it > 0) it--;
return c != EOF;
}
} _buff;
inline long long getnum() {
long long r = 0;
bool ng = 0;
char c;
c = _buff.get();
while (c != '-' && (c < '0' || c > '9')) c = _buff.get();
if (c == '-') ng = 1, c = _buff.get();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = _buff.get();
return ng ? -r : r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline char getreal() {
char c = _buff.get();
while (c <= 32) c = _buff.get();
return c;
}
long long qpow(long long x, long long k) {
return k == 0 ? 1
: 1ll * qpow(1ll * x * x % mod, k >> 1) * (k & 1 ? x : 1) % mod;
}
const int maxn = 200111;
int n, m;
int mex[maxn], a[maxn];
bool hs[maxn];
int xsum[maxn];
vector<int> con[maxn];
void dfs(int x) {
if (mex[x] != -1) return;
for (auto u : con[x]) {
dfs(u);
}
for (auto u : con[x]) hs[mex[u]] = 1;
mex[x] = 0;
while (hs[mex[x]]) mex[x]++;
for (auto u : con[x]) hs[mex[u]] = 0;
xsum[mex[x]] ^= a[x];
}
void output_ans(int L) {
static int ans[maxn];
for (int i = 1; i <= n; i++) ans[i] = a[i];
int x = -1;
for (int i = 1; i <= n; i++) {
if (mex[i] == L) {
if ((xsum[L] ^ a[i]) < a[i]) {
x = i;
break;
}
}
}
ans[x] = xsum[L] ^ a[x];
for (auto u : con[x]) {
if (!hs[mex[u]]) {
hs[mex[u]] = true;
ans[u] = xsum[mex[u]] ^ a[u];
}
}
for (int i = 1; i <= n; i++) putnum(ans[i]), putchar(' ');
}
int main() {
n = getnum(), m = getnum();
for (int i = 1; i <= n; i++) a[i] = getnum();
for (int i = 1; i <= m; i++) {
int x, y;
x = getnum(), y = getnum();
con[x].push_back(y);
}
memset(mex, -1, sizeof(mex));
for (int i = 1; i <= n; i++) {
if (mex[i] == -1) dfs(i);
}
for (int i = n; i >= 0; i--) {
if (xsum[i] != 0) {
puts("WIN");
output_ans(i);
return 0;
}
}
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int c = 200002;
queue<int> q;
vector<int> sz[c], s[c], f[c];
long long n, m, be[c], me[c], t[c], xo[c], maxi;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> t[i], f[i].push_back(c);
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
sz[a].push_back(b), s[b].push_back(a);
be[a]++;
}
for (int i = 1; i <= n; i++)
if (!be[i]) q.push(i);
while (q.size() > 0) {
int id = q.front(), pr = 0;
q.pop();
sort(f[id].begin(), f[id].end());
for (int i = 0; i < f[id].size(); i++) {
if (f[id][i] - pr > 1) {
pr++;
xo[pr] ^= t[id];
me[id] = pr;
break;
}
pr = f[id][i];
}
for (int i = 0; i < s[id].size(); i++) {
int x = s[id][i];
f[x].push_back(me[id]);
be[x]--;
if (!be[x]) q.push(x);
}
}
for (int i = 1; i <= n; i++) {
if (xo[i]) maxi = i;
}
if (!maxi) {
cout << "LOSE\n";
} else {
cout << "WIN\n";
for (int i = 1; i <= n; i++) {
if (me[i] == maxi && (t[i] ^ xo[me[i]]) < t[i]) {
for (int j = 0; j < sz[i].size(); j++) {
int x = sz[i][j];
if (xo[me[x]]) {
t[x] ^= xo[me[x]];
xo[me[x]] = 0;
}
}
t[i] ^= xo[maxi];
xo[maxi] = 0;
break;
}
}
for (int i = 1; i <= n; i++) {
cout << t[i] << " ";
}
cout << "\n";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int NN = 200011;
vector<int> adj[NN];
int n, m;
int h[NN];
int xo[NN];
int g[NN];
int ans[NN];
int vst[NN];
int runs = 1;
int calc(int u) {
if (~g[u]) return g[u];
for (int v : adj[u]) calc(v);
runs++;
for (int v : adj[u]) vst[g[v]] = runs;
for (int i = 0;; i++)
if (vst[i] ^ runs) return g[u] = i;
}
int solve() {
memset(g, -1, sizeof g);
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%d", h + i), ans[i] = h[i];
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
}
for (int i = 1; i <= n; i++) xo[calc(i)] ^= h[i];
int id = -1;
for (int i = 0; i <= n; i++)
if (xo[i]) id = i;
if (id == -1) return puts("LOSE");
puts("WIN");
int now = -1;
for (int i = 1; i <= n; i++)
if (g[i] == id) {
int u = xo[id] ^ h[i];
if (u < h[i]) {
ans[i] = u;
now = i;
break;
}
}
assert(now != -1);
for (int u : adj[now]) ans[u] = xo[g[u]] ^ h[u], xo[g[u]] = 0;
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
int main() {
solve();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, SG[200005], Mx, h[200005], sum[200005];
bool vis[200005];
int fir[200005], nxt[200005], to[200005], tot;
inline void line(int x, int y) {
nxt[++tot] = fir[x];
fir[x] = tot;
to[tot] = y;
}
void dfs(int u) {
for (int i = fir[u]; i; i = nxt[i])
if (!SG[to[i]]) dfs(to[i]);
for (int i = fir[u]; i; i = nxt[i]) vis[SG[to[i]]] = 1;
int x = 1;
while (vis[x] == 1) x++;
Mx = max(Mx, SG[u] = x), sum[x] ^= h[u];
for (int i = fir[u]; i; i = nxt[i]) vis[SG[to[i]]] = 0;
}
int main() {
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), line(x, y);
for (int i = 1; i <= n; i++)
if (!SG[i]) dfs(i);
for (int k = Mx, id = 0; k >= 1; k--)
if (sum[k]) {
for (int i = 1; i <= n; i++)
if (SG[i] == k && (h[i] ^ sum[k]) < h[i]) id = i;
h[id] ^= sum[k];
for (int i = fir[id]; i; i = nxt[i])
if (!vis[SG[to[i]]]) h[to[i]] ^= sum[SG[to[i]]], vis[SG[to[i]]] = 1;
puts("WIN");
for (int i = 1; i <= n; i++) printf("%d%c", h[i], i == n ? 10 : 32);
return 0;
}
puts("LOSE");
}
| 11 | CPP |
#include <bits/stdc++.h>
using std::cerr;
using std::endl;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int MAXN = 200005;
int n, m, ecnt, head[MAXN], deg[MAXN];
int a[MAXN], sg[MAXN], sum[MAXN];
std::vector<int> ie[MAXN];
struct Edge {
int to, nxt;
} e[MAXN];
inline void add_edge(int bg, int ed) {
++ecnt;
e[ecnt].to = ed;
e[ecnt].nxt = head[bg];
head[bg] = ecnt;
}
std::queue<int> q;
int vis[MAXN];
void topo() {
while (!q.empty()) q.pop();
for (int i = (1); i <= (n); ++i)
if (!deg[i]) q.push(i);
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = head[x]; i; i = e[i].nxt) {
int ver = e[i].to;
vis[sg[ver]] = x;
}
for (int i = (0); i <= (1e9); ++i) {
if (vis[i] != x) {
sg[x] = i;
break;
}
}
sum[sg[x]] ^= a[x];
for (int i = (0); i <= ((int)ie[x].size() - 1); ++i) {
int ver = ie[x][i];
--deg[ver];
if (!deg[ver]) q.push(ver);
}
}
}
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();
add_edge(u, v);
ie[v].push_back(u);
++deg[u];
}
topo();
int max_sg = -1;
for (int i = (n - 1); i >= (0); --i) {
if (sum[i]) {
max_sg = i;
break;
}
}
if (max_sg == -1) {
printf("LOSE\n");
return 0;
}
printf("WIN\n");
for (int i = (1); i <= (n); ++i) {
if (sg[i] == max_sg && (a[i] ^ sum[max_sg]) < a[i]) {
a[i] ^= sum[max_sg];
sum[max_sg] = 0;
for (int j = head[i]; j; j = e[j].nxt) {
int ver = e[j].to;
a[ver] ^= sum[sg[ver]];
sum[sg[ver]] = 0;
}
}
}
for (int i = (1); i <= (n); ++i) printf("%d ", a[i]);
putchar('\n');
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
if (flag) x = -x;
}
int n, m;
int v[200010], w[200010], s[200010], d[200010], tag[200010];
vector<int> ve[200010];
struct edge {
int to, nxt;
} e[200010];
int head[200010], edge_cnt;
void add(int from, int to) {
e[++edge_cnt] = {to, head[from]}, head[from] = edge_cnt;
}
void topo() {
queue<int> q;
for (int i = 1; i <= n; ++i)
if (!d[i]) q.push(i);
while (!q.empty()) {
int x = q.front();
q.pop();
for (int i = head[x]; i; i = e[i].nxt)
if (--d[e[i].to] == 0) q.push(e[i].to);
for (int i = 0; i < ve[x].size(); ++i) tag[w[ve[x][i]]] = x;
while (tag[w[x]] == x) w[x]++;
s[w[x]] ^= v[x];
}
}
int main() {
read(n), read(m);
for (int i = 1; i <= n; ++i) read(v[i]);
for (int i = 1; i <= m; ++i) {
int x, y;
read(x), read(y);
ve[x].push_back(y), add(y, x), d[x]++;
}
topo();
for (int i = n; i >= 0; --i) {
if (!s[i]) continue;
int pos;
for (int j = 1; j <= n; ++j)
if (w[j] == i && v[j] > (v[j] ^ s[i])) pos = j;
v[pos] ^= s[i];
for (int j = 0; j < ve[pos].size(); ++j) {
int x = ve[pos][j];
v[x] ^= s[w[x]], s[w[x]] = 0;
}
puts("WIN");
for (int j = 1; j <= n; ++j) printf("%d ", v[j]);
return 0;
}
puts("LOSE");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int c = 200002;
queue<int> q;
vector<int> sz[c], s[c], f[c];
long long n, m, be[c], me[c], t[c], xo[c], maxi;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> t[i], f[i].push_back(c);
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
sz[a].push_back(b), s[b].push_back(a);
be[a]++;
}
for (int i = 1; i <= n; i++)
if (!be[i]) q.push(i);
while (q.size() > 0) {
int id = q.front(), pr = 0;
q.pop();
sort(f[id].begin(), f[id].end());
for (int i = 0; i < f[id].size(); i++) {
if (f[id][i] - pr > 1) {
pr++;
xo[pr] ^= t[id];
me[id] = pr;
break;
}
pr = f[id][i];
}
for (int i = 0; i < s[id].size(); i++) {
int x = s[id][i];
f[x].push_back(me[id]);
be[x]--;
if (!be[x]) q.push(x);
}
}
for (int i = 1; i <= n; i++) {
if (xo[i]) maxi = i;
}
if (!maxi) {
cout << "LOSE\n";
} else {
cout << "WIN\n";
for (int i = 1; i <= n; i++) {
if (me[i] == maxi && (t[i] ^ xo[me[i]]) < t[i]) {
for (int j = 0; j < sz[i].size(); j++) {
int x = sz[i][j];
if (xo[me[x]]) {
t[x] ^= xo[me[x]];
xo[me[x]] = 0;
}
}
t[i] ^= xo[maxi];
xo[maxi] = 0;
break;
}
}
for (int i = 1; i <= n; i++) {
cout << t[i] << " ";
}
cout << "\n";
}
return 0;
}
| 11 | CPP |
m = int(input())
l = [0 for _ in range(m + 1)]
for _ in range(m - 1):
a,b = map(int, input().split())
l[a] += 1
l[b] += 1
if 2 in l:
print("NO")
else:
print("YES")
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void pr_init() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
vector<vector<long long> > tree;
vector<long long> deg;
void solve() {
long long n;
cin >> n;
tree.assign(n + 1, vector<long long>());
deg.assign(n + 1, 0);
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
deg[u]++;
deg[v]++;
tree[u].emplace_back(v);
tree[v].emplace_back(u);
}
if (n == 2) {
cout << "YES\n";
return;
} else if (n == 3) {
cout << "NO\n";
return;
}
bool is = true;
for (long long i = 1; i <= n; i++) {
if (deg[i] != 1 && deg[i] < 3) is = false;
}
if (is)
cout << "YES\n";
else
cout << "NO\n";
}
int32_t main() {
solve();
return 0;
}
| 10 | CPP |
# @author
import sys
class D1AddOnATree:
def dfs(self, start):
self.done[start] = 1
for x in self.adj[start]:
if self.done[x]:
continue
self.par[x] = start
self.dfs(x)
def solve(self):
from collections import defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 5)
n = int(input())
self.adj = defaultdict(list)
self.par = defaultdict(int)
self.done = [0] * (n + 1)
for i in range(n - 1):
u, v = [int(_) for _ in input().split()]
self.adj[u].append(v)
self.adj[v].append(u)
self.done[u] += 1
self.done[v] += 1
for i in range(1, n + 1):
if self.done[i] == 2:
print("NO")
break
else:
print("YES")
return
v = max(len(self.adj[p]) for p in self.adj)
start = -1
for p in self.adj:
if len(self.adj[p]) == v:
start = p
break
assert(start != -1)
self.dfs(start)
cnt = [0] * (n + 1)
for k in self.adj:
if self.par[k] == 0:
continue
if len(self.adj[k]) == 1:
cnt[self.par[k]] += 1
ans = 0
for x in cnt:
if x == 1:
ans += 1
# for x in adj:
# if self.adj
if ans == 0:
print("YES")
else:
print("NO")
solver = D1AddOnATree()
input = sys.stdin.readline
solver.solve()
| 10 | PYTHON3 |
n=int(input())
deg=[0]*n
for i in range(n-1):
u,v=map(int,input().split())
u-=1
v-=1
deg[u]+=1
deg[v]+=1
for d in deg:
if d==2:
print("NO")
exit(0)
print("YES") | 10 | PYTHON3 |
from collections import defaultdict, deque
from heapq import heappush, heappop
from math import inf
ri = lambda : map(int, input().split())
def solve():
n = int(input())
cnt = defaultdict(int)
for _ in range(n-1):
x,y = ri()
cnt[x] += 1
cnt[y] += 1
valid = True
for x in cnt:
if cnt[x] == 2:
valid = False
if valid:
print("YES")
else:
print("NO")
t = 1
#t = int(input())
while t:
t -= 1
solve()
| 10 | PYTHON3 |
n = int(input())
tree_nums = [0 for i in range(n)]
for i in range(n - 1):
a1, a2 = map(int, input().split())
tree_nums[a1 - 1] += 1
tree_nums[a2 - 1] += 1
if n == 2:
print('YES')
elif n == 3:
print('NO')
else:
ans_is_no = False
for i in range(n):
if tree_nums[i] == 2:
ans_is_no = True
print('NO')
break
if not ans_is_no:
print('YES') | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ind[n];
memset(ind, 0, sizeof(ind));
int u, v;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
u--;
v--;
ind[u]++;
ind[v]++;
}
bool f = 1;
int c1 = 0, c2 = 0;
for (int i = 0; i < n; i++) {
if (ind[i] == 2) {
return cout << "NO", 0;
}
}
cout << "YES";
}
| 10 | CPP |
n = int(input())
gr = {i: 0 for i in range(1, n + 1)}
for i in range(n - 1):
a, b = map(int, input().split())
gr[a] += 1
gr[b] += 1
for i in gr:
if gr[i] == 2:
print('NO')
exit(0)
print('YES') | 10 | PYTHON3 |
n = int(input())
arr = [0] * (n+1)
for _ in range(n-1):
a,b = map(int,input().split())
arr[a] += 1
arr[b] += 1
for i in range(1,n+1):
if arr[i] == 2:
print("NO")
break
else:
print("YES")
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int power(long long int x, long long int y) {
long long int temp;
if (y == 0) return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
return x * temp * temp;
}
bool prime_check(long long int n) {
long long int i, j;
if (n == 1) {
return false;
}
for (i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
long long int fact(long long int n) {
long long int prod = 1;
for (long long int i = 1; i <= n; i++) {
prod = (prod * i) % 1000000007;
}
return prod;
}
bool vowl(char c) {
return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, i, u, v;
cin >> n;
int freq[100003] = {};
for (i = 0; i < n - 1; i++) {
cin >> u >> v;
u--;
v--;
freq[u]++;
freq[v]++;
}
for (i = 0; i < n; i++) {
if (freq[i] == 2) break;
}
if (i == n)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 10 | CPP |
n = int(input())
g = [[] for i in range(n+1)]
d = [0]*100001
for i in range(n-1):
u, v = [int(i) for i in input().split()]
g[u].append(v)
g[v].append(u)
d[u] += 1
d[v] += 1
for i in d:
if i == 2:
print("NO")
break
else:
print("YES")
| 10 | PYTHON3 |
n = int(input())
edges = [0] * (n)
for i in range(n-1):
a, b = list(map(int, input().split()))
edges[a-1] +=1
edges[b-1] +=1
if 2 in edges:
print("NO")
else:
print("YES") | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, p, q;
vector<int> G[100005];
int main() {
cin >> n;
for (i = 0; i < n - 1; i++) {
cin >> p >> q;
G[p - 1].push_back(q - 1);
G[q - 1].push_back(p - 1);
}
bool flag = false;
for (i = 0; i < n; i++) {
if (G[i].size() == 2) {
flag = true;
break;
}
}
if (!flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 10 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.