text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int M = 405, C = N / M + 5;
char s[N];
int n, q, op, x, y;
char t[N];
int len;
bitset<N> a[26], b, c;
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1, _b = n; i <= _b; i++) a[s[i] - 'a'][i] = 1;
scanf("%d", &q);
for (int i = 1, _b = n; i <= _b; i++) b[i - 1] = 1;
for (int ii = 1, _b = q; ii <= _b; ii++) {
scanf("%d", &op);
if (op == 1) {
scanf("%d", &x);
scanf("%s", t + 1);
len = strlen(t + 1);
a[s[x] - 'a'][x] = 0;
s[x] = t[1];
a[s[x] - 'a'][x] = 1;
} else {
scanf("%d %d", &x, &y);
scanf("%s", t + 1);
len = strlen(t + 1);
c = b;
for (int i = 1, _b = len; i <= _b; i++) {
c &= a[t[i] - 'a'] >> i;
}
y -= len - 1;
if (y < x) {
printf("0\n");
} else {
printf("%d\n", (c >> (x - 1)).count() - (c >> (y)).count());
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T& n) {
char ch;
int sign = 1;
while (!isdigit(ch = getchar()))
if (ch == '-') sign = -1;
n = ch - '0';
while (isdigit(ch = getchar())) n = n * 10 + ch - '0';
n *= sign;
}
const int INF = 1e9 + 7;
const int N = 122222;
int n, m, l, r, first, len, opt;
char s[N], t[N];
bitset<N> occ[35], full;
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = (1); i <= (n); ++i) occ[s[i] - 'a'][i] = 1;
for (int i = (0); i <= (N - 1); ++i) full[i] = 1;
read(m);
while (m--) {
read(opt);
if (opt == 1) {
char ch;
read(first), scanf("%c", &ch);
occ[s[first] - 'a'][first] = 0, occ[ch - 'a'][first] = 1;
s[first] = ch;
} else {
read(l), read(r), scanf("%s", t + 1);
len = strlen(t + 1);
if (r - l + 1 < len) {
puts("0");
continue;
}
bitset<N> cnt = full, tmp;
for (int i = (1); i <= (len); ++i) cnt &= occ[t[i] - 'a'] >> i;
tmp = cnt >> (r - len + 1), cnt >>= l - 1;
printf("%d\n", (int)cnt.count() - (int)tmp.count());
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace string_kit {
class suffix_automaton {
struct NODE {
int len, cnt;
int fail, next[26];
};
NODE pool[1000];
int pooltop;
int order[1000];
int root, last;
int alloc() {
int ptr = pooltop++;
pool[ptr].len = pool[ptr].cnt = 0;
pool[ptr].fail = -1;
for (int i = 0; i < 26; ++i) pool[ptr].next[i] = -1;
return ptr;
}
void radix_sort() {
static int c[1000];
for (int i = 0; i <= pool[last].len; ++i) c[i] = 0;
for (int i = 0; i < pooltop; ++i) ++c[pool[i].len];
for (int i = 1; i <= pool[last].len; ++i) c[i] += c[i - 1];
for (int i = 0; i < pooltop; ++i) order[--c[pool[i].len]] = i;
}
public:
void init() {
pooltop = 0;
root = last = alloc();
}
void extend(char ch) {
int mch = ch - 'a';
int p = last;
int np = alloc();
pool[np].len = pool[p].len + 1;
pool[np].cnt = 1;
while (p != -1 && pool[p].next[mch] == -1) {
pool[p].next[mch] = np;
p = pool[p].fail;
}
if (p == -1)
pool[np].fail = root;
else {
int q = pool[p].next[mch];
if (pool[q].len == pool[p].len + 1)
pool[np].fail = q;
else {
int nq = alloc();
pool[nq].len = pool[p].len + 1;
pool[nq].cnt = 0;
pool[nq].fail = pool[q].fail;
memcpy(pool[nq].next, pool[q].next, sizeof(pool[nq].next));
pool[q].fail = pool[np].fail = nq;
while (p != -1 && pool[p].next[mch] == q) {
pool[p].next[mch] = nq;
p = pool[p].fail;
}
}
}
last = np;
}
void extend(const char* s) {
while (*s) extend(*s++);
}
void extend(const char* s, int first, int last) {
for (int i = first; i < last; ++i) extend(s[i]);
}
void calc_cnt() {
radix_sort();
for (int i = pooltop - 1; i >= 0; --i) {
int now = order[i];
if (pool[now].fail != -1) pool[pool[now].fail].cnt += pool[now].cnt;
}
}
int count(const char* s) const {
int pnode = root;
while (*s) {
int mch = *s++ - 'a';
if (pool[pnode].next[mch] == -1)
return 0;
else
pnode = pool[pnode].next[mch];
}
return pool[pnode].cnt;
}
};
class kmp {
const char* pat;
int next[100005];
int n;
public:
void init(const char* str, int first, int last) {
pat = str + first;
next[0] = -1;
n = last - first;
for (int i = 1; i < n; ++i) {
int p = next[i - 1];
while (p >= 0 && str[first + p + 1] != str[first + i]) p = next[p];
if (p == -1)
next[i] = (str[first] == str[first + i] ? 0 : -1);
else
next[i] = p + 1;
}
}
void init(const char* str) { init(str, 0, strlen(str)); }
int count(const char* src, int first, int last) const {
int psrc = first, ppat = 0;
int ans = 0;
while (psrc < last) {
if (src[psrc] == pat[ppat]) {
++psrc;
++ppat;
} else {
if (ppat == 0)
++psrc;
else
ppat = next[ppat - 1] + 1;
}
if (ppat == n) {
++ans;
ppat = next[ppat - 1] + 1;
}
}
return ans;
}
};
} // namespace string_kit
using namespace string_kit;
char s[100005];
char buf[100005];
suffix_automaton sam[400];
kmp match;
int slen, blsize, blcnt;
int sgn(int x) {
if (x > 0)
return 1;
else if (x == 0)
return 0;
else
return -1;
}
void sam_build(int bid) {
sam[bid].init();
sam[bid].extend(s, ((bid)*blsize), min((((bid) + 1) * blsize - 1) + 1, slen));
sam[bid].calc_cnt();
}
void change(int i, char c) {
int bid = ((i) / blsize);
s[i] = c;
sam_build(bid);
}
int query(int l, int r, const char* y) {
int ylen = strlen(y);
match.init(y);
if (ylen >= blsize || ((l) / blsize) == ((r) / blsize))
return match.count(s, l, r + 1);
else {
int ans = 0;
for (int i = ((l) / blsize) + 1; i < ((r) / blsize); ++i)
ans += sam[i].count(y);
ans += match.count(s, l, (((((l) / blsize)) + 1) * blsize - 1) + 1);
ans += match.count(s, ((((r) / blsize)) * blsize), r + 1);
for (int i = ((l) / blsize) + 1; i <= ((r) / blsize); ++i) {
int rgleft = max(l, ((i)*blsize) - ylen + 1);
int rgright = min(r, (((i - 1) + 1) * blsize - 1) + ylen - 1);
ans += match.count(s, rgleft, rgright + 1);
}
return ans;
}
}
int main(int argc, char* argv[]) {
scanf("%s", s);
slen = strlen(s);
blsize = (int)sqrt(slen);
blcnt = slen / blsize + sgn(slen % blsize);
for (int i = 0; i < blcnt; ++i) sam_build(i);
int q;
scanf("%d", &q);
while (q--) {
int type;
scanf("%d", &type);
if (type == 1) {
int i;
char c;
scanf("%d %c", &i, &c);
change(i - 1, c);
} else {
int l, r;
scanf("%d%d%s", &l, &r, buf);
printf("%d\n", query(l - 1, r - 1, buf));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
char s[N], t[N];
int n, m, q, op, x, y;
bitset<N> ans, pos[26];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) pos[s[i] - 'a'].set(i);
scanf("%d", &q);
while (q--) {
scanf("%d", &op);
if (op == 1) {
scanf("%d%s", &x, t + 1);
pos[s[x] - 'a'].reset(x);
s[x] = t[1];
pos[s[x] - 'a'].set(x);
} else {
scanf("%d%d%s", &x, &y, t + 1);
m = strlen(t + 1);
ans.set();
for (int i = 1; i <= m; i++) ans &= pos[t[i] - 'a'] >> (i - 1);
int w = (ans >> x).count() - (ans >> (y - m + 2)).count();
printf("%d\n", max(w, 0));
}
}
return 0;
}
|
#include <bits/stdc++.h>
inline int sbt(int x) { return __builtin_popcount(x); }
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int n;
string s;
int q;
bitset<100013> bit[27];
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
cin >> s;
s = '$' + s;
for (int i = 1; i < s.size(); i++) {
bit[s[i] - 'a'].set(i, 1);
}
const int nm = s.size() - 1;
bitset<100013> o;
for (int i = 0; i < nm; i++) o.set(i);
cin >> q;
while (q--) {
int ty;
cin >> ty;
if (ty == 1) {
int i;
char c;
cin >> i >> c;
bit[s[i] - 'a'].set(i, 0);
bit[c - 'a'].set(i, 1);
s[i] = c;
} else {
bitset<100013> res = o;
int l, r;
string t;
cin >> l >> r >> t;
if ((r - l + 1) < t.size()) {
cout << 0 << endl;
continue;
}
t = '$' + t;
int n = t.size();
for (int i = 1; i < n; i++) {
res = (res & (bit[t[i] - 'a'] >> i));
}
if ((r - (n - 1) + 1) < 0) {
cout << 0 << endl;
continue;
}
cout << ((res >> (l - 1)).count()) - ((res >> (r - (n - 1) + 1)).count())
<< endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
bitset<maxn> b[30], ans;
char s[maxn], tmp[maxn];
int n, m;
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
scanf("%d", &m);
for (int i = 1; i <= n; ++i) {
b[s[i] - 'a'].set(i);
}
for (int i = 1; i <= m; ++i) {
int op;
scanf("%d", &op);
if (op == 1) {
int pos;
scanf("%d%s", &pos, tmp + 1);
b[s[pos] - 'a'][pos] = 0;
s[pos] = tmp[1];
b[s[pos] - 'a'][pos] = 1;
} else {
int l, r;
scanf("%d%d", &l, &r);
scanf("%s", tmp);
int len = strlen(tmp);
ans.set();
for (int i = 0; i < len; ++i) {
ans &= (b[tmp[i] - 'a'] >> i);
}
len = r - len + 2;
int left = (ans >> l).count();
int right = (ans >> len).count();
if (left < right) left = right;
printf("%d\n", left - right);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int getInt() {
int res(0);
char c = getchar();
while (c < '0') c = getchar();
while (c >= '0') {
res = res * 10 + (c - '0');
c = getchar();
}
return res;
}
inline int fastpo(int x, int n, int mod) {
int res(1);
while (n) {
if (n & 1) {
res = res * (long long)x % mod;
}
x = x * (long long)x % mod;
n /= 2;
}
return res;
}
const int N = 100000;
const int LOG = 20;
const int mod = 1e9 + 7;
const int inf = 1e9 + 7;
bitset<N> msk[26];
int main() {
string st;
cin >> st;
for (int i(0); i < (int)st.size(); i++) {
msk[st[i] - 'a'].set(i);
}
int Q;
scanf("%d", &Q);
for (int i(0); i < Q; i++) {
int tp;
scanf("%d", &tp);
if (tp == 2) {
int le, ri;
scanf("%d%d", &le, &ri);
le--;
ri--;
string a;
cin >> a;
if (ri - le + 1 < (int)a.size()) {
printf("0\n");
continue;
}
bitset<N> tmp;
tmp.set();
for (int i(0); i < (int)a.size(); i++)
tmp = tmp & (msk[a[i] - 'a'] >> (le + i));
printf("%d\n",
(int)(tmp << (N - (ri - le + 1 - (int)a.size() + 1))).count());
} else {
int le;
char c;
scanf("%d %c", &le, &c);
msk[st[le - 1] - 'a'].set(le - 1, 0);
msk[c - 'a'].set(le - 1, 1);
st[le - 1] = c;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int dr[]{-1, -1, 0, 1, 1, 1, 0, -1};
const int dc[]{0, 1, 1, 1, 0, -1, -1, -1};
void run() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int sqrtQ = 100;
struct suffix_automaton {
struct state {
int len, link = 0, cnt = 0;
bool terminal = false, is_clone = false;
vector<int> nxt;
state(int len = 0) : len(len), nxt(26, -1) {}
bool have_next(char ch) { return nxt[ch - 'a'] != -1; }
void clone(const state &other, int nlen) {
len = nlen;
nxt = other.nxt;
link = other.link;
is_clone = true;
}
};
vector<state> st;
int last = 0;
suffix_automaton() {
st.push_back(state());
st[0].link = -1;
}
suffix_automaton(const string &s) : suffix_automaton() {
for (char ch : s) extend(ch);
calc_number_of_occurrences();
}
void extend(char c) {
int cur = st.size();
st.push_back(state(st[last].len + 1));
st[cur].cnt = 1;
int p = last;
last = cur;
while (p != -1 && !st[p].have_next(c)) {
st[p].nxt[c - 'a'] = cur;
p = st[p].link;
}
if (p == -1) return;
int q = st[p].nxt[c - 'a'];
if (st[p].len + 1 == st[q].len) {
st[cur].link = q;
return;
}
int clone = st.size();
st.push_back(state());
st[clone].clone(st[q], st[p].len + 1);
while (p != -1 && st[p].nxt[c - 'a'] == q) {
st[p].nxt[c - 'a'] = clone;
p = st[p].link;
}
st[q].link = st[cur].link = clone;
}
void calc_number_of_occurrences() {
vector<vector<int>> lvl(st[last].len + 1);
for (int i = 1; i < st.size(); i++) lvl[st[i].len].push_back(i);
for (int i = st[last].len; i >= 0; i--)
for (auto cur : lvl[i]) st[st[cur].link].cnt += st[cur].cnt;
}
int count(const string &y) {
int cur = 0;
for (auto &it : y) {
if (!st[cur].have_next(it)) return 0;
cur = st[cur].nxt[it - 'a'];
}
return st[cur].cnt;
}
} SA[(int)1e4];
string y;
vector<int> longestPrefix;
vector<int> Fail[26];
int fail(int k, char nxt) {
int &rt = Fail[nxt - 'a'][k];
if (~rt) return rt;
while (k > 0 && y[k] != nxt) k = longestPrefix[k - 1];
if (nxt == y[k]) k++;
return rt = k;
}
void failure_function() {
int n = y.size();
longestPrefix = vector<int>(n);
for (int i = 0; i < 26; i++) Fail[i] = vector<int>(n + 1, -1);
for (int i = 1, k = 0; i < n; i++) longestPrefix[i] = k = fail(k, y[i]);
}
int main() {
run();
string s;
int q;
cin >> s >> q;
for (int i = 0; i < (int)(s.size()); i += sqrtQ)
SA[i / sqrtQ] = suffix_automaton(s.substr(i, sqrtQ));
auto solve = [&](int l, int r) {
int match = 0, cnt = 0;
for (int i = l; i <= r; i++) {
match = fail(match, s[i]);
if (match == (int)(y.size())) {
cnt++;
match = longestPrefix[match - 1];
}
}
return cnt;
};
while (q--) {
int t;
cin >> t;
if (t == 1) {
int idx;
char ch;
cin >> idx >> ch;
idx--;
s[idx] = ch;
SA[idx / sqrtQ] = suffix_automaton(s.substr(idx / sqrtQ * sqrtQ, sqrtQ));
} else {
int l, r;
cin >> l >> r >> y;
l--, r--;
failure_function();
if ((int)(y.size()) >= sqrtQ || r - l <= 2 * sqrtQ) {
cout << solve(l, r) << "\n";
continue;
}
int ans = 0, len = (int)(y.size());
int st = l / sqrtQ, ed = r / sqrtQ;
ans += solve(l, (st + 1) * sqrtQ + len - 2);
ans += solve(ed * sqrtQ - len + 1, r);
for (int i = st + 1; i < ed; i++) ans += SA[i].count(y);
for (int i = st + 2; i < ed; i++)
ans += solve(i * sqrtQ - len + 1, i * sqrtQ + len - 2);
cout << ans << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int sz = 1e5 + 10;
bitset<sz> s[26], an;
int main() {
string ss;
cin >> ss;
int n = ss.size(), q;
for (int a = 0; a < n; a++) s[ss[a] - 'a'][a] = 1;
cin >> q;
for (int a = 0; a < q; a++) {
int ty;
scanf("%d", &ty);
if (ty == 1) {
int p;
char sy;
scanf("%d", &p);
p--;
cin >> sy;
for (int b = 0; b < 26; b++) {
if (sy - 'a' == b)
s[b][p] = 1;
else
s[b][p] = 0;
}
} else {
int l, r;
string s2;
scanf("%d%d", &l, &r);
l--;
cin >> s2;
int m = s2.size();
an.set();
for (int b = 0; b < m; b++) an &= (s[s2[b] - 'a'] >> b);
an >>= l;
an <<= l;
an <<= (sz - r + (m - 1));
printf("%d\n", an.count());
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100010;
bitset<MAX> b[26];
bitset<MAX> c;
char s[MAX];
int main(void) {
scanf("%s", s);
int n = strlen(s);
for (int i = (0); i < (n); ++i) {
b[s[i] - 'a'].set(i);
}
int m;
scanf("%d", &m);
for (int i = (0); i < (m); ++i) {
int type;
scanf("%d", &type);
static char buf[MAX];
if (type == 1) {
int idx;
scanf("%d %s", &idx, buf);
idx--;
b[s[idx] - 'a'].reset(idx);
s[idx] = buf[0];
b[s[idx] - 'a'].set(idx);
} else {
int l, r;
scanf("%d %d %s", &l, &r, buf);
--l;
int m = strlen(buf);
c.set();
for (int i = (0); i < (m); ++i) {
int ch = buf[i] - 'a';
c &= b[ch] >> (l + i);
}
int k = r - l - m + 1;
c <<= MAX - k;
int ans = c.count();
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << '\n';
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
void run() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
}
const int N = 1e5 + 5, mod = 1e9 + 7, mod2 = 998244353, MAXN = 100000 + 29;
void files() {}
bitset<N> bits[26];
int countt(bitset<N> &a, int l) {
int shift = N - l;
return (a << shift).count();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
files();
string s;
cin >> s;
int q;
cin >> q;
for (int i = 0; i < ((int)((s).size())); ++i) {
bits[s[i] - 'a'].set(i);
}
while (q--) {
int type;
cin >> type;
if (type == 1) {
int i;
cin >> i;
i--;
char c;
cin >> c;
bits[s[i] - 'a'].reset(i);
s[i] = c;
bits[s[i] - 'a'].set(i);
} else {
int l, r;
cin >> l >> r;
string sub;
cin >> sub;
if (r - l + 1 < ((int)((sub).size()))) {
cout << 0 << '\n';
continue;
}
bitset<N> ans;
ans.set();
for (int i = 0; i < ((int)((sub).size())); ++i) {
ans &= (bits[sub[i] - 'a'] >> i);
}
int shift = N - r + ((int)((sub).size())) - 1;
int res = (ans << shift).count();
shift = N - l + 1;
res -= (ans << shift).count();
cout << res << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
bitset<100001> bs[26], ba, bm;
char s[100001], t[100001];
int main(void) {
scanf("%s", s);
int n = strlen(s);
for (int i = 0; i != n; ++i) bs[s[i] - 'a'][i] = bm[i] = 1;
int q;
scanf("%d", &q);
while (q--) {
int o;
scanf("%d", &o);
if (o == 1) {
int i;
char b[10];
scanf("%d%s", &i, b);
i--;
bs[s[i] - 'a'][i] = 0;
s[i] = b[0];
bs[s[i] - 'a'][i] = 1;
} else {
int l, r, m;
scanf("%d%d%s", &l, &r, t);
m = strlen(t);
ba.set();
for (int i = 0; i != m; ++i) {
ba &= (bs[t[i] - 'a'] >> i);
}
ba >>= l - 1;
ba <<= (n - (r - l - m + 2));
ba &= bm;
printf("%d\n", ba.count());
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
char s[N], t[N];
bitset<N> bs[26], cur;
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) bs[s[i] - 'a'][i] = 1;
int q;
cin >> q;
while (q--) {
int type;
scanf("%d", &type);
if (type == 1) {
int idx;
scanf("%d", &idx);
scanf("%s", t);
bs[s[idx] - 'a'][idx] = 0;
s[idx] = t[0];
bs[s[idx] - 'a'][idx] = 1;
} else {
int l, r;
scanf("%d %d %s", &l, &r, t + 1);
int m = strlen(t + 1);
if (r - l + 1 < m) {
printf("0\n");
continue;
}
cur.reset();
cur = ~cur;
for (int i = 1; i <= m; i++) {
cur &= (bs[t[i] - 'a'] >> (i - 1));
}
cur >>= l;
int ans = cur.count();
cur >>= (r - l - m + 2);
ans -= cur.count();
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int dr[]{-1, -1, 0, 1, 1, 1, 0, -1};
const int dc[]{0, 1, 1, 1, 0, -1, -1, -1};
void run() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int sqrtQ = 150;
struct suffix_automaton {
struct state {
int len, link = 0, cnt = 0;
bool terminal = false, is_clone = false;
vector<int> nxt;
state(int len = 0) : len(len), nxt(26, -1) {}
bool have_next(char ch) { return nxt[ch - 'a'] != -1; }
void clone(const state &other, int nlen) {
len = nlen;
nxt = other.nxt;
link = other.link;
is_clone = true;
}
};
vector<state> st;
int last = 0;
suffix_automaton() {
st.push_back(state());
st[0].link = -1;
}
suffix_automaton(const string &s) : suffix_automaton() {
for (char ch : s) extend(ch);
calc_number_of_occurrences();
}
void extend(char c) {
int cur = st.size();
st.push_back(state(st[last].len + 1));
st[cur].cnt = 1;
int p = last;
last = cur;
while (p != -1 && !st[p].have_next(c)) {
st[p].nxt[c - 'a'] = cur;
p = st[p].link;
}
if (p == -1) return;
int q = st[p].nxt[c - 'a'];
if (st[p].len + 1 == st[q].len) {
st[cur].link = q;
return;
}
int clone = st.size();
st.push_back(state());
st[clone].clone(st[q], st[p].len + 1);
while (p != -1 && st[p].nxt[c - 'a'] == q) {
st[p].nxt[c - 'a'] = clone;
p = st[p].link;
}
st[q].link = st[cur].link = clone;
}
void calc_number_of_occurrences() {
vector<vector<int>> lvl(st[last].len + 1);
for (int i = 1; i < st.size(); i++) lvl[st[i].len].push_back(i);
for (int i = st[last].len; i >= 0; i--)
for (auto cur : lvl[i]) st[st[cur].link].cnt += st[cur].cnt;
}
int count(const string &y) {
int cur = 0;
for (auto &it : y) {
if (!st[cur].have_next(it)) return 0;
cur = st[cur].nxt[it - 'a'];
}
return st[cur].cnt;
}
} SA[(int)1e4];
string y;
vector<int> longestPrefix;
vector<int> Fail[26];
int fail(int k, char nxt) {
int &rt = Fail[nxt - 'a'][k];
if (~rt) return rt;
while (k > 0 && y[k] != nxt) k = longestPrefix[k - 1];
if (nxt == y[k]) k++;
return rt = k;
}
void failure_function() {
int n = y.size();
longestPrefix = vector<int>(n);
for (int i = 0; i < 26; i++) Fail[i] = vector<int>(n + 1, -1);
for (int i = 1, k = 0; i < n; i++) longestPrefix[i] = k = fail(k, y[i]);
}
int main() {
run();
string s;
int q;
cin >> s >> q;
for (int i = 0; i < (int)(s.size()); i += sqrtQ)
SA[i / sqrtQ] = suffix_automaton(s.substr(i, sqrtQ));
auto solve = [&](int l, int r) {
int match = 0, cnt = 0;
for (int i = l; i <= r; i++) {
match = fail(match, s[i]);
if (match == (int)(y.size())) {
cnt++;
match = longestPrefix[match - 1];
}
}
return cnt;
};
while (q--) {
int t;
cin >> t;
if (t == 1) {
int idx;
char ch;
cin >> idx >> ch;
idx--;
s[idx] = ch;
SA[idx / sqrtQ] = suffix_automaton(s.substr(idx / sqrtQ * sqrtQ, sqrtQ));
} else {
int l, r;
cin >> l >> r >> y;
l--, r--;
failure_function();
if ((int)(y.size()) >= sqrtQ || r - l <= 2 * sqrtQ) {
cout << solve(l, r) << "\n";
continue;
}
int ans = 0, len = (int)(y.size());
int st = l / sqrtQ, ed = r / sqrtQ;
for (int i = st + 1; i <= ed; i++)
ans += solve(max(l, i * sqrtQ - len + 1), min(r, i * sqrtQ + len - 2));
for (int i = st + 1; i < ed; i++) ans += SA[i].count(y);
ans += solve(l, (st + 1) * sqrtQ - 1);
ans += solve(ed * sqrtQ, r);
cout << ans << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
bitset<100005> mask[26];
void test() {
for (int i = 0; i < 26; i++) {
cout << (char)(i + 'a') << " " << mask[i] << endl;
}
}
void computeMask(string &text) {
for (int i = 0; i < (int)text.size(); ++i) {
int c = text[i] - 'a';
mask[c].set(i);
}
}
int StringMatchingInRange(string &pattern, string &text, long long l,
long long r) {
if ((int)pattern.size() > (r - l + 1)) return 0;
bitset<100005> startMask;
startMask.set();
for (int i = 0; i < (int)pattern.size(); ++i) {
int c = pattern[i] - 'a';
startMask &= (mask[c] >> i);
}
return (startMask >> (l)).count() -
(startMask >> (r - (int)pattern.size() + 2)).count();
}
int StringMatching(string &pattern, string &text) {
if ((int)pattern.size() > (int)text.size()) return 0;
bitset<100005> startMask;
startMask.set();
for (int i = 1; i < (int)pattern.size(); ++i) {
int c = pattern[i] - 'a';
startMask &= (mask[c] >> i);
}
return startMask.count();
}
void update(int idx, char ch, string &text) {
char old = text[idx];
mask[old - 'a'][idx] = 0;
text[idx] = ch;
mask[ch - 'a'][idx] = 1;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s, t;
cin >> t;
computeMask(t);
int q, ty, l, r, x;
char ch;
cin >> q;
while (q--) {
cin >> ty;
if (ty == 2) {
cin >> l >> r >> s;
l--, r--;
cout << StringMatchingInRange(s, t, l, r) << endl;
} else {
cin >> x >> ch;
x--;
update(x, ch, t);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dr[]{-1, -1, 0, 1, 1, 1, 0, -1};
const int dc[]{0, 1, 1, 1, 0, -1, -1, -1};
void run() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int sqrtQ = 150;
class suffix_array {
const static int alpha = 128;
int getOrder(int a) const { return (a < (int)order.size() ? order[a] : 0); }
public:
int n;
string s;
vector<int> suf, order, lcp;
suffix_array() {}
suffix_array(const string &s) : n(s.size() + 1), s(s) {
suf = order = lcp = vector<int>(n);
vector<int> bucket_idx(n), newOrder(n), newsuff(n);
{
vector<int> prev(n), head(alpha, -1);
for (int i = 0; i < n; i++) {
prev[i] = head[s[i]];
head[s[i]] = i;
}
int buc = -1, idx = 0;
for (int i = 0; i < alpha; i++) {
if (head[i] == -1) continue;
bucket_idx[++buc] = idx;
for (int j = head[i]; ~j; j = prev[j]) suf[idx++] = j, order[j] = buc;
}
}
int len = 1;
do {
auto cmp = [&](int a, int b) {
if (order[a] != order[b]) return order[a] < order[b];
return getOrder(a + len) < getOrder(b + len);
};
for (int i = 0; i < n; i++) {
int j = suf[i] - len;
if (j < 0) continue;
newsuff[bucket_idx[order[j]]++] = j;
}
for (int i = 1; i < n; i++) {
suf[i] = newsuff[i];
bool cmpres = cmp(suf[i - 1], suf[i]);
newOrder[suf[i]] = newOrder[suf[i - 1]] + cmpres;
if (cmpres) bucket_idx[newOrder[suf[i]]] = i;
}
order = newOrder;
len <<= 1;
} while (order[suf[n - 1]] != n - 1);
}
int count(const string &x) {
int st = 0, ed = n;
for (int i = 0; i < (int)(x.size()) && st < ed; i++) {
auto cmp = [&](int a, int b) {
if (a == -1) return x[i] < s[b + i];
return s[a + i] < x[i];
};
st = lower_bound(suf.begin() + st, suf.begin() + ed, -1, cmp) -
suf.begin();
ed = upper_bound(suf.begin() + st, suf.begin() + ed, -1, cmp) -
suf.begin();
}
return max(0, ed - st);
}
} SA[(int)1e4];
string y;
vector<int> longestPrefix;
vector<int> Fail[26];
int fail(int k, char nxt) {
int &rt = Fail[nxt - 'a'][k];
if (~rt) return rt;
while (k > 0 && y[k] != nxt) k = longestPrefix[k - 1];
if (nxt == y[k]) k++;
return rt = k;
}
void failure_function() {
int n = y.size();
longestPrefix = vector<int>(n);
for (int i = 0; i < 26; i++) Fail[i] = vector<int>(n + 1, -1);
for (int i = 1, k = 0; i < n; i++) longestPrefix[i] = k = fail(k, y[i]);
}
int main() {
run();
string s;
int q;
cin >> s >> q;
for (int i = 0; i < (int)(s.size()); i += sqrtQ)
SA[i / sqrtQ] = suffix_array(s.substr(i, sqrtQ));
auto solve = [&](int l, int r) {
int match = 0, cnt = 0;
for (int i = l; i <= r; i++) {
match = fail(match, s[i]);
if (match == (int)(y.size())) {
cnt++;
match = longestPrefix[match - 1];
}
}
return cnt;
};
while (q--) {
int t;
cin >> t;
if (t == 1) {
int idx;
char ch;
cin >> idx >> ch;
idx--;
s[idx] = ch;
SA[idx / sqrtQ] = suffix_array(s.substr(idx / sqrtQ * sqrtQ, sqrtQ));
} else {
int l, r;
cin >> l >> r >> y;
l--, r--;
failure_function();
if ((int)(y.size()) >= sqrtQ || r - l <= 2 * sqrtQ) {
cout << solve(l, r) << "\n";
continue;
}
int ans = 0, len = (int)(y.size());
int st = l / sqrtQ, ed = r / sqrtQ;
ans += solve(l, (st + 1) * sqrtQ + len - 2);
ans += solve(ed * sqrtQ - len + 1, r);
for (int i = st + 1; i < ed; i++) ans += SA[i].count(y);
for (int i = st + 2; i < ed; i++)
ans += solve(i * sqrtQ - len + 1, i * sqrtQ + len - 2);
cout << ans << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, q;
char s[N], c[N];
bitset<N> a[26], ans;
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; i++) a[s[i] - 'a'][i] = 1;
scanf("%d", &q);
while (q--) {
int op, x, y;
scanf("%d%d", &op, &x);
if (op == 1) {
scanf("%s", c);
a[s[x - 1] - 'a'][x - 1] = 0;
a[(s[x - 1] = c[0]) - 'a'][x - 1] = 1;
} else {
ans.set();
scanf("%d%s", &y, c);
int len = strlen(c);
if (y - x + 1 < len) {
puts("0");
continue;
}
for (int i = 0; i < len; i++) ans &= a[c[i] - 'a'] >> i;
printf("%d\n", (ans >> (x - 1)).count() - (ans >> (y - len + 1)).count());
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, op, x, y, l, i, j, a[100001];
bitset<100001> V[26], I, an;
char s[100001];
int main() {
scanf("%s", s);
n = strlen(s);
for (i = 0; i < n; i++) V[s[i] - 'a'][i] = 1, I[i] = 1;
for (scanf("%d", &m); m--;) {
scanf("%d%d", &op, &x);
if (op == 1)
for (scanf("%s", s), i = 0; i < 26; i++)
V[i][x - 1] = ((s[0] - 'a' == i) ? 1 : 0);
else {
scanf("%d%s", &y, s);
l = strlen(s);
an = (I >> (n - y + x + l - 2)) << (x - 1);
for (i = 0; i < l; an <<= 1, i++) an &= V[s[i] - 'a'];
printf("%d\n", an.count());
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int EXP = 26;
const int DIM = 100005;
char str[DIM], aux[DIM];
bitset<DIM> bts[EXP], sol, one;
int main(void) {
scanf("%s", str + 1);
int n = (int)strlen(str + 1);
for (int i = 1; i <= n; ++i) {
bts[str[i] - 'a'][i] = true;
one[i - 1] = true;
}
int q;
scanf("%d", &q);
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int p;
char ch;
scanf("%d %c", &p, &ch);
bts[str[p] - 'a'][p] = false;
bts[ch - 'a'][p] = true;
str[p] = ch;
} else {
int l, r;
scanf("%d %d %s", &l, &r, aux + 1);
int m = (int)strlen(aux + 1);
if (m > r - l + 1)
printf("%d\n", 0);
else {
sol = one;
for (int i = 1; i <= m; ++i) sol &= (bts[aux[i] - 'a'] >> i);
printf("%d\n", (int)(sol >> (l - 1)).count() -
(int)(sol >> (r - m + 1)).count());
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int M = 405, C = N / M + 5;
char s[N];
int n, q, op, x, y;
char t[N];
int len;
struct sam {
int son[M * 2][26], fa[M * 2], dep[M * 2], ed[M * 2], tot, la;
void build() {
for (int i = 1, _b = tot; i <= _b; i++) {
memset(son[i], 0, sizeof son[i]);
dep[i] = fa[i] = ed[i] = 0;
}
tot = la = 1;
}
void push(int v) { dep[++tot] = v; }
void add(int c) {
int p = la;
push(dep[p] + 1);
int np = tot;
for (; p && !son[p][c]; p = fa[p]) son[p][c] = np;
if (!p)
fa[np] = 1;
else {
int q = son[p][c];
if (dep[p] + 1 < dep[q]) {
push(dep[p] + 1);
int nq = tot;
memcpy(son[nq], son[q], sizeof son[q]);
fa[nq] = fa[q];
fa[q] = fa[np] = nq;
for (; son[p][c] == q; p = fa[p]) son[p][c] = nq;
} else
fa[np] = q;
}
la = np;
ed[la] = 1;
}
int d[M * 2], d0, r[M * 2], f[M * 2];
void dg(int x) {
if (x == 1) d0 = 0;
for (int i = 1, _b = d0; i <= _b; i++) putchar(d[i] + 'a');
printf("\n");
for (int j = 0, _b = 25; j <= _b; j++)
if (son[x][j]) {
d[++d0] = j;
dg(son[x][j]);
d0--;
}
}
void work() {
for (int i = 1, _b = tot; i <= _b; i++) r[i] = f[i] = 0;
for (int i = 2, _b = tot; i <= _b; i++) r[fa[i]]++;
d0 = 0;
for (int i = 1, _b = tot; i <= _b; i++)
if (!r[i]) d[++d0] = i;
for (int i = 1; i <= tot - 1; i++) {
int x = d[i];
if (!(--r[fa[x]])) d[++d0] = fa[x];
f[x] += ed[x], f[fa[x]] += f[x];
}
}
int qry() {
int p = 1;
for (int i = 1, _b = len; i <= _b; i++) p = son[p][t[i] - 'a'];
return f[p];
}
} a[C];
int id[N], id0, il[C], ir[C];
void build(int i) {
a[i].build();
for (int j = il[i], _b = ir[i]; j <= _b; j++) a[i].add(s[j] - 'a');
a[i].work();
}
int nt[N];
void get_nt() {
int x = 0;
for (int i = 2, _b = len; i <= _b; i++) {
while (x && t[x + 1] != t[i]) x = nt[x];
x += (t[x + 1] == t[i]);
nt[i] = x;
}
}
int qry(int l, int r, int z) {
if (z != -1) {
r = min(r, z + len - 2);
l = max(l, z - len);
}
int ans = 0;
int x = 0;
for (int i = l, _b = r; i <= _b; i++) {
while (x && t[x + 1] != s[i]) x = nt[x];
x += (t[x + 1] == s[i]);
if (x == len) {
if (z == -1)
ans++;
else {
if (i >= z && i - len + 1 < z) ans++;
}
}
}
return ans;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = 1, _b = n; i <= _b; i++) {
if (i % M == 1) il[++id0] = i;
id[i] = id0;
ir[id0] = i;
}
for (int i = 1, _b = id0; i <= _b; i++) {
build(i);
}
scanf("%d", &q);
for (int ii = 1, _b = q; ii <= _b; ii++) {
scanf("%d", &op);
if (op == 1) {
scanf("%d", &x);
scanf("%s", t + 1);
len = strlen(t + 1);
s[x] = t[1];
build(id[x]);
} else {
scanf("%d %d", &x, &y);
scanf("%s", t + 1);
len = strlen(t + 1);
int ans = 0;
if (len > M) {
get_nt();
ans = qry(x, y, -1);
} else {
int l = id[x], r = id[y];
for (int i = l + 1, _b = r - 1; i <= _b; i++) ans += a[i].qry();
get_nt();
if (id[x] != id[y]) {
ans += qry(x, ir[id[x]], -1);
ans += qry(il[id[y]], y, -1);
for (int i = l + 1, _b = r; i <= _b; i++)
ans += qry((i - 1) == l ? x : il[i - 1], i == r ? y : ir[i], il[i]);
} else {
ans += qry(x, y, -1);
}
}
printf("%d\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100005], t[100005];
bitset<100005> p[27], ini, ans;
inline int read() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x;
}
int main() {
int n, q, i, j, opt, l, r, len;
scanf("%s", s + 1);
n = strlen(s + 1);
for (i = 1; i <= n; i++) {
p[s[i] - 'a'][i] = 1;
ini[i] = 1;
}
q = read();
while (q--) {
opt = read();
if (opt == 1) {
l = read();
scanf("%s", t + 1);
p[s[l] - 'a'][l] = 0;
s[l] = t[1];
p[s[l] - 'a'][l] = 1;
continue;
}
l = read();
r = read();
scanf("%s", t + 1);
len = strlen(t + 1);
if (r - l + 1 < len) {
puts("0");
continue;
}
ans = ini;
int res = 0;
for (i = 1; i <= len; i++) {
ans &= (p[t[i] - 'a'] >> (i - 1));
}
r -= (len - 1);
if (r - l + 1 <= 66) {
for (j = l; j <= r; j++) res += ans[j];
printf("%d\n", res);
continue;
}
int *o = (int *)&ans;
while (l & 31) res += ans[l++];
while (r & 31) res += ans[r--];
res += ans[r];
l >>= 5;
r >>= 5;
for (j = l; j < r; j++) {
res += __builtin_popcount(o[j]);
}
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
bitset<N> b[26], all, ans, bas;
char s[N], t[N];
int n, Q;
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = (int)(1); i <= (int)(n); i++) b[s[i] - 'a'][i] = 1;
for (int i = (int)(1); i <= (int)(n); i++) all[i] = 1;
scanf("%d", &Q);
while (Q--) {
int tp;
scanf("%d", &tp);
if (tp == 1) {
int x;
scanf("%d%s", &x, t + 1);
b[s[x] - 'a'][x] = 0;
b[(s[x] = t[1]) - 'a'][x] = 1;
} else {
int l, r;
scanf("%d%d%s", &l, &r, t + 1);
ans = bas = (all << (l - 1)) & (all >> (n - r));
int len = strlen(t + 1);
for (int i = (int)(1); i <= (int)(len); i++)
ans &= (b[t[i] - 'a'] & bas) >> (i - 1);
printf("%d\n", ans.count());
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
bitset<100010> a[26], ans;
int cnt;
vector<int> ori;
void cg() {
int pos;
char targ;
scanf("%d %c", &pos, &targ);
a[ori[pos - 1]][pos] = 0;
ori[pos - 1] = targ - 'a';
a[ori[pos - 1]][pos] = 1;
}
char ta[100010];
void qr() {
int l, r;
scanf("%d%d%s", &l, &r, ta);
int m = strlen(ta);
if (r - l + 1 < m) {
printf("0\n");
return;
}
ans.set();
for (int i = 0; i < m; i++) {
ans &= (a[ta[i] - 'a'] >> i);
}
int res = (ans >> (l)).count() - (ans >> (r - m + 2)).count();
printf("%d\n", res);
}
int main() {
int q;
char tmp;
while ((tmp = getchar()) != '\n') {
int ch = tmp - 'a';
ori.push_back(ch);
cnt++;
a[ch][cnt] = 1;
}
scanf("%d", &q);
while (q--) {
int kind;
scanf("%d", &kind);
if (kind == 1)
cg();
else
qr();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 5;
char s[N];
int q;
char y[N], c[3];
bitset<N> state[26], ans;
int main() {
scanf("%s%d", (s + 1), &q);
int n = strlen(s + 1);
for (register int i = 1; i <= n; i++) state[s[i] - 'a'].set(i);
while (q-- > 0) {
int op, l, r;
scanf("%d%d", &op, &l);
if (op == 1) {
scanf("%s", c);
char rw = c[0];
int x = s[l] - 'a', y = rw - 'a';
state[x].reset(l);
state[y].set(l);
s[l] = rw;
} else if (op == 2) {
scanf("%d%s", &r, y);
ans.set();
int v = strlen(y);
r = r - v + 1;
for (int i = 0; i < v; i++) ans &= (state[y[i] - 'a'] >> i);
ans <<= (N - r - 1);
ans >>= (N - r - 1);
ans >>= l;
printf("%d\n", ans.count());
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, B = 233;
char s[N], str[N];
bitset<N> ch[26];
int main() {
scanf("%s", str);
int n = (int)strlen(str);
for (int i = 0; i < n; ++i) ch[str[i] - 'a'].set(i);
int q;
scanf("%d", &q);
while (q--) {
int type;
scanf("%d", &type);
if (type == 2) {
int l, r;
scanf("%d%d%s", &l, &r, s);
--l, --r;
int m = (int)strlen(s);
if (r - l + 1 < m) {
puts("0");
continue;
}
bitset<N> pos = ch[s[0] - 'a'];
for (int i = 1; i < m; ++i) pos &= ch[s[i] - 'a'] >> i;
printf("%d\n", (int)(pos >> l << (N - (r - l + 1 - m + 1))).count());
} else {
int x;
scanf("%d%s", &x, s);
--x;
ch[str[x] - 'a'].reset(x);
str[x] = s[0];
ch[str[x] - 'a'].set(x);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename... As>
struct tpl : public std::tuple<As...> {
using std::tuple<As...>::tuple;
tpl() {}
tpl(std::tuple<As...> const& b) { std::tuple<As...>::operator=(b); }
template <typename T = tuple<As...> >
typename tuple_element<0, T>::type const& x() const {
return get<0>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<0, T>::type& x() {
return get<0>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<1, T>::type const& y() const {
return get<1>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<1, T>::type& y() {
return get<1>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<2, T>::type const& z() const {
return get<2>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<2, T>::type& z() {
return get<2>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<3, T>::type const& w() const {
return get<3>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<3, T>::type& w() {
return get<3>(*this);
}
};
using lli = int;
using llu = long long unsigned;
using pii = tpl<lli, lli>;
using piii = tpl<lli, lli, lli>;
using piiii = tpl<lli, lli, lli, lli>;
using vi = vector<lli>;
using vii = vector<pii>;
using viii = vector<piii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
using vviii = vector<viii>;
template <class T>
using min_queue = priority_queue<T, vector<T>, greater<T> >;
template <class T>
using max_queue = priority_queue<T>;
template <size_t... I>
struct my_index_sequence {
using type = my_index_sequence;
static constexpr array<size_t, sizeof...(I)> value = {{I...}};
};
namespace my_index_sequence_detail {
template <typename I, typename J>
struct concat;
template <size_t... I, size_t... J>
struct concat<my_index_sequence<I...>, my_index_sequence<J...> >
: my_index_sequence<I..., (sizeof...(I) + J)...> {};
template <size_t N>
struct make_index_sequence
: concat<typename make_index_sequence<N / 2>::type,
typename make_index_sequence<N - N / 2>::type>::type {};
template <>
struct make_index_sequence<0> : my_index_sequence<> {};
template <>
struct make_index_sequence<1> : my_index_sequence<0> {};
} // namespace my_index_sequence_detail
template <class... A>
using my_index_sequence_for =
typename my_index_sequence_detail::make_index_sequence<sizeof...(A)>::type;
template <class T, size_t... I>
void print_tuple(ostream& s, T const& a, my_index_sequence<I...>) {
using swallow = int[];
(void)swallow{0, (void(s << (I == 0 ? "" : ", ") << get<I>(a)), 0)...};
}
template <class T>
ostream& print_collection(ostream& s, T const& a);
template <class... A>
ostream& operator<<(ostream& s, tpl<A...> const& a);
template <class... A>
ostream& operator<<(ostream& s, tuple<A...> const& a);
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a);
template <class T, size_t I>
ostream& operator<<(ostream& s, array<T, I> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, vector<T> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, multimap<T, U> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, multiset<T> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, map<T, U> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, set<T> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& print_collection(ostream& s, T const& a) {
s << '[';
for (auto it = begin(a); it != end(a); ++it) {
s << *it;
if (it != prev(end(a))) s << " ";
}
return s << ']';
}
template <class... A>
ostream& operator<<(ostream& s, tpl<A...> const& a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class... A>
ostream& operator<<(ostream& s, tuple<A...> const& a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a) {
return s << "(" << get<0>(a) << ", " << get<1>(a) << ")";
}
const int BSIZE = 300;
struct SuffixAutomaton {
int edges[26][1 + BSIZE * 2], link[1 + BSIZE * 2], length[1 + BSIZE * 2],
isTerminal[1 + BSIZE * 2], dp1[1 + BSIZE * 2], last;
int sz;
SuffixAutomaton() {
last = 0;
sz = 0;
}
void set(int k) {
for (int i = 0; i < 26; ++i) edges[i][k] = -1;
}
void build(char* s, int size) {
link[0] = -1;
length[0] = 0;
last = 0;
sz = 1;
set(0);
for (int i = 0; i < size; i++) {
set(sz);
length[sz] = i + 1;
link[sz] = 0;
int r = sz;
++sz;
int p = last;
while (p >= 0 && edges[s[i] - 'a'][p] == -1) {
edges[s[i] - 'a'][p] = r;
p = link[p];
}
if (p != -1) {
int q = edges[s[i] - 'a'][p];
if (length[p] + 1 == length[q]) {
link[r] = q;
} else {
for (int i = 0; i < 26; ++i) {
edges[i][sz] = edges[i][q];
}
length[sz] = length[p] + 1;
link[sz] = link[q];
int qq = sz;
++sz;
link[q] = qq;
link[r] = qq;
while (p >= 0 && edges[s[i] - 'a'][p] == q) {
edges[s[i] - 'a'][p] = qq;
p = link[p];
}
}
}
last = r;
}
for (int i = 0; i < sz; ++i) isTerminal[i] = 0, dp1[i] = -1;
int p = last;
while (p > 0) {
isTerminal[p] = 1;
p = link[p];
}
}
int solve(int pos) {
if (dp1[pos] != -1) return dp1[pos];
dp1[pos] = isTerminal[pos];
for (int i = 0; i < 26; ++i) {
if (edges[i][pos] != -1) dp1[pos] += solve(edges[i][pos]);
}
return dp1[pos];
}
int run(char const* sq) {
int cur = 0;
for (int i = 0; sq[i] != '\0'; ++i) {
auto it = edges[sq[i] - 'a'][cur];
if (it == -1)
return 0;
else
cur = it;
}
return solve(cur);
}
};
vi kmp_build(string const& s) {
int n = s.size();
vi T(n + 1);
T[0] = -1;
for (lli i = 0; i < (lli)(n); ++i) {
int b = T[i];
while (b != -1 && s[i] != s[b]) b = T[b];
T[i + 1] = b + 1;
}
return T;
}
int kmp_next(string const& s, vi const& T, int i, int x) {
while (i != -1 && x != s[i]) i = T[i];
return i + 1;
}
SuffixAutomaton B[100000 / BSIZE + 10];
int clean[100000 / BSIZE + 10];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = s.size();
int nblock = (n + BSIZE - 1) / BSIZE;
int q;
cin >> q;
for (lli q_ = 0; q_ < (lli)(q); ++q_) {
int ty;
cin >> ty;
if (ty == 1) {
int i;
char c;
cin >> i >> c;
--i;
if (s[i] == c) continue;
s[i] = c;
clean[i / BSIZE] = 0;
} else {
lli l, r;
string y;
cin >> l >> r >> y;
--l;
--r;
lli ans = 0;
if (y.size() > 150) {
auto T = kmp_build(y);
lli S = 0;
for (lli i = (l); i <= (lli)(r); ++i) {
S = kmp_next(y, T, S, s[i]);
if (S == (int)y.size()) ans += 1;
}
} else {
lli bl = l / BSIZE;
lli br = r / BSIZE;
auto T = kmp_build(y);
{
lli S = 0;
for (lli i = (l); i <= (lli)(min(r, (bl + 1) * BSIZE - 1)); ++i) {
S = kmp_next(y, T, S, s[i]);
if (S == (int)y.size()) ans += 1;
}
}
if (bl != br) {
lli S = 0;
for (lli i = (br * BSIZE); i <= (lli)(r); ++i) {
S = kmp_next(y, T, S, s[i]);
if (S == (int)y.size()) ans += 1;
}
}
for (lli b = (bl + 1); b <= (lli)(br - 1); ++b) {
if (!clean[b]) {
clean[b] = 1;
B[b].build(&s[b * BSIZE], min<int>(BSIZE, s.size() - b * BSIZE));
}
ans += B[b].run(y.c_str());
}
for (lli b = (bl); b <= (lli)(br - 1); ++b) {
int S = 0;
int from = max<int>(l, (b + 1) * BSIZE - y.size() + 1);
int to = min<int>(r, (b + 1) * BSIZE + y.size() - 2);
for (lli i = (from); i <= (lli)(to); ++i) {
S = kmp_next(y, T, S, s[i]);
if (S == (int)y.size()) ans += 1;
}
}
}
cout << ans << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dr[]{-1, -1, 0, 1, 1, 1, 0, -1};
const int dc[]{0, 1, 1, 1, 0, -1, -1, -1};
void run() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int sqrtQ = 350;
class suffix_array {
const static int alpha = 128;
int getOrder(int a) const { return (a < (int)order.size() ? order[a] : 0); }
public:
int n;
string s;
vector<int> suf, order, lcp;
suffix_array() {}
suffix_array(const string &s) : n(s.size() + 1), s(s) {
suf = order = lcp = vector<int>(n);
vector<int> bucket_idx(n), newOrder(n), newsuff(n);
{
vector<int> prev(n), head(alpha, -1);
for (int i = 0; i < n; i++) {
prev[i] = head[s[i]];
head[s[i]] = i;
}
int buc = -1, idx = 0;
for (int i = 0; i < alpha; i++) {
if (head[i] == -1) continue;
bucket_idx[++buc] = idx;
for (int j = head[i]; ~j; j = prev[j]) suf[idx++] = j, order[j] = buc;
}
}
int len = 1;
do {
auto cmp = [&](int a, int b) {
if (order[a] != order[b]) return order[a] < order[b];
return getOrder(a + len) < getOrder(b + len);
};
for (int i = 0; i < n; i++) {
int j = suf[i] - len;
if (j < 0) continue;
newsuff[bucket_idx[order[j]]++] = j;
}
for (int i = 1; i < n; i++) {
suf[i] = newsuff[i];
bool cmpres = cmp(suf[i - 1], suf[i]);
newOrder[suf[i]] = newOrder[suf[i - 1]] + cmpres;
if (cmpres) bucket_idx[newOrder[suf[i]]] = i;
}
order = newOrder;
len <<= 1;
} while (order[suf[n - 1]] != n - 1);
}
int count(const string &x) {
int st = 0, ed = n;
for (int i = 0; i < (int)(x.size()) && st < ed; i++) {
auto cmp = [&](int a, int b) {
if (a == -1) return x[i] < s[b + i];
return s[a + i] < x[i];
};
st = lower_bound(suf.begin() + st, suf.begin() + ed, -1, cmp) -
suf.begin();
ed = upper_bound(suf.begin() + st, suf.begin() + ed, -1, cmp) -
suf.begin();
}
return max(0, ed - st);
}
} SA[(int)1e4];
string y;
vector<int> longestPrefix;
vector<int> Fail[26];
int fail(int k, char nxt) {
int &rt = Fail[nxt - 'a'][k];
if (~rt) return rt;
while (k > 0 && y[k] != nxt) k = longestPrefix[k - 1];
if (nxt == y[k]) k++;
return rt = k;
}
void failure_function() {
int n = y.size();
longestPrefix = vector<int>(n);
for (int i = 0; i < 26; i++) Fail[i] = vector<int>(n + 1, -1);
for (int i = 1, k = 0; i < n; i++) longestPrefix[i] = k = fail(k, y[i]);
}
int main() {
run();
string s;
int q;
cin >> s >> q;
for (int i = 0; i < (int)(s.size()); i += sqrtQ)
SA[i / sqrtQ] = suffix_array(s.substr(i, sqrtQ));
auto solve = [&](int l, int r) {
int match = 0, cnt = 0;
for (int i = l; i <= r; i++) {
match = fail(match, s[i]);
if (match == (int)(y.size())) {
cnt++;
match = longestPrefix[match - 1];
}
}
return cnt;
};
while (q--) {
int t;
cin >> t;
if (t == 1) {
int idx;
char ch;
cin >> idx >> ch;
idx--;
s[idx] = ch;
SA[idx / sqrtQ] = suffix_array(s.substr(idx / sqrtQ * sqrtQ, sqrtQ));
} else {
int l, r;
cin >> l >> r >> y;
l--, r--;
failure_function();
if ((int)(y.size()) >= sqrtQ || r - l <= 2 * sqrtQ) {
cout << solve(l, r) << "\n";
continue;
}
int ans = 0, len = (int)(y.size());
int st = l / sqrtQ, ed = r / sqrtQ;
ans += solve(l, (st + 1) * sqrtQ + len - 2);
ans += solve(ed * sqrtQ - len + 1, r);
for (int i = st + 1; i < ed; i++) ans += SA[i].count(y);
for (int i = st + 2; i < ed; i++)
ans += solve(i * sqrtQ - len + 1, i * sqrtQ + len - 2);
cout << ans << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Imx = 2147483647;
const long long Lbig = 2e18;
const int mod = 1e9 + 7;
struct fastio {
char s[100000];
int it, len;
fastio() { it = len = 0; }
inline char get() {
if (it < len) return s[it++];
it = 0;
len = fread(s, 1, 100000, stdin);
if (len == 0)
return EOF;
else
return s[it++];
}
bool notend() {
char c = get();
while (c == ' ' || c == '\n') c = get();
if (it > 0) it--;
return c != EOF;
}
} _buff;
inline long long getnum() {
long long r = 0;
bool ng = 0;
char c;
c = _buff.get();
while (c != '-' && (c < '0' || c > '9')) c = _buff.get();
if (c == '-') ng = 1, c = _buff.get();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = _buff.get();
return ng ? -r : r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline char getreal() {
char c = _buff.get();
while (c <= 32) c = _buff.get();
return c;
}
long long qpow(long long x, long long k) {
return k == 0 ? 1
: 1ll * qpow(1ll * x * x % mod, k >> 1) * (k & 1 ? x : 1) % mod;
}
char s[100111];
bitset<100005> ch[26], A, all;
char t[100111];
int main() {
scanf("%s", s);
int n = strlen(s);
for (int i = 0; i < n; i++) ch[s[i] - 'a'][i] = 1, all[i] = 1;
int q;
scanf("%d", &q);
while (q--) {
int op, x;
scanf("%d%d", &op, &x);
x--;
if (op == 1) {
char c = getchar();
while (c < 'a' || c > 'z') c = getchar();
ch[s[x] - 'a'][x] = 0;
s[x] = c;
ch[s[x] - 'a'][x] = 1;
} else {
int y;
scanf("%d", &y);
y--;
scanf("%s", t);
int l = strlen(t);
A = (all >> (n - (y - x + 1) + l - 1)) << x;
for (int i = 0; i < l; i++) A = (A & ch[t[i] - 'a']) << 1;
printf("%d\n", A.count());
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
bitset<N> bt[26], ans;
int n, x, y, opt;
char s[N], c[N];
int main() {
scanf("%s", s + 1);
for (int i = 1; s[i]; ++i) bt[s[i] - 'a'][i] = 1;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &opt);
if (opt == 1) {
scanf("%d%s", &x, c);
bt[s[x] - 'a'][x] = 0;
s[x] = c[0];
bt[s[x] - 'a'][x] = 1;
} else {
scanf("%d%d%s", &x, &y, c);
y = y - strlen(c) + 2;
if (x >= y) {
puts("0");
continue;
}
ans = bt[c[0] - 'a'];
for (int i = 1; c[i]; ++i) ans &= bt[c[i] - 'a'] >> i;
printf("%d\n", (ans >> x).count() - (ans >> y).count());
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dr[]{-1, -1, 0, 1, 1, 1, 0, -1};
const int dc[]{0, 1, 1, 1, 0, -1, -1, -1};
void run() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int sqrtQ = 100;
struct suffix_automaton {
struct state {
int len, link = 0, cnt = 0;
bool terminal = false, is_clone = false;
vector<int> nxt;
state(int len = 0) : len(len), nxt(26, -1) {}
bool have_next(char ch) { return nxt[ch - 'a'] != -1; }
void clone(const state &other, int nlen) {
len = nlen;
nxt = other.nxt;
link = other.link;
is_clone = true;
}
};
vector<state> st;
int last = 0;
suffix_automaton() {
st.push_back(state());
st[0].link = -1;
}
suffix_automaton(const string &s) : suffix_automaton() {
for (char ch : s) extend(ch);
calc_number_of_occurrences();
}
void extend(char c) {
int cur = st.size();
st.push_back(state(st[last].len + 1));
st[cur].cnt = 1;
int p = last;
last = cur;
while (p != -1 && !st[p].have_next(c)) {
st[p].nxt[c - 'a'] = cur;
p = st[p].link;
}
if (p == -1) return;
int q = st[p].nxt[c - 'a'];
if (st[p].len + 1 == st[q].len) {
st[cur].link = q;
return;
}
int clone = st.size();
st.push_back(state());
st[clone].clone(st[q], st[p].len + 1);
while (p != -1 && st[p].nxt[c - 'a'] == q) {
st[p].nxt[c - 'a'] = clone;
p = st[p].link;
}
st[q].link = st[cur].link = clone;
}
void calc_number_of_occurrences() {
vector<vector<int>> lvl(st[last].len + 1);
for (int i = 1; i < st.size(); i++) lvl[st[i].len].push_back(i);
for (int i = st[last].len; i >= 0; i--)
for (auto cur : lvl[i]) st[st[cur].link].cnt += st[cur].cnt;
}
int count(const string &y) {
int cur = 0;
for (auto &it : y) {
if (!st[cur].have_next(it)) return 0;
cur = st[cur].nxt[it - 'a'];
}
return st[cur].cnt;
}
} SA[(int)1e4];
string y;
vector<int> longestPrefix;
int fail(int k, char nxt) {
while (k > 0 && y[k] != nxt) k = longestPrefix[k - 1];
if (nxt == y[k]) k++;
return k;
}
void failure_function() {
int n = y.size();
longestPrefix = vector<int>(n);
for (int i = 1, k = 0; i < n; i++) longestPrefix[i] = k = fail(k, y[i]);
}
int main() {
run();
string s;
int q;
cin >> s >> q;
for (int i = 0; i < (int)(s.size()); i += sqrtQ)
SA[i / sqrtQ] = suffix_automaton(s.substr(i, sqrtQ));
auto solve = [&](int l, int r) {
int match = 0, cnt = 0;
for (int i = l; i <= r; i++) {
match = fail(match, s[i]);
if (match == (int)(y.size())) {
cnt++;
match = longestPrefix[match - 1];
}
}
return cnt;
};
while (q--) {
int t;
cin >> t;
if (t == 1) {
int idx;
char ch;
cin >> idx >> ch;
idx--;
s[idx] = ch;
SA[idx / sqrtQ] = suffix_automaton(s.substr(idx / sqrtQ * sqrtQ, sqrtQ));
} else {
int l, r;
cin >> l >> r >> y;
l--, r--;
failure_function();
if ((int)(y.size()) >= sqrtQ || r - l <= 3 * sqrtQ) {
cout << solve(l, r) << "\n";
continue;
}
int ans = 0, len = (int)(y.size());
int st = l / sqrtQ, ed = r / sqrtQ;
ans += solve(l, (st + 1) * sqrtQ + len - 2);
ans += solve(ed * sqrtQ - len + 1, r);
for (int i = st + 1; i < ed; i++) ans += SA[i].count(y);
for (int i = st + 2; i < ed; i++)
ans += solve(i * sqrtQ - len + 1, i * sqrtQ + len - 2);
cout << ans << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cerr << '\n';
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
void run() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
}
const int N = 1e5 + 5, mod = 1e9 + 7, mod2 = 998244353, MAXN = 100000 + 29;
void files() {}
bitset<N> bits[26];
int countt(bitset<N> &a, int l) {
int shift = N - l;
return (a << shift).count();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
files();
string s;
cin >> s;
int q;
cin >> q;
for (int i = 0; i < ((int)((s).size())); ++i) {
bits[s[i] - 'a'].set(i);
}
while (q--) {
int type;
cin >> type;
if (type == 1) {
int i;
cin >> i;
i--;
char c;
cin >> c;
bits[s[i] - 'a'].reset(i);
s[i] = c;
bits[s[i] - 'a'].set(i);
} else {
int l, r;
cin >> l >> r;
string sub;
cin >> sub;
bitset<N> ans;
ans.set();
for (int i = 0; i < ((int)((sub).size())); ++i) {
ans &= (bits[sub[i] - 'a'] >> i);
}
int shift = N - r + ((int)((sub).size())) - 1;
int res = (ans << shift).count();
shift = N - l + 1;
res -= (ans << shift).count();
cout << max(0, res) << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int m, o, l, r;
char s[N], t[N];
bitset<N> x[30], ans, one;
int main() {
scanf("%s", s);
int n = strlen(s);
for (int i = 0; i < n; i++) {
int ch = s[i] - 'a';
x[ch][i + 1] = 1;
}
scanf("%d", &m);
for (int i = 0; i < n; i++) {
one[i] = 1;
}
for (int i = 0; i < m; i++) {
scanf("%d", &o);
if (o == 1) {
scanf("%d %s", &l, t);
l--;
x[s[l] - 'a'][l + 1] = 0;
s[l] = t[0];
x[s[l] - 'a'][l + 1] = 1;
} else if (o == 2) {
scanf("%d %d %s", &l, &r, t);
int len = strlen(t);
if (r - l + 1 < len) {
puts("0");
continue;
}
ans = one;
for (int j = 0; j < len; j++) {
int ch = t[j] - 'a';
ans &= (x[ch] >> (j + 1));
}
int w = (ans >> (l - 1)).count() - (ans >> (r - len + 1)).count();
printf("%d\n", w);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)(1e5) + 5;
char s[maxn], t[maxn];
bitset<maxn> c[26];
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1), q;
for (int i = 1; i <= n; ++i) c[s[i] - 'a'].set(i);
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
int opt;
scanf("%d", &opt);
if (opt == 1) {
int x;
scanf("%d%s", &x, t);
c[s[x] - 'a'].reset(x);
c[(s[x] = t[0]) - 'a'].set(x);
} else {
int l, r;
scanf("%d%d%s", &l, &r, t);
int m = strlen(t);
bitset<maxn> ret;
ret.set();
for (int j = 0; j < m; ++j) ret &= (c[t[j] - 'a'] >> j);
ret = (ret >> l) << l;
ret = (ret << (maxn - r + m - 2)) >> (maxn - r + m - 2);
printf("%u\n", ret.count());
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int getint() {
char c = getchar();
int res = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
res = res * 10 + c - '0';
c = getchar();
}
return res * f;
}
const int maxn = 3e5 + 10;
char s[maxn], t[maxn];
int n, m, T, tlen, nod[maxn];
int vis[maxn], tmp[maxn], c[maxn], p[maxn], top;
int fa[maxn], Max[maxn], cnt[maxn], tot, last;
int ch[maxn][30];
vector<int> E[maxn];
queue<int> Q;
int f[maxn];
long long ans;
inline int newnode() {
int o;
if (Q.empty())
o = ++tot;
else {
o = Q.front();
Q.pop();
Max[o] = vis[o] = cnt[o] = fa[o] = 0;
memset(ch[o], 0, sizeof(ch[o]));
}
return p[++top] = o;
}
inline void insert(int c, int rt) {
int v = last;
Max[last = newnode()] = Max[v] + 1;
fa[last] = rt;
while (v && !ch[v][c]) ch[v][c] = last, v = fa[v];
if (!v) return;
int p = ch[v][c];
if (Max[p] != Max[v] + 1) {
int np = newnode();
Max[np] = Max[v] + 1;
fa[np] = fa[p];
fa[p] = fa[last] = np;
while (v && ch[v][c] == p) ch[v][c] = np, v = fa[v];
for (int i = (1); i <= (26); i++) ch[np][i] = ch[p][i];
} else
fa[last] = p;
}
inline void dfs(int u) {
if (vis[u]) return;
vis[u] = 1;
Q.push(u);
for (int i = (1); i <= (26); i++)
if (ch[u][i]) dfs(ch[u][i]);
}
inline void build(int id) {
if (nod[id]) dfs(nod[id]);
nod[id] = last = newnode();
int l = (id - 1) * T + 1, r = min(id * T, n);
for (int i = (l); i <= (r); i++)
insert(s[i] - 'a' + 1, nod[id]), cnt[last] = 1;
int see = 0;
for (int i = (1); i <= (top); i++) see = max(see, Max[p[i]]);
for (int i = (0); i <= (top); i++) c[i] = 0;
for (int i = (1); i <= (top); i++) c[Max[p[i]]]++;
for (int i = (1); i <= (top); i++) c[i] += c[i - 1];
for (int i = (top); i >= (1); i--) tmp[c[Max[p[i]]]--] = p[i];
for (int i = (top); i >= (1); i--) cnt[fa[tmp[i]]] += cnt[tmp[i]];
top = 0;
}
inline void init() {
f[1] = f[0] = 0;
for (int i = (2); i <= (tlen); i++) {
f[i] = f[i - 1];
while (f[i] && t[f[i] + 1] != t[i]) f[i] = f[f[i]];
f[i] = t[f[i] + 1] == t[i] ? f[i] + 1 : 0;
}
}
inline void kmp(int l, int r) {
if (r - l + 1 < tlen) return;
int now = 0;
for (int i = (l); i <= (r); i++) {
while (now && t[now + 1] != s[i]) now = f[now];
now = t[now + 1] == s[i] ? now + 1 : 0;
if (now == tlen) ans++;
}
}
inline void calc(int id) {
int o = nod[id];
for (int i = (1); i <= (tlen); i++) {
o = ch[o][t[i] - 'a' + 1];
if (!o) return;
}
ans += cnt[o];
}
inline void getans(int l, int r) {
ans = 0;
init();
if (tlen <= T) {
int lid = (l + T - 1) / T, rid = (r + T - 1) / T;
if (lid == rid)
kmp(l, r);
else {
for (int j = (lid + 1); j <= (rid - 1); j++) calc(j);
for (int j = (lid); j <= (rid - 1); j++)
kmp(max(j * T - tlen + 2, l), min(j * T + tlen - 1, r));
kmp(l, lid * T);
kmp((rid - 1) * T + 1, r);
}
} else
kmp(l, r);
}
int main() {
T = 150;
scanf("%s", s + 1);
n = strlen(s + 1);
for (int i = (1); i <= ((n + T - 1) / T); i++) build(i);
m = getint();
while (m--) {
int typ = getint();
if (typ == 1) {
int pos = getint();
s[pos] = getchar();
build((pos + T - 1) / T);
} else {
int l = getint(), r = getint();
scanf("%s", t + 1);
tlen = strlen(t + 1);
getans(l, r);
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace {
const long long MAX = 100002;
bitset<MAX> was[26];
void Solve(long long test) {
(void)test;
string str;
cin >> str;
for (long long i = (long long)(0); i < (long long)(((long long)(str.size())));
++i) {
was[str[i] - 'a'].set(i);
}
long long q;
cin >> q;
for (long long _ = (long long)(0); _ < (long long)(q); ++_) {
long long ty;
cin >> ty;
if (ty == 1) {
long long i;
char c;
cin >> i >> c;
--i;
was[str[i] - 'a'].flip(i);
str[i] = c;
was[str[i] - 'a'].flip(i);
} else {
long long l, r;
string y;
cin >> l >> r >> y;
--l, --r;
if (((long long)(y.size())) > r - l + 1) {
cout << 0 << '\n';
continue;
}
bitset<MAX> mask, ones;
mask.flip();
ones.flip();
ones <<= (r - l - ((long long)(y.size())) + 2);
ones.flip();
for (long long i = (long long)(0);
i < (long long)(((long long)(y.size()))); ++i) {
mask &= (was[y[i] - 'a'] >> i);
}
mask >>= l;
mask &= ones;
const long long res = mask.count();
cout << res << '\n';
}
}
}
void Init() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
}
} // namespace
int main() {
Init();
long long tests = 1;
for (long long test = (long long)(1); test < (long long)(tests + 1); ++test)
Solve(test);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dr[]{-1, -1, 0, 1, 1, 1, 0, -1};
const int dc[]{0, 1, 1, 1, 0, -1, -1, -1};
void run() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int sqrtQ = 200;
class suffix_array {
const static int alpha = 128;
int getOrder(int a) const { return (a < (int)order.size() ? order[a] : 0); }
public:
int n;
string s;
vector<int> suf, order, lcp;
suffix_array() {}
suffix_array(const string &s) : n(s.size() + 1), s(s) {
suf = order = lcp = vector<int>(n);
vector<int> bucket_idx(n), newOrder(n), newsuff(n);
{
vector<int> prev(n), head(alpha, -1);
for (int i = 0; i < n; i++) {
prev[i] = head[s[i]];
head[s[i]] = i;
}
int buc = -1, idx = 0;
for (int i = 0; i < alpha; i++) {
if (head[i] == -1) continue;
bucket_idx[++buc] = idx;
for (int j = head[i]; ~j; j = prev[j]) suf[idx++] = j, order[j] = buc;
}
}
int len = 1;
do {
auto cmp = [&](int a, int b) {
if (order[a] != order[b]) return order[a] < order[b];
return getOrder(a + len) < getOrder(b + len);
};
for (int i = 0; i < n; i++) {
int j = suf[i] - len;
if (j < 0) continue;
newsuff[bucket_idx[order[j]]++] = j;
}
for (int i = 1; i < n; i++) {
suf[i] = newsuff[i];
bool cmpres = cmp(suf[i - 1], suf[i]);
newOrder[suf[i]] = newOrder[suf[i - 1]] + cmpres;
if (cmpres) bucket_idx[newOrder[suf[i]]] = i;
}
order = newOrder;
len <<= 1;
} while (order[suf[n - 1]] != n - 1);
}
int count(const string &x) {
int st = 0, ed = n;
for (int i = 0; i < (int)(x.size()) && st < ed; i++) {
auto cmp = [&](int a, int b) {
if (a == -1) return x[i] < s[b + i];
return s[a + i] < x[i];
};
st = lower_bound(suf.begin() + st, suf.begin() + ed, -1, cmp) -
suf.begin();
ed = upper_bound(suf.begin() + st, suf.begin() + ed, -1, cmp) -
suf.begin();
}
return max(0, ed - st);
}
} SA[(int)1e4];
string y;
vector<int> longestPrefix;
vector<int> Fail[26];
int fail(int k, char nxt) {
int &rt = Fail[nxt - 'a'][k];
if (~rt) return rt;
while (k > 0 && y[k] != nxt) k = longestPrefix[k - 1];
if (nxt == y[k]) k++;
return rt = k;
}
void failure_function() {
int n = y.size();
longestPrefix = vector<int>(n);
for (int i = 0; i < 26; i++) Fail[i] = vector<int>(n + 1, -1);
for (int i = 1, k = 0; i < n; i++) longestPrefix[i] = k = fail(k, y[i]);
}
int main() {
run();
string s;
int q;
cin >> s >> q;
for (int i = 0; i < (int)(s.size()); i += sqrtQ)
SA[i / sqrtQ] = suffix_array(s.substr(i, sqrtQ));
auto solve = [&](int l, int r) {
int match = 0, cnt = 0;
for (int i = l; i <= r; i++) {
match = fail(match, s[i]);
if (match == (int)(y.size())) {
cnt++;
match = longestPrefix[match - 1];
}
}
return cnt;
};
while (q--) {
int t;
cin >> t;
if (t == 1) {
int idx;
char ch;
cin >> idx >> ch;
idx--;
s[idx] = ch;
SA[idx / sqrtQ] = suffix_array(s.substr(idx / sqrtQ * sqrtQ, sqrtQ));
} else {
int l, r;
cin >> l >> r >> y;
l--, r--;
failure_function();
if ((int)(y.size()) >= sqrtQ || r - l <= 2 * sqrtQ) {
cout << solve(l, r) << "\n";
continue;
}
int ans = 0, len = (int)(y.size());
int st = l / sqrtQ, ed = r / sqrtQ;
ans += solve(l, (st + 1) * sqrtQ + len - 2);
ans += solve(ed * sqrtQ - len + 1, r);
for (int i = st + 1; i < ed; i++) ans += SA[i].count(y);
for (int i = st + 2; i < ed; i++)
ans += solve(i * sqrtQ - len + 1, i * sqrtQ + len - 2);
cout << ans << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e9;
const long long mod = 998244353;
const int maxn = 1e5 + 50;
bitset<maxn> s[27], ans;
char a[maxn], b[maxn];
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> a + 1;
int len = strlen(a + 1);
for (int i = 1; i <= len; i++) s[a[i] - 'a'].set(i);
int q;
cin >> q;
while (q--) {
int op;
cin >> op;
if (op == 1) {
int x;
char ch;
cin >> x >> ch;
s[a[x] - 'a'][x] = 0;
s[(a[x] = ch) - 'a'][x] = 1;
} else {
ans.set();
int l, r;
cin >> l >> r;
cin >> b;
int len1 = strlen(b);
if (len1 > (r - l + 1)) {
cout << 0 << '\n';
continue;
}
for (int i = 0; i < len1; i++) {
ans &= (s[b[i] - 'a'] >> i);
}
int num1 = (ans >> (l)).count();
int num2 = (ans >> (r - len1 + 2)).count();
cout << num1 - num2 << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int q;
char s[100005] = {0};
bitset<100005> m[27], ans;
int main() {
scanf("%s", s);
int len = strlen(s);
for (int i = 0; i < len; i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
m[s[i] - 'a'][i + 1] = 1;
}
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int op;
scanf("%d", &op);
if (op == 1) {
int pos;
char ne;
scanf("%d %c", &pos, &ne);
m[s[pos - 1] - 'a'][pos] = 0;
m[ne - 'a'][pos] = 1;
s[pos - 1] = ne;
} else if (op == 2) {
int tl, tr;
char s2[100005] = {0};
scanf("%d %d %s", &tl, &tr, s2);
ans.set();
int lens2 = strlen(s2);
for (int j = 0; j < lens2; j++) {
ans &= (m[s2[j] - 'a'] >> j);
}
int leftN = (ans >> (tl)).count();
int rigthN = (ans >> (tr - lens2 + 2)).count();
if (leftN - rigthN < 0) leftN = rigthN;
printf("%d\n", leftN - rigthN);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char s[100005] = {0};
bitset<100005> a[27], b;
int main() {
scanf("%s", s);
int len = strlen(s);
for (int i = 0; i < len; i++) {
if (s[i] >= 'a' && s[i] <= 'z') a[s[i] - 'a'][i + 1] = 1;
}
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int op;
scanf("%d", &op);
if (op == 1) {
int x;
char c;
scanf("%d %c", &x, &c);
a[s[x - 1] - 'a'][x] = 0;
a[c - 'a'][x] = 1;
s[x - 1] = c;
} else if (op == 2) {
int l, r;
char s2[100005] = {0};
scanf("%d %d %s", &l, &r, s2);
b.set();
int len1 = strlen(s2);
for (int j = 0; j < len1; j++) b &= (a[s2[j] - 'a'] >> j);
int ans1 = (b >> (l)).count();
int ans2 = (b >> (r - len1 + 2)).count();
if (ans1 - ans2 < 0) ans1 = ans2;
printf("%d\n", ans1 - ans2);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
int read() {
char ch = getchar();
int w = 1, c = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') w = -1;
for (; isdigit(ch); ch = getchar()) c = (c << 3) + (c << 1) + (ch ^ 48);
return w * c;
}
const int M = 1e5 + 10;
bitset<M> s[30], ans;
char ch[M], t[M];
int n, m;
int main() {
ios::sync_with_stdio(0);
cin >> (ch + 1);
n = strlen(ch + 1);
for (int i = 1; i <= n; ++i) {
s[ch[i] - 'a'][i - 1] = 1;
}
cin >> m;
while (m--) {
int ty, x, y, z;
cin >> ty >> x;
if (ty == 1) {
char c;
cin >> c;
s[ch[x] - 'a'][x - 1] = 0;
s[c - 'a'][x - 1] = 1;
ch[x] = c;
} else {
cin >> y;
cin >> (t + 1);
int l = strlen(t + 1);
ans.set();
for (int i = 1; i <= l; ++i) {
ans &= (s[t[i] - 'a'] >> (i - 1));
}
int lans = (ans >> (x - 1)).count(), rans = (ans >> (y - l + 1)).count();
cout << max(lans - rans, 0) << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int getint() {
int num = 0, flag = 1;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag = -1;
while (c >= '0' && c <= '9') num = num * 10 + c - 48, c = getchar();
return num * flag;
}
int n, m;
char s[100005], t[100005];
bitset<100005> a[27], ans;
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; i++) a[s[i] - 97][i + 1] = 1;
m = getint();
while (m--) {
int op = getint();
if (op == 1) {
int k = getint() - 1;
scanf("%s", t);
a[s[k] - 97][k + 1] = 0, a[t[0] - 97][k + 1] = 1, s[k] = t[0];
} else {
int l = getint(), r = getint();
scanf("%s", t), n = strlen(t);
ans.set();
for (int i = 0; i < n; i++) ans &= (a[t[i] - 97] >> i);
int L = (ans >> l).count(), R = (ans >> (r - n + 2)).count();
printf("%d\n", max(L - R, 0));
}
}
}
|
#include <bits/stdc++.h>
const int maxn = 100100;
std::bitset<maxn> s[26];
char ch[maxn], buf[maxn];
int n, m;
int main() {
std::ios::sync_with_stdio(false), std::cin.tie(0);
std::cin >> ch, n = strlen(ch);
for (int i = 0; i < n; ++i) s[ch[i] - 'a'].set(i);
for (std::cin >> m; m--;) {
int opt, i, l, r;
char c;
std::cin >> opt;
if (opt == 1) {
std::cin >> i >> c, --i;
s[ch[i] - 'a'].reset(i), s[(ch[i] = c) - 'a'].set(i);
} else {
std::cin >> l >> r >> buf;
int len = strlen(buf);
const int p = r - l + 1 - len + 1;
if (p < 0) {
std::cout << 0 << '\n';
continue;
}
std::bitset<maxn> ans;
ans.set();
for (int i = 0; i < len; ++i) ans &= s[buf[i] - 'a'] >> i + l - 1;
std::cout << ans.count() - (ans >> p).count() << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
char s[100005];
bitset<100005> B[30], one, normal;
int main() {
scanf("%s", s);
int n = strlen(s);
one.set();
for (int i = (0); i < (n); i++) B[s[i] - 'a'][i] = 1;
int m;
scanf("%d", &m);
while (m--) {
int co;
scanf("%d", &co);
if (co == 1) {
int x;
char ss[10];
scanf("%d%s", &x, ss);
x--;
B[s[x] - 'a'][x] = 0;
s[x] = ss[0];
B[s[x] - 'a'][x] = 1;
} else {
int l, r;
char ss[100005];
scanf("%d%d%s", &l, &r, ss);
l--;
r--;
int _n = strlen(ss);
normal = ((one >> (100004 - (r - _n + 1))) & (one << l));
for (int i = (0); i < (_n); i++) normal &= B[ss[i] - 'a'] >> i;
printf("%d\n", (int)normal.count());
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e5 + 5;
bitset<maxn> f[26], w;
char s[maxn], p[maxn];
int main() {
int n, q, op, i, j, k;
scanf("%s", s);
n = strlen(s);
for (i = 0; i < n; i++) f[s[i] - 'a'][i] = 1;
scanf("%d", &q);
while (q--) {
scanf("%d", &op);
if (op == 1) {
scanf("%d %s", &i, p);
i--;
f[s[i] - 'a'][i] = 0;
s[i] = p[0];
f[s[i] - 'a'][i] = 1;
} else {
scanf("%d%d %s", &i, &j, p);
n = strlen(p);
if (i + n - 1 > j) {
puts("0");
continue;
}
w = f[p[0] - 'a'];
for (k = 1; k < n; k++) w &= f[p[k] - 'a'] >> k;
printf("%d\n",
(int)((w >> (i - 1)).count() - (w >> (j - n + 1)).count()));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const maxn = 1e5 + 10;
struct bkn {
int to, next;
} e[maxn * 2];
int n, m;
int c[maxn], head[maxn], tot, vis[maxn][2], in[maxn];
int ans[maxn], cnt, h, win;
void add(int a, int b) {
e[++tot].to = b;
e[tot].next = head[a], head[a] = tot;
}
void dfs(int x, int now) {
if (!c[x] && now == 1) {
win = 1;
ans[++cnt] = x;
return;
}
in[x] = 1;
for (int i = head[x]; i; i = e[i].next) {
int y = e[i].to;
if (in[y]) h = 1;
if (vis[y][now ^ 1]) continue;
vis[y][now ^ 1] = 1;
dfs(y, now ^ 1);
if (win) {
ans[++cnt] = x;
return;
}
}
in[x] = 0;
}
int main() {
scanf("%d%d", &n, &m);
int ok = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
if (!c[i]) ok = 1;
for (int j = 1; j <= c[i]; j++) {
int x;
scanf("%d", &x);
add(i, x);
}
}
int s;
scanf("%d", &s);
if (!ok) {
printf("Draw\n");
return 0;
}
dfs(s, 0);
if (win) {
printf("Win\n");
for (int i = cnt; i >= 1; i--) {
printf("%d ", ans[i]);
}
printf("\n");
} else if (h) {
printf("Draw\n");
} else
printf("Lose\n");
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100001];
int dist[100001];
int visForCycleDetection[100001];
int visForParityDetection[100001][2];
int parent[100001][2];
int cycle = 0;
void printPath(int cur, int parity) {
if (parent[cur][parity] == 0) {
cout << cur << " ";
} else {
printPath(parent[cur][parity], parity ^ 1);
cout << cur << " ";
}
}
void dfs(int cur, int prev, int parity) {
visForCycleDetection[cur] = 1;
visForParityDetection[cur][parity] = 1;
parent[cur][parity] = prev;
for (int i = 0; i < g[cur].size(); i++) {
if (!visForParityDetection[g[cur][i]][parity ^ 1]) {
dfs(g[cur][i], cur, parity ^ 1);
}
if (visForCycleDetection[g[cur][i]]) {
cycle = 1;
}
}
visForCycleDetection[cur] = 0;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int c;
cin >> c;
while (c--) {
int x;
cin >> x;
g[i].push_back(x);
}
}
int s;
cin >> s;
dfs(s, 0, 0);
for (int i = 1; i <= n; i++) {
if (g[i].size() == 0 && visForParityDetection[i][1]) {
cout << "Win\n";
printPath(i, 1);
return 0;
}
}
if (cycle) {
cout << "Draw\n";
} else {
cout << "Lose\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 5;
const int maxm = 200000 + 5;
vector<int> G[maxn];
bool vis[maxn][3];
int W[maxn], ser[maxn], win = 0, draw = 0, du[maxn];
void dfs(int x, int id) {
if (win) return;
if (G[x].size() == 0 && id % 2 == 0) {
win = id;
for (int i = 0; i < id; i++) W[i] = ser[i];
return;
}
for (int i = 0; i < (int)G[x].size(); i++) {
if (!vis[G[x][i]][id & 1]) {
vis[G[x][i]][id & 1] = 1;
ser[id] = G[x][i];
dfs(G[x][i], id + 1);
}
}
}
bool dnf2(int x) {
if (du[x] == 1) {
return true;
}
du[x]++;
for (int i = 0; i < (int)G[x].size(); i++)
if (dnf2(G[x][i])) return true;
du[x]--;
return false;
}
int main() {
int n, m, s;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int c, d;
scanf("%d", &c);
for (int j = 0; j < c; j++) {
scanf("%d", &d);
G[i].push_back(d);
}
}
scanf("%d", &s);
ser[0] = s;
dfs(s, 1);
if (win) {
printf("Win\n");
for (int i = 0; i < win; i++) printf("%d ", W[i]);
} else if (dnf2(s)) {
printf("Draw\n");
} else {
printf("Lose\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int kol_vo_ver, kol_vo_reb;
vector<vector<int> > v;
vector<vector<char> > used;
vector<int> path, vis;
int now = 0;
void init() {
v.resize(kol_vo_ver);
used.resize(kol_vo_ver);
for (int j = 0; j < kol_vo_ver; j++) used[j].resize(2);
path.resize(kol_vo_ver * 3);
vis.resize(kol_vo_ver * 3);
}
bool can(int ver, int st) {
path[now++] = ver;
used[ver][st] = true;
if (v[ver].empty() && st == 1) return true;
for (auto to : v[ver]) {
if (used[to][st ^ 1]) continue;
if (can(to, st ^ 1)) return true;
}
now--;
return false;
}
bool check_win(int ver) {
if (!can(ver, 0)) return false;
cout << "Win" << endl;
for (int c = 0; c < now; c++) cout << path[c] + 1 << " ";
return true;
}
bool dfs(int ver) {
vis[ver] = 1;
for (auto to : v[ver]) {
if (vis[to] == 1) return true;
if (vis[to] == 2) continue;
if (dfs(to)) return true;
}
vis[ver] = 2;
return false;
}
bool check_draw(int ver) { return dfs(ver); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> kol_vo_ver >> kol_vo_reb;
init();
for (int c = 0; c < kol_vo_ver; c++) {
int kol;
cin >> kol;
for (int i = 0; i < kol; i++) {
int e;
cin >> e;
e--;
v[c].push_back(e);
}
}
int start;
cin >> start;
start--;
if (check_win(start)) return 0;
if (check_draw(start)) {
cout << "Draw";
return 0;
} else
cout << "Lose";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
enum { DFS_WHITE = -1, DFS_GREY, DFS_BLACK };
bool hasCycle = false;
vector<pair<int, int> > ady[100005];
vector<pair<int, int> > ady2[100005];
int visited[100005][2];
int par[100005][2];
bool dfs(int v) {
visited[v][0] = DFS_GREY;
bool ret = false;
for (pair<int, int> &e : ady2[v]) {
int dv = e.first;
if (visited[dv][0] == DFS_WHITE) dfs(dv);
if (visited[dv][0] == DFS_GREY) {
hasCycle = true;
}
}
visited[v][0] = DFS_BLACK;
return false;
}
int main(int argc, char const *argv[]) {
int n, m;
scanf("%d %d", &n, &m);
queue<int> q;
memset(visited, 0, sizeof visited);
memset(par, -1, sizeof par);
for (int i = 0; i < n; i += 1) {
int c;
scanf("%d", &c);
for (int j = 0; j < c; j += 1) {
int a;
scanf("%d", &a);
--a;
ady[a].push_back(pair<int, int>(i, 0));
ady2[i].push_back(pair<int, int>(a, 0));
}
if (!c) {
visited[i][1] = 1;
q.push(i);
q.push(1);
}
}
int s;
scanf("%d", &s);
--s;
while (!q.empty()) {
int v = q.front();
q.pop();
int pl = q.front();
q.pop();
for (pair<int, int> &e : ady[v]) {
int dv = e.first;
if (visited[dv][1 - pl] == 0) {
visited[dv][1 - pl] = 1;
par[dv][1 - pl] = v;
q.push(dv);
q.push(1 - pl);
}
}
}
if (visited[s][0]) {
printf("Win\n");
int v = s;
int pl = 0;
while (v != -1) {
printf("%d ", v + 1);
v = par[v][pl];
pl = 1 - pl;
}
printf("\n");
} else {
memset(visited, DFS_WHITE, sizeof visited);
dfs(s);
if (hasCycle) {
printf("Draw\n");
} else {
printf("Lose\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, s;
int even_odd[100005][2];
int visited[100005];
vector<int> ans;
vector<int> v[100005];
int dfs(int s, int p) {
if (v[s].empty() && p) {
ans.push_back(s);
return 1;
}
for (auto it : v[s]) {
if (even_odd[it][p ^ 1] == 0) {
even_odd[it][p ^ 1] = s;
if (dfs(it, p ^ 1)) {
ans.push_back(s);
return 1;
}
}
}
return 0;
}
bool dfs2(int source) {
visited[source] = 1;
for (auto it : v[source])
if (visited[it] == 1 || (visited[it] == 0 && dfs2(it))) return true;
visited[source] = 2;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
int k, a;
cin >> k;
for (int j = 0; j < k; j++) {
cin >> a;
v[i + 1].push_back(a);
}
}
cin >> s;
if (dfs(s, 0)) {
cout << "Win\n";
for (int i = ans.size() - 1; i >= 0; i--) cout << ans[i] << " \n"[i == 0];
} else if (dfs2(s))
cout << "Draw\n";
else
cout << "Lose\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int limN = 2e5 + 5;
const int LE = 1e6;
vector<int> adj[limN];
int minP[limN][2];
pair<int, int> ant[limN][2];
bool actv[limN], rch[limN];
bool dfs(int pos) {
if (rch[pos]) return actv[pos];
rch[pos] = true;
actv[pos] = true;
for (const int &sig : adj[pos])
if (dfs(sig)) return true;
actv[pos] = false;
return false;
}
void printAns(const pair<int, int> pos) {
if (pos.first == 0) return;
printAns(ant[pos.first][pos.second]);
printf("%d ", pos.first);
}
int main() {
bool hasCicl = false;
int N, E;
pair<int, int> pos;
int ini;
queue<pair<int, int> > Q;
scanf("%d%d", &N, &E);
for (int i = 1; i <= N; i++) {
int w;
scanf("%d", &w);
adj[i].resize(w);
for (int &second : adj[i]) scanf("%d", &second);
}
scanf("%d", &pos.first);
ini = pos.first;
minP[pos.first][pos.second] = 1;
Q.push(pos);
while (!Q.empty()) {
pos = Q.front();
Q.pop();
if (adj[pos.first].empty() && pos.second == 1 &&
minP[pos.first][pos.second] < LE) {
printf("Win\n");
printAns(pos);
printf("\n");
return 0;
}
if (minP[pos.first][pos.second] >= LE) {
hasCicl = true;
break;
}
int sp = 1 - pos.second, d = minP[pos.first][pos.second] + 1;
for (const int &sig : adj[pos.first]) {
if (minP[sig][sp]) continue;
Q.push({sig, sp});
minP[sig][sp] = d;
ant[sig][sp] = pos;
}
}
if (!hasCicl) hasCicl |= dfs(ini);
printf("%s\n", hasCicl ? "Draw" : "Lose");
}
|
#include <bits/stdc++.h>
using namespace std;
int testsNumber = 1;
const int nmax = 2 * 1e5 + 5;
vector<int> gf[nmax];
int n, m;
vector<int> gt[nmax];
int viz[nmax][3];
int t[nmax][3];
int s;
int ciclu[nmax];
int ciclu2[nmax];
void reset() {}
void writeDrum(int node, int cost) {
if (node == 0) {
return;
}
writeDrum(t[node][cost], cost ^ 1);
cout << node << " ";
}
void dfs(int node) {
ciclu[node] = 1;
ciclu2[node] = 1;
for (int i = 0; i < gf[node].size(); ++i) {
int vc = gf[node][i];
if (ciclu[vc] == 0) {
dfs(vc);
} else if (ciclu2[vc] == 1) {
cout << "Draw\n";
exit(0);
}
}
ciclu2[node] = 0;
}
void solve() {
queue<pair<int, int> > q;
q.push(make_pair(s, 1));
viz[s][1] = 1;
while (!q.empty()) {
pair<int, int> curNode = q.front();
int currNode = curNode.first;
int currCost = curNode.second;
q.pop();
if (gf[currNode].size() == 0 && currCost % 2 == 0) {
cout << "Win\n";
writeDrum(currNode, currCost);
return;
}
for (int j = 0; j < gf[currNode].size(); ++j) {
int vc = gf[currNode][j];
int newCost = currCost ^ 1;
if (viz[vc][newCost] == 0) {
t[vc][newCost] = currNode;
q.push(make_pair(vc, newCost));
viz[vc][newCost] = 1;
}
}
}
dfs(s);
cout << "Lose"
<< "\n";
}
int main() {
ios::sync_with_stdio(false);
for (int currTest = 1; currTest <= testsNumber; ++currTest) {
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
int ci;
cin >> ci;
for (int j = 1; j <= ci; ++j) {
int y;
cin >> y;
gf[i].push_back(y);
}
}
cin >> s;
reset();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 10;
const long long mod = 1e9 + 7;
long long pw(long long a, long long b) {
if (b == 0) return 1;
long long k = pw(a, b / 2);
k = (k * k) % mod;
if (b & 1) k = (k * a) % mod;
return k;
}
long long n, m;
long long ev[maxn], od[maxn], pv[maxn], pd[maxn];
vector<long long> g[maxn];
void dfs(long long v) {
if (ev[v])
for (auto u : g[v])
if (!od[u]) {
od[u] = 1;
pd[u] = v;
dfs(u);
}
if (od[v])
for (auto u : g[v])
if (!ev[u]) {
pv[u] = v;
ev[u] = 1;
dfs(u);
}
}
long long mark[maxn];
vector<long long> bg[maxn];
bool dor;
bool dfs_draw(long long v) {
mark[v] = 1;
for (auto u : bg[v])
if (mark[u] == 0)
dfs_draw(u);
else if (mark[u] == 1)
dor = 1;
mark[v] = 2;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
vector<long long> sink;
for (long long i = 1; i <= n; i++) {
long long sz;
cin >> sz;
if (sz == 0) sink.push_back(i);
while (sz--) {
long long v;
cin >> v;
g[v].push_back(i);
bg[i].push_back(v);
}
}
long long s;
cin >> s;
for (auto v : sink) {
ev[v] = 1;
dfs(v);
}
if (od[s]) {
cout << "Win\n";
bool T = 0;
long long v = s;
while (bg[v].size()) {
cout << v << " ";
if (T == 0)
v = pd[v];
else
v = pv[v];
T = !T;
}
cout << v;
return 0;
}
dfs_draw(s);
if (dor) return cout << "Draw", 0;
cout << "Lose";
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, t;
};
node now, temp;
queue<node> q;
vector<int> G[100005];
int out[100005], vis[100005][2], flag[100005], ff;
void dfs(int u) {
int i, v;
flag[u] = 1;
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (flag[v] == 1)
ff = 1;
else if (flag[v] == 0)
dfs(v);
}
flag[u] = 2;
}
void print(int pre, int x) {
if (vis[pre][x ^ 1] != -1) print(vis[pre][x ^ 1], x ^ 1);
printf("%d ", pre);
}
int main(void) {
int n, m, k, cnt, a, i, v;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &cnt);
out[i] = cnt;
while (cnt--) {
scanf("%d", &a);
G[i].push_back(a);
}
}
scanf("%d", &k);
vis[k][0] = -1;
now.x = k, now.t = 0;
q.push(now);
while (q.empty() == 0) {
now = q.front();
q.pop();
for (i = 0; i < G[now.x].size(); i++) {
temp.x = G[now.x][i];
temp.t = now.t ^ 1;
if (vis[temp.x][temp.t] == 0) {
vis[temp.x][temp.t] = now.x;
q.push(temp);
}
}
}
for (i = 1; i <= n; i++) {
if (out[i] == 0) {
if (vis[i][1]) {
puts("Win");
print(vis[i][1], 1);
printf("%d\n", i);
return 0;
}
}
}
dfs(k);
if (ff)
puts("Draw");
else
puts("Lose");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int poww(long long int x, long long int y) {
long long int res = 1;
x %= 1000000007;
for (; y; y >>= 1) {
if (y & 1) res = res * x % 1000000007;
x = x * x % 1000000007;
}
return res;
}
int viss[100005], vis[100005][2], cyc[100005];
int par[100005][2];
vector<int> adj[100005];
void dfs(int u, int parity) {
vis[u][parity] = 1;
for (int i = 0; i < adj[u].size(); i++) {
int x = adj[u][i];
if (!vis[x][(parity ^ 1)]) {
par[x][(parity ^ 1)] = u;
dfs(x, parity ^ 1);
}
}
}
void findcycle(int u) {
if (cyc[u] == 1) {
puts("Draw");
exit(0);
}
cyc[u] = 1;
for (int i = 0; i < adj[u].size(); i++) findcycle(adj[u][i]);
cyc[u] = 0;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int tmp;
cin >> tmp;
for (int j = 1; j <= tmp; j++) {
int x;
cin >> x;
adj[i].push_back(x);
}
}
int source;
cin >> source;
dfs(source, 0);
int f = 0;
int start;
for (int i = 1; i <= n; i++) {
if (vis[i][1] == 1 && adj[i].size() == 0) {
f = 1;
start = i;
break;
}
}
int st = 1;
vector<int> v;
if (f == 1) {
while (1) {
v.push_back(start);
if (start == source && st == 0) break;
start = par[start][st];
st ^= 1;
}
puts("Win");
reverse(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
return 0;
}
findcycle(source);
puts("Lose");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long win = 0, draw = 0;
vector<long long> g[100009], us, p;
void dfs(long long v, long long l) {
if (us[v] == 0) {
us[v] = 1;
} else {
us[v] = 2;
}
if (g[v].size() == 0 && l < 1000000 && l % 2 == 1) {
win = 1;
p.push_back(v);
return;
}
for (long long i = 0; i < g[v].size(); i++) {
long long to = g[v][i];
if (us[to] != 2) {
dfs(to, l + 1);
if (win == 1) {
p.push_back(v);
return;
}
}
}
}
bool ccl(long long v) {
us[v] = 1;
for (long long i = 0; i < g[v].size(); i++) {
long long to = g[v][i];
if (us[to] == 1) {
return true;
} else if (us[to] == 0) {
if (ccl(to) == true) {
return true;
}
}
}
us[v] = 2;
return false;
}
int main() {
ios::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
long long k;
cin >> k;
for (long long j = 0; j < k; j++) {
long long p;
cin >> p;
g[i].push_back(p - 1);
}
}
long long s;
cin >> s;
s--;
us = vector<long long>(n, 0);
p.reserve(100000);
dfs(s, 0);
if (win == 1) {
cout << "Win\n";
for (long long i = p.size() - 1; i >= 0; i--) {
cout << p[i] + 1 << " ";
}
return 0;
}
us = vector<long long>(n, 0);
if (ccl(s) == true) {
cout << "Draw";
} else {
cout << "Lose";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, s, tmp1, tmp2;
vector<long long> ans;
vector<vector<long long>> g(100000);
bool vs[2][100000];
bool vs1[100000] = {0}, rc[100000] = {0};
bool a = false, w = false, d = false, t = false;
long long cnt = 0;
void hasc(long long v) {
vs1[v - 1] = true;
rc[v - 1] = true;
for (auto el : g[v - 1]) {
if (!vs1[el - 1])
hasc(el);
else if (rc[el - 1]) {
d = true;
}
}
rc[v - 1] = false;
}
void dfs(long long v) {
ans.push_back(v);
vs[a][v - 1] = true;
if (a && !(g[v - 1].size())) {
w = 1;
return;
}
a = !a;
for (auto el : g[v - 1])
if (!vs[a][el - 1] && !w) {
dfs(el);
}
a = !a;
if (w) return;
ans.pop_back();
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> tmp1;
for (int j = 0; j < tmp1; j++) {
cin >> tmp2;
g[i].push_back(tmp2);
}
}
cin >> s;
dfs(s);
hasc(s);
if (w) {
cout << "Win" << endl;
for (auto el : ans) cout << el << " ";
cout << endl;
} else if (d) {
cout << "Draw" << endl;
} else
cout << "Lose" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
vector<int> G[maxn];
bool visit[maxn][2], vis[maxn];
int path[maxn];
void dfs(int v, int flag, int xb) {
if (G[v].size() == 0 && flag) {
cout << "Win" << endl;
for (int i = 0; i < xb; i++) printf("%d ", path[i]);
cout << v << endl;
exit(0);
}
if (visit[v][flag]) return;
path[xb] = v;
visit[v][flag] = 1;
for (int i = 0; i < G[v].size(); i++) dfs(G[v][i], flag ^ 1, xb + 1);
}
void cycle(int v) {
if (vis[v]) {
cout << "Draw" << endl;
exit(0);
}
vis[v] = 1;
for (int i = 0; i < G[v].size(); i++) {
cycle(G[v][i]);
}
vis[v] = 0;
}
int main() {
int n, m, s;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int c, x;
scanf("%d", &c);
while (c--) {
scanf("%d", &x);
G[i].push_back(x);
}
}
cin >> s;
dfs(s, 0, 0);
cycle(s);
cout << "Lose" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const maxn = 1e5 + 10;
struct bkn {
int to, next;
} e[maxn * 2];
int n, m;
int c[maxn], head[maxn], tot, vis[maxn][2], in[maxn];
int ans[maxn], cnt, h, win;
void add(int a, int b) {
e[++tot].to = b;
e[tot].next = head[a], head[a] = tot;
}
void dfs(int x, int now) {
if (!c[x] && now == 1) {
win = 1;
ans[++cnt] = x;
return;
}
in[x] = 1;
for (int i = head[x]; i; i = e[i].next) {
int y = e[i].to;
if (in[y]) h = 1;
if (vis[y][now ^ 1]) continue;
vis[y][now ^ 1] = 1;
dfs(y, now ^ 1);
if (win) {
ans[++cnt] = x;
return;
}
}
in[x] = 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
for (int j = 1; j <= c[i]; j++) {
int x;
scanf("%d", &x);
add(i, x);
}
}
int s;
scanf("%d", &s);
dfs(s, 0);
if (win) {
printf("Win\n");
for (int i = cnt; i >= 1; i--) {
printf("%d ", ans[i]);
}
printf("\n");
} else if (h) {
printf("Draw\n");
} else
printf("Lose\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7, M = 2e5 + 7;
pair<int, int> vf[4 * M];
int ant[4 * M], sf[N][2], basevf[2 * M], baseant[2 * M], basesf[N], gradex[N],
nl(0), basenl(0), prevy[2 * N];
bool vis[N][2], vees[N], ok(false), cycle(false);
void adaugaC(int x, int y) {
vf[++nl] = make_pair(y, 0);
ant[nl] = sf[x][1];
sf[x][1] = nl;
vf[++nl] = make_pair(y, 1);
ant[nl] = sf[x][0];
sf[x][0] = nl;
}
void adauga(int x, int y) {
basevf[++basenl] = y;
baseant[basenl] = basesf[x];
basesf[x] = basenl;
}
void dfs(int nodc, int state, int pozc) {
if (ok) {
return;
}
prevy[pozc] = nodc;
vis[nodc][state] = true;
if (!gradex[nodc] && !state) {
cout << "Win\n";
for (int i = 0; i <= pozc; ++i) {
cout << prevy[i] << " ";
}
ok = true;
return;
}
for (int x = sf[nodc][state]; x; x = ant[x]) {
pair<int, int> nod = vf[x];
if (!vis[nod.first][nod.second]) {
dfs(nod.first, nod.second, pozc + 1);
}
}
}
void checkforcycles(int nodc) {
if (cycle) {
return;
}
for (int x = basesf[nodc]; x; x = baseant[x]) {
if (vees[basevf[x]]) {
cycle = true;
return;
}
vees[basevf[x]] = true;
checkforcycles(basevf[x]);
vees[basevf[x]] = false;
}
}
int main() {
int n, m, x, nod;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> gradex[i];
for (int j = 0; j < gradex[i]; ++j) {
cin >> x;
adaugaC(i, x);
adauga(i, x);
}
}
cin >> nod;
dfs(nod, 1, 0);
if (ok) {
return 0;
}
checkforcycles(nod);
vees[nod] = true;
if (cycle) {
cout << "Draw\n";
return 0;
}
cout << "Lose";
return 0;
}
|
#include <bits/stdc++.h>
const int MAX = 2e5;
struct Situation {
int longueur, u;
};
std::vector<int> G[MAX];
bool visited[MAX][2];
bool visiting[MAX];
int parent[MAX][2];
bool DFS(int u) {
if (visiting[u]) return false;
visiting[u] = true;
for (auto v : G[u])
if (!DFS(v)) return false;
visiting[u] = false;
return true;
}
int main(void) {
std::ios_base::sync_with_stdio(false);
int N, M;
std::cin >> N >> M;
for (int i(0); i < N; ++i) {
int m;
std::cin >> m;
while (m--) {
int v;
std::cin >> v;
--v;
G[i].push_back(v);
}
}
int start;
std::cin >> start;
--start;
std::queue<Situation> Q;
Q.push({0, start});
visited[start][0] = true;
while (!Q.empty()) {
Situation cur = Q.front();
Q.pop();
if (G[cur.u].size() == 0) {
if (cur.longueur % 2 == 0) continue;
std::cout << "Win" << std::endl;
std::vector<int> answer;
int index(cur.longueur);
for (int i(cur.u); index % 2 == 1 or i != start; --index) {
answer.push_back(i + 1);
i = parent[i][(index) % 2];
}
answer.push_back(start + 1);
for (int i(answer.size() - 1); i >= 0; --i) std::cout << answer[i] << " ";
std::cout << std::endl;
while (!Q.empty()) Q.pop();
return 0;
}
for (auto v : G[cur.u]) {
if (visited[v][(cur.longueur + 1) % 2]) continue;
Q.push({cur.longueur + 1, v});
visited[v][(cur.longueur + 1) % 2] = true;
parent[v][(cur.longueur + 1) % 2] = cur.u;
}
}
if (!DFS(start))
std::cout << "Draw" << std::endl;
else
std::cout << "Lose" << std::endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void func(void) {
freopen("input.c", "r", stdin);
freopen("output.c", "w", stdout);
}
const int N = 2e5 + 10;
vector<long long> a[N];
long long vis[N], dis[N][2], par[N][2];
long long aa;
vector<long long> leaf;
void bfs(int x) {
queue<long long> q;
par[x][0] = par[x][1] = -1;
q.push(x);
dis[x][0] = 0;
for (int i = 0; i < N; i++)
dis[i][0] = dis[i][1] = par[i][0] = par[i][1] = -1;
dis[x][0] = 0;
while (!q.empty()) {
int y = q.front();
q.pop();
if (a[y].size() == 0) {
leaf.push_back(y);
}
for (int i = 0; i < a[y].size(); i++) {
int z = a[y][i];
if (dis[y][0] != -1 and dis[z][1] == -1) {
dis[z][1] = dis[y][0] + 1;
par[z][1] = y;
q.push(z);
}
if (dis[y][1] != -1 and dis[z][0] == -1) {
dis[z][0] = dis[y][1] + 1;
par[z][0] = y;
q.push(z);
}
}
}
}
int flag = 0;
void dfs(int x) {
vis[x] = 1;
for (int i = 0; i < a[x].size(); i++) {
int y = a[x][i];
if (!vis[y]) dfs(y);
if (vis[y] == 1) flag = 1;
}
vis[x] = 2;
}
stack<long long> st;
long long d = 0;
void printPath(long long y, long long dis, long long dd) {
st.push(y);
d = max(d, dd);
if (dis & 1) {
if (par[y][1] == -1) return;
printPath(par[y][1], 0, dd + 1);
} else {
if (par[y][0] == -1) return;
printPath(par[y][0], 1, dd + 1);
}
}
int main() {
long long n, q, i, j = 0, temp, t, k, ans = 0, sum = 0, x, y, z, cnt = 0, m,
fg = 0, mx = 0, mx1 = 0, mn = 8000000000000000000,
mn1 = 8000000000000000000;
scanf("%lld %lld", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%lld", &x);
while (x--) {
scanf("%lld", &y);
a[i].push_back(y);
}
}
scanf("%lld", &x);
dfs(x);
bfs(x);
for (int i = 0; i < leaf.size(); i++) {
y = leaf[i];
if (dis[y][1] != -1) {
ans = y;
fg = 1;
break;
}
}
if (fg == 0) {
if (flag)
cout << "Draw\n";
else
cout << "Lose\n";
return 0;
}
printPath(ans, 1, 1);
if (d == 1) {
cout << "Lose\n";
return 0;
}
cout << "Win\n";
while (!st.empty()) {
x = st.top();
st.pop();
printf("%lld ", x);
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> adj;
vector<vector<int>> parent;
vector<int> post;
vector<bool> done;
int t = 0;
bool cycle = 0;
void dfs(int u) {
done[u] = 1;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (done[v] && post[v] == -1) cycle = 1;
if (parent[u][1] != -1 && parent[v][0] == -1 ||
parent[u][0] != -1 && parent[v][1] == -1) {
if (parent[u][1] != -1 && parent[v][0] == -1) {
parent[v][0] = u;
}
if (parent[u][0] != -1 && parent[v][1] == -1) {
parent[v][1] = u;
}
dfs(v);
}
}
post[u] = t++;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, c, x, s;
cin >> n >> m;
adj.resize(n);
done.resize(n);
parent = vector<vector<int>>(n, vector<int>(2, -1));
post = vector<int>(n, -1);
for (int i = 0; i < n; i++) {
cin >> c;
for (int j = 0; j < c; j++) {
cin >> x;
adj[i].push_back(x - 1);
}
}
cin >> s;
s--;
parent[s][0] = s;
dfs(s);
int i;
for (i = 0; i < n; i++)
if (!adj[i].size() && parent[i][1] != -1) break;
if (i != n) {
cout << "Win\n";
int c = 0;
vector<int> ans;
while (!(i == s && c == 1)) {
ans.push_back(i + 1);
i = parent[i][c = (c + 1) % 2];
}
ans.push_back(s + 1);
for (int i = ans.size() - 1; i >= 0; i--) cout << ans[i] << " \n"[i == 0];
} else if (cycle)
cout << "Draw\n";
else
cout << "Lose\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 4;
int n, m, s, oud[MAX], vst[MAX][2], fin[MAX];
set<int> g[MAX];
vector<int> ans;
bool found = 0, cycle;
void dfs(int u, int p) {
if (found) return;
vst[u][p] = 1;
ans.push_back(u);
if (oud[u] == 0 && ans.size() % 2 == 0) found = 1;
for (int v : g[u]) {
if ((vst[v][!p] || vst[v][p]) && !fin[v]) cycle = 1;
if (!vst[v][!p]) {
vst[v][!p] = 1;
dfs(v, !p);
}
}
if (found) return;
ans.pop_back();
fin[u] = 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
;
cin >> n >> m;
for (int u = 1, x; u <= n; u++) {
cin >> x;
for (int i = 0, v; i < x; i++) {
cin >> v;
g[u].insert(v);
oud[u]++;
}
}
cin >> s;
dfs(s, 1);
if (found) {
cout << "Win\n";
for (int i : ans) cout << i << " ";
cout << '\n';
} else {
if (cycle)
cout << "Draw\n";
else
cout << "Lose\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5 + 9;
int res[MAX_N][2], point[MAX_N], num_s, st[MAX_N * 4], vis[MAX_N];
vector<int> vec[MAX_N];
int N, M, x;
bool dfs(int pos, int x) {
if (res[pos][x ^ 1] == 1) return false;
res[pos][x ^ 1] = 1;
st[num_s++] = pos;
if (vec[pos].size() == 0 && res[pos][1]) {
return true;
}
for (int i = 0; i < vec[pos].size(); i++) {
if (dfs(vec[pos][i], x ^ 1)) return true;
}
num_s--;
return false;
}
bool cheak(int pos) {
vis[pos] = 1;
bool f = false;
for (int i = 0; i < vec[pos].size(); i++) {
if (vis[vec[pos][i]] == 1)
f = true;
else if (vis[vec[pos][i]] == 0)
f = cheak(vec[pos][i]);
if (f) return true;
}
vis[pos] = 2;
return false;
}
int main() {
cin >> N >> M;
for (int i = 1; i <= N; i++) {
int num, temp;
scanf("%d", &num);
for (int j = 0; j < num; j++) {
scanf("%d", &temp);
vec[i].push_back(temp);
}
}
int pos;
cin >> pos;
if (dfs(pos, 1)) {
cout << "Win" << endl;
for (int i = 0; i < num_s; i++) {
printf("%d ", st[i]);
}
cout << endl;
} else if (cheak(pos))
cout << "Draw" << endl;
else
cout << "Lose" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
struct Where {
int node;
int parity;
Where(int _node = 0, int _parity = 0) {
node = _node;
parity = _parity;
}
};
vector<int> gr[MAXN];
vector<int> gri[MAXN];
bool inQ[MAXN];
int grad[MAXN];
bool found[MAXN][2];
int last[MAXN][2];
int vis[MAXN];
bool cycle = false;
void dfs(int node) {
if (vis[node] == 1) cycle = 1;
if (cycle || vis[node]) return;
vis[node] = 1;
for (auto x : gri[node]) dfs(x);
vis[node] = 2;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
scanf("%d", &n);
int m;
scanf("%d", &m);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
while (x--) {
int y;
scanf("%d", &y);
grad[i]++;
gr[y].push_back(i);
gri[i].push_back(y);
}
}
int s;
scanf("%d", &s);
queue<Where> Q;
for (int i = 1; i <= n; ++i) {
if (grad[i] == 0) Q.push({i, 0});
}
if (Q.size() == 0) {
cout << "Draw";
return 0;
}
while (Q.size()) {
Where current;
current = Q.front();
Q.pop();
if (current.node == s && current.parity == 1) {
break;
}
for (auto x : gr[current.node]) {
if (found[x][current.parity ^ 1]) continue;
found[x][current.parity ^ 1] = true;
last[x][current.parity ^ 1] = current.node;
Q.push({x, current.parity ^ 1});
}
}
if (found[s][1]) {
cout << "Win\n";
int node = s;
int parity = 1;
cout << node << ' ';
while (grad[node] != 0) {
node = last[node][parity];
parity ^= 1;
cout << node << ' ';
}
return 0;
}
dfs(s);
if (cycle)
cout << "Draw";
else
cout << "Lose";
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456")
using namespace std;
template <typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& t) {
return in >> t.first >> t.second;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& out, pair<T1, T2>& t) {
return out << t.first << " " << t.second;
}
template <typename T>
istream& operator>>(istream& in, vector<T>& t) {
for (long long i = 0; i < t.size(); i++) in >> t[i];
return in;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T>& t) {
for (long long i = 0; i < t.size(); i++) out << t[i] << " ";
return out;
}
struct G {
vector<long long> to, rev;
long long stat[2] = {-1, -1};
long long left[2] = {-1, -1};
long long p[2] = {-1, -1};
};
vector<G> g;
void bfs() {
queue<pair<long long, long long> > que;
for (long long i = 0; i < g.size(); i++) {
g[i].left[0] = g[i].left[1] = g[i].to.size();
if (g[i].to.size() == 0) {
g[i].stat[0] = 0;
g[i].stat[1] = 0;
que.push({i, 0});
que.push({i, 1});
}
}
while (!que.empty()) {
long long v = que.front().first;
long long who = que.front().second;
que.pop();
long long stat = g[v].stat[who];
for (long long u : g[v].rev) {
if (g[u].stat[!who] != -1) continue;
if (who == stat) {
g[u].stat[!who] = !who;
g[u].p[!who] = v;
que.push({u, !who});
} else {
g[u].left[!who]--;
if (g[u].left[!who] == 0) {
g[u].stat[!who] = who;
g[u].p[!who] = v;
que.push({u, !who});
}
}
}
}
}
void res(long long v, long long who) {
if (v == -1) return;
cout << v + 1 << " ";
res(g[v].p[who], !who);
}
signed main() {
long long n, m;
cin >> n >> m;
g.resize(n);
for (long long i = 0; i < n; i++) {
long long sz;
scanf("%lld", &sz);
for (long long j = 0; j < sz; j++) {
long long to;
scanf("%lld", &to);
to--;
g[i].to.push_back(to);
g[to].rev.push_back(i);
}
}
bfs();
long long s;
cin >> s;
s--;
if (g[s].stat[1] == 1) {
puts("Win");
res(s, 1);
cout << endl;
} else if (g[s].stat[1] == -1) {
puts("Draw");
} else if (g[s].stat[1] == 0) {
puts("Lose");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> edge[100010];
int n, m, c, a, s, sum;
int ve[100010], vo[100010], vis[100010], ans[100010], flag, fd;
void dfs(int ver, int cnt) {
vis[ver] = 1;
if (flag) return;
ans[cnt] = ver;
if (cnt > 1000000) {
fd = 1;
vis[ver] = 0;
return;
}
if (!edge[ver].size()) {
if (ve[ver] == 1) {
flag = 1;
sum = cnt;
}
vis[ver] = 0;
return;
}
for (int i = 0; i < edge[ver].size(); i++) {
if (vis[edge[ver][i]]) fd = 1;
if (ve[ver] == 1 && vo[edge[ver][i]] == 0) {
vo[edge[ver][i]] = 1;
dfs(edge[ver][i], cnt + 1);
}
if (vo[ver] == 1 && ve[edge[ver][i]] == 0) {
ve[edge[ver][i]] = 1;
dfs(edge[ver][i], cnt + 1);
}
}
vis[ver] = 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &c);
for (int j = 1; j <= c; j++) {
scanf("%d", &a);
edge[i].push_back(a);
}
}
scanf("%d", &s);
vo[s] = 1;
dfs(s, 1);
if (flag) {
printf("Win\n");
for (int i = 1; i <= sum; i++) {
printf("%d ", ans[i]);
}
printf("\n");
} else if (fd) {
printf("Draw\n");
} else {
printf("Lose\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct s {
int to, next;
} edge[2 * 200005];
int head[200005];
int tot;
void add(int x, int y) {
edge[tot].to = y;
edge[tot].next = head[x];
head[x] = tot++;
}
int f[200005][3], id[200005][3], ff[200005 * 2], cnt;
bool dfs(int x, int sum) {
if (f[x][sum ^ 1] == 1) return false;
f[x][sum ^ 1] = 1;
ff[cnt++] = x;
if (head[x] == -1 && f[x][1]) return true;
for (int i = head[x]; i != -1; i = edge[i].next) {
int z = edge[i].to;
if (dfs(z, sum ^ 1)) return true;
}
cnt--;
return false;
}
int vis[200005];
bool check(int x) {
vis[x] = 1;
bool flag = false;
for (int i = head[x]; i != -1; i = edge[i].next) {
int z = edge[i].to;
if (vis[z] == 1)
flag = true;
else if (vis[z] == 0)
flag = check(z);
if (flag) return true;
}
vis[x] = 2;
return false;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
memset(head, -1, sizeof(head));
tot = 0;
int x, k;
for (int i = 1; i <= n; ++i) {
scanf("%d", &k);
for (int j = 1; j <= k; ++j) {
scanf("%d", &x);
add(i, x);
}
}
scanf("%d", &x);
cnt = 0;
if (dfs(x, 1)) {
printf("Win\n");
for (int i = 0; i <= cnt - 1; ++i)
printf("%d%c", ff[i], i == cnt - 1 ? '\n' : ' ');
} else if (check(x))
printf("Draw\n");
else
printf("Lose\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
vector<int> G[N];
bool instack[N][2];
int dp[N][2];
int dfs(int u, int dep = 0) {
if (dp[u][dep] != -1) {
return dp[u][dep];
}
dp[u][dep] = 0;
instack[u][dep] = true;
for (int v : G[u]) {
if (instack[v][dep ^ 1]) {
dp[u][dep] |= 4;
} else {
dfs(v, dep ^ 1);
if (dp[v][dep ^ 1] & 1) {
dp[u][dep] |= 2;
}
if (dp[v][dep ^ 1] & 2) {
dp[u][dep] |= 1;
}
if ((dp[v][dep ^ 1] & 4)) {
dp[u][dep] |= 4;
}
}
}
if (G[u].size() == 0) {
dp[u][dep] |= 2;
}
instack[u][dep] = false;
return dp[u][dep];
}
void Print(int u, int dep = 0) {
printf("%d ", u);
instack[u][dep] = true;
for (int v : G[u])
if (!instack[v][dep ^ 1]) {
if ((dp[v][dep ^ 1] & 2) && !dep) {
Print(v, dep ^ 1);
break;
}
if ((dp[v][dep ^ 1] & 1) && dep) {
Print(v, dep ^ 1);
break;
}
}
instack[u][dep] = false;
}
int main() {
ios ::sync_with_stdio(false);
cout << fixed << setprecision(16);
int n, m, c, v, s;
scanf("%d%d", &n, &m);
for (int u = 1; u <= n; u++) {
scanf("%d", &c);
for (int i = 0; i < c; i++) {
scanf("%d", &v);
G[u].push_back(v);
}
}
scanf("%d", &s);
memset(dp, -1, sizeof dp);
int result = dfs(s);
if (result & 1) {
puts("Win");
Print(s);
puts("");
} else if (result & 4) {
puts("Draw");
} else {
puts("Lose");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
vector<int> G[110000];
int onstack[110000];
int mark[110000];
int st[2][110000];
int cycle = 0;
void dfs(int k) {
if (cycle) return;
mark[k] = 1;
onstack[k] = 1;
for (int i = 0; i < G[k].size(); i++) {
if (mark[G[k][i]] == 0)
dfs(G[k][i]);
else if (onstack[G[k][i]])
cycle = 1;
}
onstack[k] = 0;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
for (int j = 0; j < t; j++) {
int temp;
cin >> temp;
G[i + 1].push_back(temp);
}
}
int s;
cin >> s;
dfs(s);
st[1][s] = -1;
queue<int> qi;
qi.push(s);
while (!qi.empty()) {
s = qi.front();
qi.pop();
for (int i = 0; i < G[s].size(); i++) {
int flag = 0;
if (st[0][s] != 0 && st[1][G[s][i]] == 0) {
st[1][G[s][i]] = s;
flag = 1;
}
if (st[1][s] != 0 && st[0][G[s][i]] == 0) {
st[0][G[s][i]] = s;
flag = 1;
if (G[G[s][i]].size() == 0) {
cout << "Win" << endl;
vector<int> ans;
ans.push_back(G[s][i]);
int k = 0, ks = G[s][i];
while (st[k][ks] != -1) {
ans.push_back(st[k][ks]);
ks = st[k][ks];
k = (k + 1) % 2;
}
reverse(ans.begin(), ans.end());
for (auto at : ans) cout << at << " ";
cout << endl;
return 0;
}
}
if (flag == 1) qi.push(G[s][i]);
}
}
if (cycle)
cout << "Draw" << endl;
else
cout << "Lose" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void debug(int* a, int n) {
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << '\n';
}
void debug(vector<int> b, int n) {
for (int i = 0; i < n; i++) cout << b[i] << " ";
cout << '\n';
}
const long long INF = 1e18;
const int inf = 1e9;
vector<int> a[100005];
int flag = 0, flag2 = 0;
int vis[100005][2], parent[100005][2], ans = -1, vis1[100005] = {0};
int mydfs(int n, int pair) {
int cp = (pair + 1) % 2, i;
if (flag == 1) return 0;
if (a[n].size() == 0 && pair == 1) {
flag = 1;
ans = n;
return 0;
}
for (i = 0; i < a[n].size(); i++) {
if (vis[a[n][i]][cp] == 0) {
vis[a[n][i]][cp] = 1;
parent[a[n][i]][cp] = n;
mydfs(a[n][i], cp);
}
}
return 0;
}
int mydfs1(int n) {
int i;
if (flag2 == 1 || flag == 1) return 0;
for (i = 0; i < a[n].size(); i++) {
if (vis1[a[n][i]] == 1) {
flag2 = 1;
break;
}
vis1[a[n][i]] = 1;
mydfs1(a[n][i]);
vis1[a[n][i]] = 0;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
long long n, m, i, j, temp, p;
cin >> n >> m;
for (i = 0; i < 100005; i++) {
for (j = 0; j < 2; j++) {
vis[i][j] = 0;
parent[i][j] = 0;
vis1[i] = 0;
}
}
for (i = 0; i < n; i++) {
cin >> temp;
for (j = 0; j < temp; j++) {
cin >> p;
a[i + 1].push_back(p);
}
}
long long s;
cin >> s;
if (a[s].size() == 0) {
cout << "Lose" << endl;
return 0;
}
vis[s][0] = 1;
for (i = 0; i < a[s].size(); i++) {
parent[a[s][i]][1] = s;
vis[a[s][i]][1] = 1;
mydfs(a[s][i], 1);
}
vis1[s] = 1;
mydfs1(s);
if (ans != -1) {
cout << "Win" << endl;
vector<int> golu;
int cp = 1;
while (1) {
golu.push_back(ans);
if (ans == s && cp == 0) break;
ans = parent[ans][cp];
cp += 1;
cp %= 2;
}
for (i = golu.size() - 1; i >= 0; i--) {
cout << golu[i] << " ";
}
cout << endl;
} else if (flag2 == 1) {
cout << "Draw" << endl;
} else {
cout << "Lose" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
unsigned seed = chrono::system_clock::now().time_since_epoch().count();
mt19937 eng(seed);
long long random2() { return (1ll << 31ll) * eng() + eng(); }
long long n, m, k, q, T;
const long long big = 1000000007;
const long long big2 = 1000000009;
const long long mod = 998244353;
const int MAXN = 200001;
vector<vector<int> > C(MAXN, vector<int>());
vector<vector<int> > C2(MAXN, vector<int>());
bool mark[MAXN] = {0};
int par[MAXN] = {0};
int start;
int win = -1;
int lose = -1;
bool dead_end[MAXN] = {0};
void dfs(int i) {
if ((int)(C[i]).size() == 0) {
if (i % 2 == 0) lose = i;
if (i % 2 == 1) win = i;
}
mark[i] = 1;
for (auto& y : C[i]) {
if (!mark[y]) {
par[y] = i;
dfs(y);
}
}
}
int deg[MAXN] = {0};
void get_dead() {
vector<int> Q;
for (int c1 = 0; c1 < (2 * n); ++c1) {
deg[c1] = (int)(C[c1]).size();
if (deg[c1] == 0) {
Q.push_back(c1);
}
}
while (!Q.empty()) {
int a = Q.back();
Q.pop_back();
dead_end[a] = 1;
for (auto& y : C2[a]) {
deg[y]--;
if (deg[y] == 0) Q.push_back(y);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long a, b, c, d, e;
cin >> n >> m;
for (int c1 = 0; c1 < (n); ++c1) {
cin >> c;
for (int c2 = 0; c2 < (c); ++c2) {
cin >> a;
a--;
C[2 * c1].push_back(2 * a + 1);
C[2 * c1 + 1].push_back(2 * a);
C2[2 * a].push_back(2 * c1 + 1);
C2[2 * a + 1].push_back(2 * c1);
}
}
cin >> start;
start--;
dfs(2 * start);
get_dead();
if (win != -1) {
cout << "Win\n";
vector<int> ANS;
while (win != 2 * start) {
ANS.push_back(win / 2);
win = par[win];
}
ANS.push_back(start);
reverse(ANS.begin(), ANS.end());
for (auto& y : ANS) {
cout << y + 1 << " ";
}
cout << "\n";
} else {
if (dead_end[2 * start]) {
cout << "Lose\n";
} else {
cout << "Draw\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
using namespace std;
const double eps = 1e-6;
const long long mod = 1e9 + 7;
const int maxn = 1e5 + 100;
const int maxe = 1e6 + 100;
struct node {
int to;
int next;
};
bool dp[maxn][2], cir;
vector<int> V[maxn];
int vis[maxn][2];
int Next[maxn][2], n, m;
inline bool dfs(int x, int s) {
if (!V[x].size()) return s == 1;
if (vis[x][s] == 2) return dp[x][s];
vis[x][s] = 1;
bool t = 0;
for (int i = 0; i < V[x].size(); i++) {
int v = V[x][i];
if (vis[v][s ^ 1] == 1) {
cir = 1;
continue;
}
if (dfs(v, s ^ 1)) {
t = 1;
Next[x][s] = v;
}
}
vis[x][s] = 2;
return dp[x][s] = t;
}
inline void print(int x, int s) {
printf("%d ", x);
if (Next[x][s]) {
print(Next[x][s], s ^ 1);
}
}
void Solve() {
cin >> n >> m;
int xx, v;
for (int i = 1; i <= n; i++) {
cin >> xx;
for (int j = 0; j < xx; j++) {
cin >> v;
V[i].push_back(v);
}
}
int st;
cin >> st;
if (dfs(st, 0)) {
puts("Win");
print(st, 0);
} else if (cir)
puts("Draw");
else
puts("Lose");
}
int main() {
int Case = 1, cases;
while (Case--) {
Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
struct Matrix {
vector<vector<int>> data;
int r, c;
Matrix(int row, int col, bool identity = false) : r(row), c(col) {
data.assign(row, vector<int>(col, 0));
if (identity) {
for (int i = 0; i < r; ++i) {
data[i][i] = 1;
}
}
}
Matrix operator*(Matrix &other) {
int m = r, n = c, p = other.c;
Matrix res(m, p);
for (int i = 0; i < m; ++i) {
for (int j = 0; j < p; ++j) {
for (int k = 0; k < n; ++k) {
res.data[i][j] += data[i][k] * other.data[k][j];
}
}
}
return res;
}
};
vector<int> extendGcd(int a, int b) {
if (b == 0) {
return {a, 1, 0};
} else {
vector<int> tmp = extendGcd(b, a % b);
return {tmp[0], tmp[2], tmp[1] - (a / b) * tmp[2]};
}
}
Matrix matrix_power(Matrix base, long long exp) {
int n = base.r;
Matrix res(n, n, true);
while (exp) {
if (exp & 1) {
res = res * base;
}
base = base * base;
exp >>= 1;
}
return res;
}
int n, m, s;
vector<vector<int>> edges(100010);
int visited[100010];
int dp[100010][2];
int pre[100010][2];
bool hasCycle(int cur) {
if (visited[cur] == -1) return true;
if (visited[cur] == 1) return false;
visited[cur] = -1;
for (int i : edges[cur]) {
if (hasCycle(i)) return true;
}
visited[cur] = 1;
return false;
}
void dfs(int cur, int i, int from) {
if (dp[cur][i]) return;
dp[cur][i] = 1;
pre[cur][i] = from;
for (int next : edges[cur]) {
dfs(next, i ^ 1, cur);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
int c;
for (int i = 1; i <= n; ++i) {
cin >> c;
int node;
for (int j = 0; j < c; ++j) {
cin >> node;
edges[i].push_back(node);
}
}
cin >> s;
bool has = hasCycle(s);
dfs(s, 0, 0);
for (int i = 1; i <= n; ++i) {
if (edges[i].empty() && dp[i][1]) {
cout << "Win" << endl;
vector<int> path;
int cur = i, odd = 1;
while (cur != s || odd) {
path.push_back(cur);
cur = pre[cur][odd];
odd ^= 1;
}
path.push_back(s);
for (int j = path.size() - 1; j >= 0; --j) {
cout << path[j] << " \n"[j == 0];
}
return 0;
}
}
if (has) {
cout << "Draw";
} else {
cout << "Lose";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long Max(long long a, long long b) { return a > b ? a : b; }
inline long long Min(long long a, long long b) { return a < b ? a : b; }
inline long long read() {
long long x = 0;
int ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') f = -1, ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
return x * f;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10)
write(x / 10), putchar(x % 10 + '0');
else
putchar(x + '0');
}
int n, m, cnt[100005], a[100005 * 10], b[100005][2];
int edge, to[200005], pr[200005], hd[100005];
inline void addedge(int u, int v) {
to[++edge] = v, pr[edge] = hd[u], hd[u] = edge;
}
inline void print(int k) {
printf("Win\n");
for (int i = (int)(1), i_E = (int)(k); i <= i_E; i++)
write(a[i]), putchar(' ');
exit(0);
}
inline void dfs(int dep, int u) {
if (!cnt[u] && (dep & 1)) print(dep - 1);
for (int i = hd[(u)]; i; i = pr[i]) {
int v = to[i];
if (b[v][dep & 1]) continue;
b[v][dep & 1] = 1, a[dep] = v, dfs(dep + 1, v);
}
}
int idx, dfn[100005], low[100005], vis[100005], top, sta[100005], sum;
inline void tarjan(int u) {
vis[sta[++top] = u] = 1, dfn[u] = low[u] = ++idx;
for (int i = hd[(u)]; i; i = pr[i]) {
int v = to[i];
if (!dfn[v])
tarjan(v), low[u] = Min(low[u], low[v]);
else if (vis[v])
low[u] = Min(low[u], dfn[v]);
}
if (dfn[u] == low[u]) {
int s = 0;
while (sta[top + 1] != u) vis[sta[top--]] = 0, s++;
sum = Max(sum, s);
}
}
int main() {
n = read(), m = read();
for (int i = (int)(1), i_E = (int)(n); i <= i_E; i++) {
cnt[i] = read();
for (int j = (int)(1), i_E = (int)(cnt[i]); j <= i_E; j++)
addedge(i, read());
}
a[1] = read();
dfs(2, a[1]);
sum = 0, tarjan(a[1]);
printf(sum > 1 ? "Draw" : "Lose");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<int> > g;
vector<vector<bool> > visited;
vector<int> path;
vector<bool> on_path;
int chip;
bool draw = false;
bool dfs(int node, int state) {
visited[node][state] = true;
on_path[node] = true;
path.push_back(node);
for (auto neighbor : g[node]) {
if (g[neighbor].size() == 0 && state == 0) {
path.push_back(neighbor);
return true;
}
if (on_path[neighbor]) {
draw = true;
}
if (!visited[neighbor][1 - state]) {
if (dfs(neighbor, 1 - state)) {
return true;
}
}
}
on_path[node] = false;
path.pop_back();
return false;
}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
cin >> n >> m;
g.resize(n + 1);
visited.resize(n + 1);
on_path.resize(n + 1);
for (int i = 1; i <= n; ++i) {
visited[i].push_back(false);
visited[i].push_back(false);
}
for (int i = 1; i <= n; ++i) {
int a;
cin >> a;
g[i].resize(a);
int b;
for (int j = 0; j < a; ++j) {
cin >> b;
g[i][j] = b;
}
}
cin >> chip;
if (dfs(chip, 0)) {
cout << "Win" << endl;
for (int i = 0; i < path.size(); ++i) {
if (i) {
cout << " ";
}
cout << path[i];
}
cout << endl;
} else {
if (draw) {
cout << "Draw" << endl;
} else {
cout << "Lose" << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m, size;
struct edg {
int to, next;
} e[2 * N], G[2 * N];
int x, y, num, head[N], dfn[N], low[N], vis[N], du[N], cnt, chu[N], size2;
int f[N][2], pre[N][2], fa[N], st[N], h, tot, S, head2[N];
pair<int, int> q[10 * N];
int he, ta, p[N];
bool used[N][2], dra;
void add(int x, int y) {
size++;
e[size].to = y;
e[size].next = head[x];
head[x] = size;
size2++;
G[size2].to = x;
G[size2].next = head2[y];
head2[y] = size2;
}
void dfs(int x) {
cnt++;
dfn[x] = low[x] = cnt;
st[++h] = x;
vis[x] = 1;
for (int i = head2[x]; i; i = G[i].next) {
int y = G[i].to;
if (vis[y] == 0)
dfs(y), low[x] = min(low[x], low[y]);
else if (vis[y] == 1)
low[x] = min(low[x], dfn[y]);
}
if (low[x] == dfn[x]) {
tot++;
while (st[h] != x) vis[st[h]] = 2, fa[st[h]] = tot, p[tot]++, h--;
vis[st[h]] = 2, fa[st[h]] = tot, p[tot]++, h--;
if (p[tot] > 1) dra = 1;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &num);
for (int j = 1; j <= num; j++) scanf("%d", &x), add(x, i), du[i]++;
}
scanf("%d", &S);
dfs(S);
for (int i = 1; i <= n; i++)
if (vis[i] && du[i] == 0) f[i][0] = 1, q[++ta] = make_pair(i, 0);
while (he < ta) {
int x = q[++he].first, nw = q[he].second;
for (int i = head[x]; i; i = e[i].next) {
int y = e[i].to;
if (!f[y][nw ^ 1])
pre[y][nw ^ 1] = x, f[y][nw ^ 1] = 1, q[++ta] = make_pair(y, nw ^ 1);
if (f[S][1]) break;
}
}
if (f[S][1]) {
printf("Win\n");
int nw = 1;
while (S) {
printf("%d ", S);
S = pre[S][nw];
nw ^= 1;
}
return 0;
}
if (f[S][0] && !dra)
printf("Lose");
else
printf("Draw");
}
|
#include <bits/stdc++.h>
using namespace std;
const long long max3 = 1003;
const long long max4 = 10004;
const long long max5 = 100005;
const long long max6 = 1000006;
const long long max7 = 10000007;
const long long lg4 = 13;
const long long lg5 = 17;
const long long lg6 = 20;
const long long INF = 2LL * 1000000000;
const long long INFLL = 9LL * 1000000000 * 1000000000;
const long long M = 1e9 + 7;
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
}
return res;
}
long long gcd(long long a, long long b) {
while (b > 0) {
long long t = a % b;
a = b, b = t;
}
return a;
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
long long is_prime(long long n) {
if (n <= 1 || n > 3 && (n % 2 == 0 || n % 3 == 0)) return 0;
for (long long i = 5, t = 2; i * i <= n; i += t, t = 6 - t)
if (n % i == 0) return 0;
return 1;
}
vector<vector<long long> > adj(max5);
int reachable[max5][2];
int parent[max5][2];
int n, m, s;
void dfs(int u, int x) {
reachable[u][x] = 1;
for (int v : adj[u]) {
if (reachable[v][x ^ 1] == 0) {
parent[v][x ^ 1] = u;
dfs(v, x ^ 1);
}
}
}
int vis[max5];
bool dfsCycle(int u) {
vis[u] = 1;
for (int v : adj[u]) {
if (vis[v] == 1)
return true;
else if (vis[v] == 0 && dfsCycle(v))
return true;
}
vis[u] = 2;
return false;
}
vector<long long> getPath(int u, int x) {
vector<long long> temp;
while (1) {
temp.push_back(u);
u = parent[u][x];
x ^= 1;
if (u == -1) break;
}
reverse((temp).begin(), (temp).end());
return temp;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
memset(parent, -1, sizeof(parent));
cin >> n >> m;
for (int u = 1; u <= n; u++) {
int cnt;
cin >> cnt;
while (cnt--) {
int v;
cin >> v;
adj[u].push_back(v);
}
}
cin >> s;
dfs(s, 0);
for (int u = 1; u <= n; u++) {
if ((int)adj[u].size() == 0 && reachable[u][1]) {
cout << "Win"
<< "\n";
vector<long long> path = getPath(u, 1);
for (int v : path) cout << v << " ";
return 0;
}
}
if (dfsCycle(s))
cout << "Draw"
<< "\n";
else
cout << "Lose"
<< "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long win = 0;
vector<long long> g[100009], us, p;
void dfs(long long v, long long l) {
if (us[v] == 0) {
us[v] = 1;
} else {
us[v] = 2;
}
if (g[v].size() == 0 && l < 1000000 && l % 2 == 1) {
win = 1;
p.push_back(v);
return;
}
for (long long i = 0; i < g[v].size(); i++) {
long long to = g[v][i];
if (us[to] != 2) {
dfs(to, l + 1);
if (win == 1) {
p.push_back(v);
return;
}
}
}
}
bool ccl(long long v) {
us[v] = 1;
for (long long i = 0; i < g[v].size(); i++) {
long long to = g[v][i];
if (us[to] == 1) {
return true;
} else if (us[to] == 0) {
if (ccl(to) == true) {
return true;
}
}
}
us[v] = 2;
return false;
}
int main() {
ios::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
long long k;
cin >> k;
for (long long j = 0; j < k; j++) {
long long a;
cin >> a;
g[i].push_back(a - 1);
}
}
long long s;
cin >> s;
s--;
us = vector<long long>(n, 0);
p.reserve(100009);
dfs(s, 0);
if (win == 1) {
cout << "Win\n";
for (long long i = p.size() - 1; i >= 0; i--) {
cout << p[i] + 1 << " ";
}
return 0;
}
us = vector<long long>(n, 0);
if (ccl(s)) {
cout << "Draw";
} else {
cout << "Lose";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(time(0));
const long long inf = 0x3f3f3f3f3f3f3f3fLL;
const long long N = 1e5 + 10;
const long long MOD = 1e9 + 7;
long long n, m, s;
vector<vector<long long>> g(N);
bool vis[N][2];
long long par[N][2], mark[N];
void dfs(long long u, long long f) {
vis[u][f] = 1;
for (auto i : g[u]) {
if (!vis[i][f ^ 1]) {
par[i][f ^ 1] = u;
dfs(i, f ^ 1);
}
}
}
bool cyc(long long u) {
mark[u] = 1;
for (auto i : g[u]) {
if (mark[i] == 1) return true;
if (mark[i] == 0 && cyc(i)) return true;
}
mark[u] = 2;
return false;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
long long sz, x;
for (long long i = 1; i <= n; i++) {
cin >> sz;
for (long long j = 0; j < sz; j++) {
cin >> x;
g[i].push_back(x);
}
}
cin >> s;
dfs(s, 0);
for (long long i = 1; i <= n; i++) {
if ((long long)g[i].size() == 0 && vis[i][1]) {
vector<long long> res;
long long node = i, f = 1;
res.push_back(node);
while (node != s || f != 0) {
node = par[node][f];
f ^= 1;
res.push_back(node);
}
reverse(res.begin(), res.end());
cout << "Win" << '\n';
for (auto i : res) cout << i << ' ';
cout << '\n';
return 0;
}
}
if (cyc(s))
cout << "Draw" << '\n';
else
cout << "Lose" << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int s;
pair<int, int> vis[100001];
int vis2[100001];
vector<int> a[100001];
vector<int> cycle_points;
bool winner = false;
pair<int, int> par[100001];
unordered_map<int, bool> bolo;
stack<int> trace;
bool visited[100001];
bool recStack[100001];
class Graph {
int V;
list<int> *adj;
bool isCyclicUtil(int v);
public:
Graph(int V);
void addEdge(int v, int w);
bool isCyclic();
};
Graph::Graph(int V) {
this->V = V;
adj = new list<int>[V];
}
void Graph::addEdge(int v, int w) { adj[v].push_back(w); }
bool Graph::isCyclicUtil(int v) {
if (visited[v] == false) {
visited[v] = true;
recStack[v] = true;
list<int>::iterator i;
for (i = adj[v].begin(); i != adj[v].end(); ++i) {
if (!visited[*i] && isCyclicUtil(*i))
return true;
else if (recStack[*i])
return true;
}
}
recStack[v] = false;
return false;
}
bool Graph::isCyclic() {
for (int i = 0; i < V; i++) {
visited[i] = false;
recStack[i] = false;
}
for (int i = 0; i < V; i++)
if (isCyclicUtil(i)) return true;
return false;
}
int i = 1;
queue<int> qu;
void dfs(int x) {
qu.push(x);
while (!qu.empty()) {
int x = qu.front();
qu.pop();
if (a[x].size() == 0) {
bolo[x] = true;
}
for (int k = 0; k < a[x].size(); k++) {
if (vis2[a[x][k]] == 0) {
vis2[a[x][k]] = 1;
qu.push(a[x][k]);
}
}
}
}
bool shav = false;
void w(int x, short col) {
for (int k = 0; k < a[x].size(); k++) {
if (shav) return;
if (col == 1) {
if (vis[a[x][k]].second == 0) {
vis[a[x][k]].second = 1;
par[a[x][k]].second = x;
if (a[a[x][k]].size() == 0) {
shav = true;
int la = a[x][k];
int c = 2;
winner = true;
while (1) {
trace.push(la);
if (c == 1) {
la = par[la].first;
c = 2;
} else {
c = 1;
la = par[la].second;
}
if (la == s && c == 1) {
trace.push(s);
return;
}
}
}
w(a[x][k], 2);
}
} else {
if (vis[a[x][k]].first == 0) {
par[a[x][k]].first = x;
vis[a[x][k]].first = 1;
w(a[x][k], 1);
}
}
}
}
Graph g(100001);
void q(int x) {
for (int k = 0; k < a[x].size(); k++) {
if (vis2[a[x][k]] == 0) {
vis2[a[x][k]] = 1;
g.addEdge(x, a[x][k]);
q(a[x][k]);
} else {
g.addEdge(x, a[x][k]);
}
}
}
int main() {
int n, m;
cin >> n >> m;
int x;
int p;
for (int k = 0; k < n; k++) {
cin >> x;
for (int j = 0; j < x; j++) {
cin >> p;
a[k + 1].push_back(p);
}
};
cin >> s;
vis2[s] = 1;
dfs(s);
vis[s].first = 1;
w(s, 1);
memset(vis2, 0, (n + 1) * sizeof(int));
vis2[s] = 1;
q(s);
if (winner) {
cout << "Win" << endl;
while (!trace.empty()) {
cout << trace.top() << " ";
trace.pop();
}
return 0;
}
if (g.isCyclic()) {
cout << "Draw";
return 0;
}
cout << "Lose";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000;
int n, m, sz[maxn + 5], s;
int d[maxn + 5][2], vis[maxn + 5], pre[maxn + 5][2], ring;
vector<int> g[maxn + 5], path;
void dfs(int x, int t, int f) {
if (d[x][t]) return;
d[x][t] = 1;
pre[x][t] = f;
int len = g[x].size();
for (int i = 0; i < len; i++) {
int y = g[x][i];
dfs(y, t ^ 1, x);
}
}
void DFS(int x, int t) {
if (d[x][t]) return;
d[x][t] = 1;
int len = g[x].size();
for (int i = 0; i < len; i++) {
int y = g[x][i];
if (!d[y][t ^ 1]) {
pre[y][t ^ 1] = x;
DFS(y, t ^ 1);
}
}
}
bool Ring(int x) {
if (vis[x] == -1) return true;
int len = g[x].size();
vis[x] = -1;
for (int i = 0; i < len; i++) {
int y = g[x][i];
if (vis[y] != 1 && Ring(y)) return true;
}
vis[x] = 1;
return false;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &sz[i]);
for (int j = 1, x; j <= sz[i]; j++) scanf("%d", &x), g[i].push_back(x);
}
scanf("%d", &s);
DFS(s, 0);
pre[s][0] = 0;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (d[i][1] && sz[i] == 0) {
int f = i, t = 1;
path.push_back(f);
while (pre[f][t]) {
path.push_back(pre[f][t]);
f = pre[f][t];
t ^= 1;
}
printf("Win\n");
for (int j = path.size() - 1; j >= 0; j--) printf("%d ", path[j]);
ans = 1;
break;
}
}
if (Ring(s)) ring = 1;
if (!ans && ring) printf("Draw\n");
if (!ans && !ring) printf("Lose\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = (((1 << 30) - 1) << 1) + 1;
const int nINF = 1 << 31;
int n, m, s;
vector<bool> cycPart, vis, vis0, good;
vector<vector<int>> g, tlg;
vector<int> ans;
int getTlgIdx(int v, int par) { return v + n * par; }
int getOrig(int v) { return v <= n ? v : v - n; }
bool dfs(int src) {
if (good[src]) {
ans.push_back(getOrig(src));
return true;
}
vis0[src] = 1;
for (int v : tlg[src]) {
if (!vis0[v] && dfs(v)) {
ans.push_back(getOrig(src));
return true;
}
}
return false;
}
bool cycDfs(int src) {
if (cycPart[src]) return true;
vis[src] = 1;
for (int v : g[src]) {
if (!vis[v] && cycDfs(v)) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
vector<vector<int>> rg(n + 1);
g.resize(n + 1), tlg.resize(1 + 2 * n);
vector<int> deg(n + 1, 0);
vis.resize(1 + n, 0);
vis0.resize(1 + n + n, 0);
good.resize(1 + n + n, 0);
queue<int> next;
for (int i = (1); i <= (n); i++) {
int c;
cin >> c;
deg[i] = c;
if (c == 0) {
next.push(i);
good[getTlgIdx(i, 1)] = 1;
}
for (int j = 0; j < (c); j++) {
int e;
cin >> e;
g[i].push_back(e);
rg[e].push_back(i);
tlg[getTlgIdx(i, 0)].push_back(getTlgIdx(e, 1));
tlg[getTlgIdx(i, 1)].push_back(getTlgIdx(e, 0));
}
}
cin >> s;
if (dfs(getTlgIdx(s, 0))) {
cout << "Win" << endl;
reverse(ans.begin(), ans.end());
for (int v : ans) cout << v << ' ';
cout << endl;
exit(0);
}
cycPart.resize(n + 1, 1);
while (!next.empty()) {
int cur = next.front();
next.pop();
cycPart[cur] = false;
for (int v : rg[cur]) {
--deg[v];
if (deg[v] == 0) next.push(v);
}
}
cout << (cycDfs(s) ? "Draw" : "Lose") << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m, v, u = numeric_limits<int>::max(), d[N], marK[N];
bool mark[2][N], cycle, done[N];
vector<int> nei[N], answer;
void dfs(int v, int a) {
mark[a][v] = true;
for (int i = 0; i < nei[v].size(); i++) {
int w = nei[v][i];
if (!mark[!a][w]) dfs(w, !a);
if (u != numeric_limits<int>::max() && mark[1][u]) break;
}
if (u != numeric_limits<int>::max() && mark[1][u]) answer.push_back(v);
}
void dfs_2(int u) {
done[u] = true;
mark[0][u] = true;
for (int i = 0; i < nei[u].size(); i++) {
int w = nei[u][i];
if (!done[w])
dfs_2(w);
else
cycle = true;
if (cycle) break;
}
done[u] = false;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> d[i];
for (int j = 0; j < d[i]; j++) {
cin >> v;
v--;
nei[i].push_back(v);
}
}
cin >> v;
v--;
dfs(v, 0);
for (int i = 0; i < n; i++) {
if (i == v) continue;
if (!d[i] && mark[1][i]) {
u = i;
break;
}
}
memset(mark, false, sizeof(mark));
if (u != numeric_limits<int>::max()) {
dfs(v, 0);
cout << "Win\n";
for (int i = answer.size() - 1; i >= 0; i--) cout << answer[i] + 1 << ' ';
} else {
dfs_2(v);
if (cycle)
cout << "Draw";
else
cout << "Lose";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int maxx = 3e5;
const int inf = 0x3f3f3f3f;
const long long linf = 1e9;
const long long mod = 1e9 + 7;
int n, m, k;
struct EDGE {
int v, nxt;
} edge[2 * maxn];
int tot, head[maxn], out[maxn], vis[maxn][2], flag[maxn], ff;
void init() {
tot = 0, ff = 0;
memset(head, -1, sizeof(head));
memset(out, 0, sizeof(out));
memset(vis, 0, sizeof(vis));
memset(flag, 0, sizeof(flag));
}
void addEdge(int u, int v) {
edge[tot].v = v, edge[tot].nxt = head[u], head[u] = tot++;
}
void dfs(int u) {
flag[u] = 1;
for (int i = head[u]; i != -1; i = edge[i].nxt) {
int v = edge[i].v;
if (flag[v] == 1) {
ff = 1;
return;
} else if (flag[v] == 0)
dfs(v);
}
flag[u] = 2;
}
void bfs(int u) {
vis[u][0] = 0;
queue<pair<int, int> > q;
q.push(make_pair(u, 0));
while (q.empty() == 0) {
pair<int, int> now = q.front();
q.pop();
for (int i = head[now.first]; i != -1; i = edge[i].nxt) {
int v = edge[i].v;
int tmp = now.second ^ 1;
if (vis[v][tmp] == 0) {
vis[v][tmp] = now.first;
q.push(make_pair(v, tmp));
}
}
}
}
void print(int pre, int x) {
if (!(pre == k && x == 0)) print(vis[pre][x], x ^ 1);
cout << pre << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
init();
int cnt, a;
for (int i = 1; i <= n; i++) {
cin >> cnt;
out[i] = cnt;
while (cnt--) {
cin >> a;
addEdge(i, a);
}
}
cin >> k;
bfs(k);
for (int i = 1; i <= n; i++) {
if (out[i] == 0) {
if (vis[i][1]) {
cout << "Win" << endl;
print(vis[i][1], 0);
cout << i << endl;
return 0;
}
}
}
dfs(k);
if (ff)
cout << "Draw" << endl;
else
cout << "Lose" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int memo[MAXN][2], nxt[MAXN][2];
bool vis[MAXN][2], cycle = false;
vector<int> adj[MAXN];
bool dp(int u, bool turnoA) {
if (int((adj[u]).size()) == 0) return !turnoA;
int &res = memo[u][turnoA];
if (res != -1)
return res;
else if (vis[u][turnoA]) {
cycle = true;
return false;
}
vis[u][turnoA] = true;
for (int v : adj[u]) {
if (dp(v, !turnoA)) {
nxt[u][turnoA] = v;
return res = true;
}
}
return res = false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int u = 0; u < int(n); u++) {
int c;
cin >> c;
for (int _ = 0; _ < int(c); _++) {
int v;
cin >> v;
v--;
adj[u].push_back(v);
}
}
int s;
cin >> s;
s--;
fill(memo[0], memo[MAXN], -1);
fill(vis[0], vis[MAXN], false);
fill(nxt[0], nxt[MAXN], -1);
if (dp(s, true)) {
cout << "Win" << '\n';
int u = s;
bool t = true;
string sep = "";
do {
cout << sep << u + 1;
sep = " ";
u = nxt[u][t];
t = !t;
} while (u != -1);
cout << '\n';
} else if (cycle)
cout << "Draw" << '\n';
else
cout << "Lose" << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int maxx = 3e5;
const int inf = 0x3f3f3f3f;
const long long linf = 1e9;
const long long mod = 1e9 + 7;
int n, m, k;
struct EDGE {
int v, nxt;
} edge[2 * maxn];
int tot, head[maxn], out[maxn], vis[maxn][2], flag[maxn], ff;
void init() {
tot = 0, ff = 0;
memset(head, -1, sizeof(head));
memset(out, 0, sizeof(out));
memset(vis, 0, sizeof(vis));
memset(flag, 0, sizeof(flag));
}
void addEdge(int u, int v) {
edge[tot].v = v, edge[tot].nxt = head[u], head[u] = tot++;
}
void dfs(int u) {
flag[u] = 1;
for (int i = head[u]; i != -1; i = edge[i].nxt) {
int v = edge[i].v;
if (flag[v] == 1) {
ff = 1;
return;
} else if (flag[v] == 0)
dfs(v);
}
flag[u] = 2;
}
void bfs(int u) {
vis[u][0] = -1;
queue<pair<int, int> > q;
q.push(make_pair(u, 0));
while (q.empty() == 0) {
pair<int, int> now = q.front();
q.pop();
for (int i = head[now.first]; i != -1; i = edge[i].nxt) {
int v = edge[i].v;
int tmp = now.second ^ 1;
if (vis[v][tmp] == 0) {
vis[v][tmp] = now.first;
q.push(make_pair(v, tmp));
}
}
}
}
void print(int pre, int x) {
if (vis[pre][x ^ 1] != -1) print(vis[pre][x ^ 1], x ^ 1);
cout << pre << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
init();
int cnt, a;
for (int i = 1; i <= n; i++) {
cin >> cnt;
out[i] = cnt;
while (cnt--) {
cin >> a;
addEdge(i, a);
}
}
cin >> k;
bfs(k);
for (int i = 1; i <= n; i++) {
if (out[i] == 0) {
if (vis[i][1]) {
cout << "Win" << endl;
print(vis[i][1], 1);
cout << i << endl;
return 0;
}
}
}
dfs(k);
if (ff)
cout << "Draw" << endl;
else
cout << "Lose" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000;
int n, m, sz[maxn + 5], s;
int d[maxn + 5][2], vis[maxn + 5], pre[maxn + 5][2], ring;
vector<int> g[maxn + 5], path;
void dfs(int x, int t, int f) {
if (d[x][t]) return;
d[x][t] = 1;
pre[x][t] = f;
int len = g[x].size();
for (int i = 0; i < len; i++) {
int y = g[x][i];
dfs(y, t ^ 1, x);
}
}
void DFS(int x, int t) {
if (d[x][t]) return;
d[x][t] = 1;
int len = g[x].size();
for (int i = 0; i < len; i++) {
int y = g[x][i];
if (!d[y][t ^ 1]) {
pre[y][t ^ 1] = x;
DFS(y, t ^ 1);
}
}
}
bool Ring(int x) {
if (vis[x] == -1) return true;
int len = g[x].size();
vis[x] = -1;
for (int i = 0; i < len; i++) {
int y = g[x][i];
if (vis[y] != 1 && Ring(y)) return true;
}
vis[x] = 1;
return false;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &sz[i]);
for (int j = 1, x; j <= sz[i]; j++) scanf("%d", &x), g[i].push_back(x);
}
scanf("%d", &s);
dfs(s, 0, 0);
int ans = 0;
for (int i = 1; i <= n; i++) {
if (d[i][1] && sz[i] == 0) {
int f = i, t = 1;
path.push_back(f);
while (pre[f][t]) {
path.push_back(pre[f][t]);
f = pre[f][t];
t ^= 1;
}
printf("Win\n");
for (int j = path.size() - 1; j >= 0; j--) printf("%d ", path[j]);
ans = 1;
break;
}
}
if (Ring(s)) ring = 1;
if (!ans && ring) printf("Draw\n");
if (!ans && !ring) printf("Lose\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[200005];
int used[200005][2];
bool cycle = 0;
vector<int> curr;
void dfs(int temp, int parity) {
curr.push_back(temp);
used[temp][parity] = 1;
if (graph[temp].empty() && curr.size() % 2 == 0) {
cout << "Win\n";
for (auto x : curr) cout << x << " ";
exit(0);
}
for (auto x : graph[temp]) {
if (used[x][parity ^ 1] == 1) cycle = 1;
if (!used[x][parity ^ 1]) {
dfs(x, parity ^ 1);
}
}
curr.pop_back();
used[temp][parity] = 2;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int num;
cin >> num;
for (int j = 0; j < num; j++) {
int inp;
cin >> inp;
graph[i].push_back(inp);
}
}
int start;
cin >> start;
dfs(start, 0);
cout << (cycle ? "Draw" : "Lose");
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<int> g[N], vc;
int vis[N][2], pre[N][2], vs[N];
void dfs(int o, int u, int d) {
if (vis[u][d] == 1) return;
vis[u][d] = 1;
pre[u][d] = o;
for (int i = 0; i < g[u].size(); i++) {
dfs(u, g[u][i], d ^ 1);
}
}
bool hasloop(int u) {
vs[u] = 1;
bool f = false;
for (int i = 0; i < g[u].size(); i++) {
if (vs[g[u][i]] == 1)
f = true;
else if (vs[g[u][i]] == 0)
f = hasloop(g[u][i]);
if (f) return true;
}
vs[u] = 2;
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, t, u, s;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> t;
while (t--) {
cin >> u;
g[i].push_back(u);
}
}
cin >> s;
dfs(0, s, 0);
for (int i = 1; i <= n; i++) {
if (vis[i][1] && g[i].size() == 0) {
int u = i, t = 1;
vc.push_back(u);
while (pre[u][t] != 0) {
vc.push_back(pre[u][t]);
u = pre[u][t];
t ^= 1;
}
cout << "Win" << endl;
for (int j = vc.size() - 1; j >= 0; j--) cout << vc[j] << ' ';
cout << endl;
return 0;
}
}
if (hasloop(s))
cout << "Draw" << endl;
else
cout << "Lose" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<int> graph[N], path;
bool draw, win;
int pre[N][2], vis[N][2];
void dfs(int u, int p) {
if (win) return;
vis[u][p] = 1;
for (int to : graph[u]) {
int q = p ^ 1;
if (vis[to][q] == 1)
draw = true;
else if (!vis[to][q]) {
pre[to][q] = u;
dfs(to, q);
}
}
if (graph[u].size() == 0 && p) {
win = 1;
int end = u, endp = p;
while (end) {
path.push_back(end);
end = pre[end][endp], endp ^= 1;
}
} else
vis[u][p] = 2;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
int sz, u;
scanf("%d", &sz);
while (sz--) {
scanf("%d", &u);
graph[i].push_back(u);
}
}
int s;
scanf("%d", &s);
dfs(s, 0);
if (win) {
puts("Win");
for (int i = path.size() - 1; i >= 0; i--)
printf("%d%c", path[i], " \n"[!i]);
} else if (draw)
puts("Draw");
else
puts("Lose");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool tasa, on;
int n, m, c, a, s1, vesya[202020], petya[202020], v2[202020], p2[202020],
z[202020];
vector<int> vrk[202020], rvrk[202020], umpikujat;
deque<int> reitti;
void haku(int s, char cha) {
if (cha == 'v') {
if (vesya[s]) return;
vesya[s] = 1;
} else if (cha = 'p') {
if (petya[s]) return;
petya[s] = 1;
}
for (auto u : vrk[s]) {
if (cha == 'v')
haku(u, 'p');
else
haku(u, 'v');
}
}
void haku2(int s, char cha) {
if (cha == 'v') {
if (vesya[s] >= 3) {
tasa = true;
return;
}
vesya[s]++;
} else if (cha = 'p') {
if (petya[s] >= 3) {
tasa = true;
return;
}
petya[s]++;
}
for (auto u : vrk[s]) {
if (cha == 'v')
haku2(u, 'p');
else
haku2(u, 'v');
}
}
void haku3(int s, char cha) {
if (cha == 'v') {
if (v2[s]) return;
v2[s] = 1;
} else {
if (p2[s]) return;
p2[s] = 1;
}
if (s == s1 && cha == 'p') on = true;
if (on) return;
for (auto u : rvrk[s]) {
if (cha == 'v') {
reitti.push_front(u);
haku3(u, 'p');
if (on)
return;
else
reitti.pop_front();
} else {
reitti.push_front(u);
haku3(u, 'v');
if (on)
return;
else
reitti.pop_front();
}
}
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> c;
if (c == 0) umpikujat.push_back(i);
for (int j = 0; j < c; j++) {
cin >> a;
rvrk[a].push_back(i);
vrk[i].push_back(a);
}
}
cin >> s1;
if (vrk[s1].size() == 0) {
cout << "Lose";
exit(0);
}
haku(s1, 'p');
for (auto u : umpikujat) {
if (vesya[u]) {
cout << "Win"
<< "\n";
haku3(u, 'v');
while (!reitti.empty()) {
cout << reitti.front() << " ";
reitti.pop_front();
}
cout << u << " ";
exit(0);
}
}
haku2(s1, 'v');
if (tasa)
cout << "Draw";
else
cout << "Lose";
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 1e5 + 10;
const int INF = 0x3f3f3f3f;
const double PI = acos(-1.0);
vector<int> edge[maxn];
int n, s;
bool dp;
bool vis[maxn][2];
int ans[maxn], tot;
multiset<int> ss;
bool dfs(int u, int dis) {
if (ss.count(u)) dp = 1;
if (vis[u][dis]) return 0;
vis[u][dis] = 1;
ss.insert(u);
if (dis && edge[u].size() == 0) {
ans[tot++] = u;
return 1;
} else
for (int i = edge[u].size() - 1; i >= 0; i--) {
if (dfs(edge[u][i], dis ^ 1)) {
ans[tot++] = u;
return 1;
}
}
ss.erase(ss.find(u));
return 0;
}
int main() {
int m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
int c;
scanf("%d", &c);
while (c--) {
int v;
scanf("%d", &v);
edge[i].push_back(v);
}
}
scanf("%d", &s);
if (!dfs(s, 0)) {
if (dp)
printf("Draw");
else
printf("Lose");
} else {
printf("Win\n");
while (--tot) printf("%d ", ans[tot]);
printf("%d", ans[tot]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> g[200100], gr[200100];
int cnt[200100][2];
bool loose[200100][2], win[200100][2], used[200100][2];
pair<int, int> p[200100][2];
void dfs(int v, int t) {
used[v][t] = true;
for (int to : gr[v]) {
if (!used[to][t ^ 1]) {
if (t) {
if (loose[v][1])
win[to][0] = true;
else if (--cnt[to][0] == 0)
loose[to][0] = true;
else
continue;
p[to][0] = {v, t};
dfs(to, 0);
} else {
if (win[v][0])
loose[to][1] = true;
else if (--cnt[to][1] == 0)
win[to][1] = true;
else
continue;
p[to][1] = {v, t};
dfs(to, 1);
}
}
}
}
vector<int> answ;
void dfs_f(int v, int t) {
answ.push_back(v);
while (g[v].size()) {
pair<int, int> x = p[v][t];
v = x.first;
t = x.second;
answ.push_back(v);
}
}
int s;
bool fv[200100];
int main(void) {
scanf("%d %d", &n, &m);
for (register int i = 1; i <= n; ++i) {
int c = 0, v = -1;
scanf("%d", &c);
if (!c) fv[i] = true;
while (c--) {
scanf("%d", &v);
g[i].push_back(v);
gr[v].push_back(i);
++cnt[i][0];
++cnt[i][1];
}
}
for (register int i = 1; i <= n; ++i) {
if (fv[i]) {
loose[i][0] = true;
dfs(i, 0);
loose[i][1] = true;
dfs(i, 1);
}
}
scanf("%d", &s);
if (win[s][0]) {
puts("Win");
dfs_f(s, 0);
for (int to : answ) printf("%d ", to);
putc('\n', stdout);
} else if (loose[s][0])
puts("Lose");
else
puts("Draw");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000111;
int odw[maxn], n, m, x, vrt, c, b, ok[maxn][2];
vector<int> v[maxn], vo[maxn];
stack<int> s;
void dfs(int u, int win) {
ok[u][win] = 1;
s.push(u);
if (u == vrt && win == 1) {
printf("Win\n");
while (!s.empty()) {
printf("%d ", s.top());
s.pop();
}
printf("\n");
exit(0);
}
for (auto i : vo[u])
if (!ok[i][win ^ 1]) dfs(i, win ^ 1);
s.pop();
}
void cykl_parz(int u) {
odw[u] = 1;
for (auto i : v[u]) {
if (odw[i] == 1) {
printf("Draw\n");
exit(0);
} else if (odw[i] == 0) {
cykl_parz(i);
}
}
odw[u] = 2;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &c);
for (int j = 1; j <= c; j++) {
scanf("%d", &b);
v[i].push_back(b);
vo[b].push_back(i);
}
}
scanf("%d", &vrt);
for (int i = 1; i <= n; i++)
if (v[i].size() == 0) dfs(i, 0);
cykl_parz(vrt);
printf("Lose\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct {
int x;
int t;
} Res;
Res now, temp;
vector<int> G[100005];
int ok, vis[100005][2], out[100005], flag[100005];
queue<Res> q;
void Print(int x, int y) {
if (vis[x][y] != -1) Print(vis[x][y], y ^ 1);
printf("%d ", x);
}
void Sech(int x) {
int i, v;
flag[x] = 1;
for (i = 0; i < G[x].size(); i++) {
v = G[x][i];
if (flag[v] == 1)
ok = 1;
else if (flag[v] == 0)
Sech(v);
}
flag[x] = 2;
}
int main(void) {
int n, m, i, k, x;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &x);
out[i] = x;
while (x--) {
scanf("%d", &k);
G[i].push_back(k);
}
}
scanf("%d", &k);
vis[k][0] = -1;
now.x = k, now.t = 0;
q.push(now);
while (q.empty() == 0) {
now = q.front();
q.pop();
for (i = 0; i < G[now.x].size(); i++) {
temp.x = G[now.x][i];
temp.t = now.t ^ 1;
if (vis[temp.x][temp.t] == 0) {
vis[temp.x][temp.t] = now.x;
q.push(temp);
}
}
}
for (i = 1; i <= n; i++) {
if (out[i] == 0) {
if (vis[i][1]) {
printf("Win\n");
Print(i, 1);
puts("");
return 0;
}
}
}
Sech(k);
if (ok)
printf("Draw\n");
else
printf("Lose\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const bound = 1e6 + 2, N = 2e5 + 1;
long long OO = 1e18;
double eps = 1e-6;
int oo = 1e9, mod = 1e9 + 7;
int n, m, s, app[N][2];
pair<int, int> par[N][2];
vector<int> adj[N], rev[N];
queue<pair<int, int> > q;
int vis[N];
void buildpath() {
puts("Win");
int cur = s, c = 1;
while (cur != -1) {
printf("%d ", cur);
pair<int, int> ne = par[cur][c];
cur = ne.first;
c = ne.second;
}
}
bool cyc(int u) {
vis[u] = 2;
for (auto v : rev[u]) {
if (vis[v] == 2) return 1;
if (!vis[v] && cyc(v)) return 1;
}
vis[u] = 1;
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int(i) = 1; (i) <= (n); (i)++) {
int sz;
scanf("%d", &sz);
if (!sz) {
q.push({i, 0});
app[i][0] = 1;
par[i][0] = {-1, -1};
}
while (sz--) {
int a;
scanf("%d", &a);
adj[a].push_back(i);
rev[i].push_back(a);
}
}
scanf("%d", &s);
while (!q.empty()) {
pair<int, int> cur = q.front();
q.pop();
for (auto v : adj[cur.first]) {
int cost = cur.second + 1;
int md = cost % 2;
if (app[v][md]) continue;
app[v][md] = 1;
par[v][md] = {cur.first, cur.second};
if (v == s && md) {
buildpath();
return 0;
}
q.push({v, cost % 2});
}
}
if (cyc(s)) {
puts("Draw");
return 0;
}
puts("Lose");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct s {
int to, next;
} edge[2 * 200005];
int head[200005];
int tot;
void add(int x, int y) {
edge[tot].to = y;
edge[tot].next = head[x];
head[x] = tot++;
}
int f[200005][3], id[200005][3], ff[200005 * 2], cnt;
bool dfs(int x, int sum) {
if (f[x][sum]) return false;
f[x][sum] = 1;
ff[cnt++] = x;
if (head[x] == -1 && sum == 0) return true;
for (int i = head[x]; i != -1; i = edge[i].next) {
int z = edge[i].to;
if (dfs(z, sum ^ 1)) return true;
}
cnt--;
return false;
}
int vis[200005];
bool check(int x) {
vis[x] = 1;
bool flag = false;
for (int i = head[x]; i != -1; i = edge[i].next) {
int z = edge[i].to;
if (vis[z] == 1)
flag = true;
else if (vis[z] == 0)
flag = check(z);
if (flag) return true;
}
vis[x] = 2;
return false;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
memset(head, -1, sizeof(head));
tot = 0;
int x, k;
for (int i = 1; i <= n; ++i) {
scanf("%d", &k);
for (int j = 1; j <= k; ++j) {
scanf("%d", &x);
add(i, x);
}
}
scanf("%d", &x);
cnt = 0;
if (dfs(x, 1)) {
printf("Win\n");
for (int i = 0; i <= cnt - 1; ++i)
printf("%d%c", ff[i], i == cnt - 1 ? '\n' : ' ');
} else if (check(x))
printf("Draw\n");
else
printf("Lose\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, v, s;
vector<int> g[100005];
int vis[100005][3], win[100005], lose[100005], ti[100005];
int wp[100005], lp[100005], tp[100005];
void f(int u, int con) {
vis[u][con] = 1;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i], c = !con;
if (vis[v][c] == 0) f(v, c);
if (lose[v]) {
win[u] = 1;
wp[u] = v;
}
if (win[v]) {
lose[u] = 1;
lp[u] = v;
}
if (ti[v]) {
ti[u] = 1;
tp[u] = 0;
}
if (vis[v][c] == 1) {
ti[u] = 1;
tp[u] = 0;
}
}
vis[u][con] = 2;
return;
}
void path(int u, int in) {
if (!u) {
printf("\n");
return;
}
if (in) printf(" ");
printf("%d", u);
if (in & 1)
path(lp[u], in + 1);
else
path(wp[u], in + 1);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
for (int j = 0; j < x; j++) {
scanf("%d", &v);
g[i].push_back(v);
}
}
for (int i = 1; i <= n; i++)
if (g[i].size() == 0) vis[i][0] = vis[i][1] = 2, lose[i] = 1;
scanf("%d", &s);
if (!vis[s][0]) f(s, 0);
if (win[s]) {
printf("Win\n");
path(s, 0);
} else if (ti[s]) {
printf("Draw\n");
} else {
printf("Lose\n");
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.