solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long N = 200010;
long long tr1[N], tr2[N];
long long n;
long long c[N];
long long lowbit(long long x) { return x & -x; }
void ud(long long tr[], long long x, long long d) {
for (long long i = x; i <= n; i += lowbit(i)) {
tr[i] += d;
}
}
long long qur(long long tr[], long long x) {
long long ans = 0;
for (long long i = x; i; i -= lowbit(i)) {
ans += tr[i];
}
return ans;
}
long long get_pos(long long tr[], long long x) {
long long l = 0, r = n;
while (l < r) {
long long mid = (l + r) >> 1;
if (qur(tr, mid) >= x)
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
c[x] = i;
}
long long d = 0;
for (long long i = 1; i <= n; i++) {
ud(tr1, c[i], 1);
ud(tr2, c[i], c[i]);
d += (i - qur(tr1, c[i]));
long long pos = get_pos(tr1, (i + 1) / 2);
long long aa = (i - 1) / 2;
long long bb = i / 2;
long long t1 = (long long)aa * pos - (1 + aa) * aa / 2;
long long t2 = (1ll + bb) * bb / 2 + bb * pos;
long long q1 = qur(tr2, pos - 1);
long long q2 = qur(tr2, n) - qur(tr2, pos);
long long ans = q2 - t2 + t1 - q1;
cout << (ans + d) << ' ';
}
}
| 11 | CPP |
#include <bits/stdc++.h>
const int maxn = 2e5 + 10;
const int maxm = 1e5 + 10;
const long long int mod = 1e9 + 7;
const long long int INF = 1e18 + 100;
const int inf = 0x3f3f3f3f;
const double pi = acos(-1.0);
const double eps = 1e-8;
using namespace std;
int n, m;
int cas, tol, T;
set<int> st;
int a[maxn], p[maxn];
long long int sum[maxn];
void update(int x) {
for (int i = x; i; i -= i & (-i)) sum[i]++;
}
long long int query(int x) {
if (x == 0) return 0;
int ans = 0;
for (int i = x; i <= n; i += i & (-i)) ans += sum[i];
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), p[a[i]] = i;
long long int ans = 0, k = 0;
printf("0 ");
update(p[1]);
st.insert(p[1]);
auto it = st.begin();
for (int i = 2; i <= n; i++) {
ans -= min(query(p[i] + 1), i - 1 - query(p[i] + 1));
ans += query(p[i] + 1);
update(p[i]), st.insert(p[i]);
if (i % 2 == 0 && p[i] < (*it)) ans += abs((*it) - (*(--it))) - 1;
if (i % 2 == 1 && p[i] > (*it)) it++;
if (p[i] > (*it))
ans += p[i] - (*it) + 1 - query((*it)) + query(p[i] + 1);
else
ans += (*it) - p[i] + 1 - query(p[i]) + query((*it) + 1);
printf("%lld ", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double Pi = acos(-1);
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
double dpow(double a, long long b) {
double ans = 1.0;
while (b) {
if (b % 2) ans = ans * a;
a = a * a;
b /= 2;
}
return ans;
}
long long quick_pow(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) {
ans = ans * x % mod;
}
x = x * x % mod;
y >>= 1;
}
return ans;
}
int n;
int a[maxn], c[maxn];
int lowbit(int x) { return x & (-x); }
long long bit1[maxn], bit2[maxn];
void add(long long *bit, int pos, int val) {
while (pos < maxn) {
bit[pos] += val;
pos += lowbit(pos);
}
}
long long query(long long *bit, int pos) {
long long ans = 0;
while (pos) {
ans += bit[pos];
pos -= lowbit(pos);
}
return ans;
}
int bs(long long *bit, int val) {
int i = 0;
for (int j = 19; j >= 0; j--) {
if ((i | 1 << j) < maxn) {
if (bit[i | 1 << j] <= val) {
val -= bit[i |= 1 << j];
}
}
}
return i;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
c[a[i]] = i;
}
long long cnt = 0;
for (int i = 1; i <= n; i++) {
int p = c[i];
add(bit1, p, 1);
cnt += i - query(bit1, p);
add(bit2, p, p);
int pos = bs(bit1, i / 2) + 1;
long long sum = 0;
long long aa = i / 2;
long long bb = i - i / 2 - 1;
sum += (long long)aa * pos - (long long)aa * (aa + 1) / 2 -
query(bit2, pos - 1);
sum += (query(bit2, maxn) - query(bit2, pos)) - (long long)bb * pos -
(long long)bb * (bb + 1) / 2;
printf("%lld\n", sum + cnt);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int n, k;
char s[maxn];
int pre[maxn << 1], sz[maxn << 1];
vector<int> op[maxn];
int find(int x) { return x == pre[x] ? x : pre[x] = find(pre[x]); }
void merge(int x, int y) {
int fx = find(x), fy = find(y);
if (fy == 0) swap(fx, fy);
if (fx != fy) pre[fy] = fx, sz[fx] += sz[fy];
}
int cal(int x) {
int y = (x <= k) ? x + k : x - k;
int fx = find(x), fy = find(y);
if (fx == 0 || fy == 0) return sz[fx + fy];
return min(sz[fx], sz[fy]);
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
for (int i = 1; i <= k; i++) pre[i] = i, pre[i + k] = i + k, sz[i + k] = 1;
for (int i = 1, c, x; i <= k; i++) {
scanf("%d", &c);
while (c--) {
scanf("%d", &x);
op[x].push_back(i);
}
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (op[i].size() == 1) {
int x = op[i][0];
res -= cal(x);
if (s[i] == '1')
pre[find(x + k)] = 0;
else
pre[find(x)] = 0;
res += cal(x);
} else if (op[i].size() == 2) {
int x = op[i][0], y = op[i][1];
if (s[i] == '1') {
if (find(x) != find(y)) {
res -= cal(x) + cal(y);
merge(x, y), merge(x + k, y + k);
res += cal(x);
}
} else {
if (find(x + k) != find(y)) {
res -= cal(x) + cal(y);
merge(x + k, y), merge(x, y + k);
res += cal(x);
}
}
}
printf("%d\n", res);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7;
const int INF = 1e7;
char s[maxn];
int fa[maxn], siz[maxn];
int l[maxn][2];
int n, k;
int findset(int x) {
if (fa[x] == x) return x;
return fa[x] = findset(fa[x]);
}
void Union(int x, int y) {
int rx = findset(x), ry = findset(y);
if (!ry) swap(rx, ry);
if (rx) siz[rx] += siz[ry];
fa[ry] = rx;
}
int cal(int x) {
int y = x + k;
x = findset(x), y = findset(y);
return min(siz[x], siz[y]);
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
for (int i = 1; i <= k; i++) {
int m;
scanf("%d", &m);
for (int j = 1; j <= m; j++) {
int x;
scanf("%d", &x);
if (l[x][0] == 0)
l[x][0] = i;
else
l[x][1] = i;
}
siz[i] = 1;
fa[i] = i;
fa[i + k] = i + k;
}
siz[0] = INF;
int ans = 0;
for (int i = 1; i <= n; i++) {
int x = l[i][0], y = l[i][1];
int rx = findset(x), ry = findset(y);
int rxk = findset(x + k), ryk = findset(y + k);
if (!y) {
ans -= cal(x);
if (s[i] == '1') fa[rx] = 0;
if (s[i] == '0') fa[rxk] = 0;
ans += cal(x);
} else if (s[i] == '0' && rx != ryk) {
ans -= cal(x);
ans -= cal(y);
Union(x, y + k);
Union(y, x + k);
ans += cal(x);
} else if (s[i] == '1' && rx != ry) {
ans -= cal(x);
ans -= cal(y);
Union(x, y);
Union(x + k, y + k);
ans += cal(x);
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 10, inf = 0x3f3f3f3f;
vector<int> v[maxn];
int fa[maxn];
long long cnt[maxn];
int n, k;
string s;
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void merge(int u, int v) {
u = find(u), v = find(v);
if (u == v) return;
cnt[u] += cnt[v];
fa[v] = u;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> s;
for (int i = 1, c, t; i <= k; i++) {
cin >> c;
while (c--) {
cin >> t;
v[t].push_back(i);
}
}
for (int i = 1; i <= k; i++) {
fa[i] = i, fa[i + k] = i + k;
cnt[i + k] = 1;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (v[i].size() == 0) {
printf("%d\n", ans);
continue;
} else if (v[i].size() == 1) {
int x = v[i][0];
ans -= min(cnt[find(x)], cnt[find(x + k)]);
if (s[i - 1] == '0')
cnt[find(x)] = inf;
else
cnt[find(x + k)] = inf;
ans += min(cnt[find(x)], cnt[find(x + k)]);
printf("%d\n", ans);
} else {
int x1 = v[i][0], x2 = v[i][1];
if (find(x1) == find(x2) || find(x1) == find(x2 + k)) {
printf("%d\n", ans);
continue;
}
ans -= min(cnt[find(x1)], cnt[find(x1 + k)]);
ans -= min(cnt[find(x2)], cnt[find(x2 + k)]);
if (s[i - 1] == '0') {
merge(x1, x2 + k);
merge(x1 + k, x2);
} else {
merge(x1, x2);
merge(x1 + k, x2 + k);
}
ans += min(cnt[find(x1)], cnt[find(x1 + k)]);
printf("%d\n", ans);
}
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxm = 3e5 + 5;
int fa[maxm << 1], cnt[maxm << 1], n, k, state[maxm][2];
int Find(int x) { return fa[x] == x ? x : fa[x] = Find(fa[x]); }
void Union(int x, int y) {
x = Find(x), y = Find(y);
if (y == 0) swap(x, y);
fa[y] = x;
if (x) cnt[x] += cnt[y];
}
int calc(int x) {
int y = x <= k ? x + k : x - k;
x = Find(x), y = Find(y);
if (x == 0 || y == 0) return cnt[x + y];
return min(cnt[x], cnt[y]);
}
void run_case() {
cin >> n >> k;
string str;
cin >> str;
for (int i = 1; i <= k; ++i) {
int num, lamp;
cin >> num;
while (num--) {
cin >> lamp;
if (!state[lamp][0])
state[lamp][0] = i;
else
state[lamp][1] = i;
}
fa[i] = i, fa[i + k] = i + k, cnt[i + k] = 1;
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (!state[i][1]) {
int x = state[i][0];
if (x) {
ans -= calc(x);
if (str[i - 1] == '0') {
fa[Find(x)] = 0;
} else
fa[Find(x + k)] = 0;
ans += calc(x);
}
} else {
int x = state[i][0], y = state[i][1];
if (str[i - 1] == '0') {
if (Find(x + k) != Find(y)) {
ans -= calc(x), ans -= calc(y);
Union(x, y + k), Union(x + k, y);
ans += calc(x);
}
} else {
if (Find(x) != Find(y)) {
ans -= calc(x), ans -= calc(y);
Union(x, y), Union(x + k, y + k);
ans += calc(x);
}
}
}
cout << ans << "\n";
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
run_case();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e6 + 100;
const int mod = (int)1e9 + 7;
int n, k, fa[maxn], tot[maxn], ans;
char s[maxn];
vector<int> v[maxn];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
void join(int x, int y) {
x = find(x);
y = find(y);
if (x != y) fa[x] = y, tot[y] += tot[x];
}
int get(int x) { return min(tot[find(x)], tot[find(x + k)]); }
int main() {
scanf("%d%d%s", &n, &k, s + 1);
for (int i = (1); i <= (k); ++i) {
int x, c;
scanf("%d", &c);
while (c--) scanf("%d", &x), v[x].push_back(i);
}
for (int i = (1); i <= (2 * k + 1); ++i) fa[i] = i, tot[i] = (i <= k);
tot[2 * k + 1] = mod;
for (int i = (1); i <= (n); ++i) {
if (v[i].size() == 1) {
int tmp = v[i][0] + (s[i] == '0') * k;
ans -= get(v[i][0]);
join(tmp, 2 * k + 1);
ans += get(v[i][0]);
}
if (v[i].size() == 2) {
int x = v[i][0], y = v[i][1];
if (s[i] == '1' && find(x) != find(y)) {
ans -= (get(x) + get(y));
join(x, y);
join(x + k, y + k);
ans += get(x);
}
if (s[i] == '0' && find(x) != find(y + k)) {
ans -= (get(x) + get(y));
join(x, y + k);
join(x + k, y);
ans += get(x);
}
}
printf("%d\n", ans);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
int a[300005];
std::vector<int> g[300005];
int vis[600005], count[600005];
int p[600005];
int find(int u) {
if (p[u] == u)
return u;
else
return p[u] = find(p[u]);
}
void merge(int u, int v) {
int x = find(u), y = find(v);
if (x != y) {
if (x > y) {
p[y] = x;
count[x] += count[y];
count[y] = 0;
} else {
p[x] = y;
count[y] += count[x];
count[x] = 0;
}
}
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%1d", &a[i]);
for (int i = 1; i <= k; i++) {
int c;
scanf("%d", &c);
while (c--) {
int p;
scanf("%d", &p);
g[p].push_back(i);
}
p[i] = i;
p[i + k] = i + k;
count[i] = 0, count[i + k] = 1;
}
int ans = 0;
int True = 2 * k + 1;
p[True] = True;
count[True] = 0;
for (int i = 1; i <= n; i++) {
if ((int)g[i].size() != 0) {
if (g[i].size() == 1) {
int u = g[i][0];
int x = find(u), y = find(u + k);
if (x != True && y != True) {
if (vis[x]) vis[x] = 0, ans -= count[x];
if (vis[y]) vis[y] = 0, ans -= count[y];
ans -= count[True];
if (a[i] != 0)
merge(x, True);
else
merge(y, True);
vis[True] = 1;
ans += count[True];
}
} else {
int u = g[i][0], v = g[i][1];
int x0 = find(u), y0 = find(u + k), x1 = find(v), y1 = find(v + k);
if (vis[x0]) vis[x0] = 0, ans -= count[x0];
if (vis[y0]) vis[y0] = 0, ans -= count[y0];
if (vis[x1]) vis[x1] = 0, ans -= count[x1];
if (vis[y1]) vis[y1] = 0, ans -= count[y1];
if (a[i] != 0) {
merge(x0, x1);
merge(y0, y1);
} else {
merge(x0, y1);
merge(x1, y0);
}
int x = find(u), y = find(u + k);
if (x == True || y == True) {
vis[True] = 1;
ans += count[True];
} else {
int t = count[x] < count[y] ? x : y;
vis[t] = 1;
ans += count[t];
}
}
}
printf("%d\n", ans);
}
printf("\n");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long sz[3000009], par[3000009];
long long res;
long long n, k;
std::vector<long long> pos[3000009];
long long getparent(long long x) {
if (par[x] == x) return x;
return par[x] = getparent(par[x]);
}
void merge(long long x, long long y) {
long long p1 = getparent(x);
long long p2 = getparent(y);
if (p1 == p2) return;
par[p1] = p2;
res -= min(sz[p1], sz[p1 ^ 1]);
res -= min(sz[p2], sz[p2 ^ 1]);
sz[p2] += sz[p1];
res += min(sz[p2], sz[p2 ^ 1]);
sz[p1] = 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
string x;
cin >> x;
for (long long int i = 0; i < 2 * k + 2; i++) {
par[i] = i;
sz[i] = (i) % 2;
}
for (long long int i = 0; i < k; i++) {
long long ss;
cin >> ss;
for (long long int j = 0; j < ss; j++) {
long long yy;
cin >> yy;
yy--;
pos[yy].push_back(i);
}
}
for (long long int i = 0; i < n; i++) {
if (pos[i].size() == 0) {
cout << res << '\n';
continue;
}
if (pos[i].size() == 1) {
if (x[i] == '1') {
long long pp = getparent(2 * pos[i][0] + 1);
res -= min(sz[pp], sz[pp ^ 1]);
sz[pp] = 1e7;
res += sz[pp ^ 1];
} else {
long long pp = getparent(2 * pos[i][0]);
res -= min(sz[pp], sz[pp ^ 1]);
sz[pp] = 1e7;
res += sz[pp ^ 1];
}
cout << res << '\n';
continue;
}
if (x[i] == '1') {
merge(2 * pos[i][0], 2 * pos[i][1]);
merge((2 * pos[i][0]) + 1, (2 * pos[i][1]) + 1);
} else {
merge(2 * pos[i][0], (2 * pos[i][1]) + 1);
merge((2 * pos[i][0]) + 1, 2 * pos[i][1]);
}
cout << res << '\n';
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 3e5 + 5;
long long inf = (long long)30000;
long long mod = (long long)998244353;
long long ans = 0, vert;
long long n, k, par[MAX], sz[MAX], cnt[MAX][2], clr[MAX], pos[MAX];
vector<long long> sets[MAX];
vector<long long> b[MAX];
void x_or(long long dad) {
for (int i = 0; i < sets[dad].size(); i++) {
clr[sets[dad][i]] ^= 1;
}
cnt[dad][0] = 0;
cnt[dad][1] = 0;
for (int i = 0; i < sets[dad].size(); i++) {
long long v = sets[dad][i];
if (clr[v] == 0)
cnt[dad][0]++;
else
cnt[dad][1]++;
}
}
long long get(long long u) {
if (par[u] == u)
return u;
else {
long long v = get(par[u]);
par[u] = v;
return v;
}
}
void unite(long long a, long long b) {
if (get(a) == get(b)) return;
if (sz[get(a)] < sz[get(b)]) swap(a, b);
if (vert == 1 && clr[a] != clr[b]) x_or(get(b));
if (vert == 0 && clr[a] == clr[b]) x_or(get(b));
a = get(a);
b = get(b);
for (int i = 0; i < sets[b].size(); i++) sets[a].push_back(sets[b][i]);
sets[b].clear();
par[b] = a;
sz[a] += sz[b];
ans -= min(cnt[b][0], cnt[b][1]) + min(cnt[a][0], cnt[a][1]);
cnt[a][0] += cnt[b][0];
cnt[a][1] += cnt[b][1];
ans += min(cnt[a][0], cnt[a][1]);
}
void unite_1(long long v, long long u) {
if (vert == 1 && clr[v] != clr[u]) x_or(get(u));
if (vert == 0 && clr[v] == clr[u]) x_or(get(u));
v = get(v);
u = get(u);
par[u] = v;
for (int i = 0; i < sets[u].size(); i++) {
sets[v].push_back(sets[u][i]);
}
sets[u].clear();
ans -= min(cnt[u][1], cnt[u][0]);
ans += cnt[u][1];
cnt[v][1] += cnt[u][1];
cnt[v][0] += cnt[u][0];
}
void solve() {
cin >> n >> k;
string s;
cin >> s;
for (int i = 1; i <= k; i++) {
long long c;
cin >> c;
for (int j = 0; j < c; j++) {
long long a;
cin >> a;
b[a].push_back(i);
}
}
for (int i = 1; i <= k; i++) {
sz[i] = 1;
clr[i] = 0;
cnt[i][0] = 1;
par[i] = i;
sets[i].push_back(i);
}
for (int i = 1; i <= n; i++) {
vert = s[i - 1] - 48;
if (b[i].size() == 1 && !pos[get(b[i][0])]) {
long long v = b[i][0];
if (clr[v] == 0 && vert == 0) x_or(get(v));
if (clr[v] == 1 && vert == 1) x_or(get(v));
ans -= min(cnt[get(v)][0], cnt[get(v)][1]);
ans += cnt[get(v)][1];
pos[get(v)] = 1;
} else if (b[i].size() == 2) {
if (pos[get(b[i][0])] || pos[get(b[i][1])]) {
if (pos[get(b[i][0])] && pos[get(b[i][1])])
;
else {
long long u, v;
v = b[i][0];
u = b[i][1];
if (pos[get(b[i][1])]) swap(u, v);
unite_1(v, u);
}
} else {
unite(b[i][0], b[i][1]);
}
}
cout << ans << "\n";
}
}
int main() {
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ios::sync_with_stdio(0);
long long q;
q = 1;
while (q--) solve();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct perem {
long long t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
long long n, k, m, c, vas, cc = 1000000;
vector<long long> vv;
string s;
vector<vector<long long>> la;
vector<perem> pr;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
la.resize(n, vector<long long>(0));
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() > 0) {
long long a = la[i][0];
bool b1 = 0;
while (a != -1) {
b1 ^= pr[a].q;
if (pr[a].p != -1)
a = pr[a].p;
else
break;
}
if (la[i].size() == 1) {
if ((b1 and s[i] == '1') or (!b1 and s[i] == '0')) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
} else {
long long b = la[i][1];
bool b2 = 0;
while (b != -1) {
b2 ^= pr[b].q;
if (pr[b].p != -1)
b = pr[b].p;
else
break;
}
if (a != b) {
b1 ^= b2;
long long kl = 0;
if ((b1 and s[i] == '1') or (!b1 and s[i] == '0')) {
if (pr[a].l < pr[b].l) {
vas += pr[a].l;
pr[a].q ^= 1;
} else {
vas += pr[b].l;
pr[b].q ^= 1;
}
kl = abs(pr[a].l - pr[b].l);
} else
kl = min(pr[a].l + pr[b].l, cc);
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
}
}
if (i)
vv.emplace_back(vv.back() + vas);
else
vv.emplace_back(vas);
}
for (long long i : vv) cout << i << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 100;
vector<int> v[N];
int father[N], cnt[N], k;
int Find(int x) { return father[x] = father[x] == x ? x : Find(father[x]); }
void unite(int x, int y) {
int tx = Find(x);
int ty = Find(y);
if (tx == ty) return;
father[tx] = ty;
cnt[ty] += cnt[tx];
}
int calc(int x) { return min(cnt[Find(x)], cnt[Find(x + k)]); }
int main() {
int n, x, m;
string s;
cin >> n >> k;
cin >> s;
for (int i = 1; i <= k; i++) {
cin >> m;
while (m--) {
cin >> x;
x--;
v[x].push_back(i);
}
father[i] = i;
father[i + k] = i + k;
cnt[i] = 1;
}
father[2 * k + 1] = 2 * k + 1;
cnt[2 * k + 1] = (int)1e9;
int ans = 0;
for (int i = 0; i < n; i++) {
if ((int)v[i].size() == 1) {
int to = v[i][0] + k * (s[i] == '0');
ans -= calc(v[i][0]);
unite(to, 2 * k + 1);
ans += calc(v[i][0]);
} else if ((int)v[i].size() == 2) {
int x = v[i][0];
int y = v[i][1];
if (s[i] == '1' && Find(x) != Find(y)) {
ans -= calc(x) + calc(y);
unite(x, y);
unite(x + k, y + k);
ans += calc(x);
}
if (s[i] == '0' && Find(x) != Find(y + k)) {
ans -= calc(x) + calc(y);
unite(x, y + k);
unite(x + k, y);
ans += calc(x);
}
}
cout << ans << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct perem {
int t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
long long n, k, m, c, vas, cc = 10000;
vector<long long> vv;
string s;
vector<vector<long long>> la;
vector<perem> pr;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
la.resize(n, vector<long long>(0));
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() == 2) {
long long a = la[i][0], b = la[i][1];
bool b1 = 0;
while (a != -1) {
b1 ^= pr[a].q;
if (pr[a].p != -1)
a = pr[a].p;
else
break;
}
bool b2 = 0;
while (b != -1) {
b2 ^= pr[b].q;
if (pr[b].p != -1)
b = pr[b].p;
else
break;
}
if (a != b) {
b1 ^= b2;
int kl = 0;
if ((b1 and s[i] == '1') or (!b1 and s[i] == '0')) {
if (pr[a].l < pr[b].l) {
vas += pr[a].l;
pr[a].q ^= 1;
} else {
vas += pr[b].l;
pr[b].q ^= 1;
}
kl = abs(pr[a].l - pr[b].l);
} else {
kl = pr[a].l + pr[b].l;
}
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
} else if (la[i].size() == 1) {
bool b = 0;
int a = la[i][0];
while (a != -1) {
b ^= pr[a].q;
if (pr[a].p != -1)
a = pr[a].p;
else
break;
}
if ((b and s[i] == '1') or (!b and s[i] == '0')) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
}
if (i)
vv.emplace_back(vv.back() + vas);
else
vv.emplace_back(vas);
}
for (long long i : vv) cout << i << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5;
const int oo = 1e7 + 5;
int du[] = {-1, 0, 0, 1};
int dv[] = {0, -1, 1, 0};
const long long mod = 1e9 + 7;
long long sqr(long long x) { return x * x; }
int getbit(int state, int i) { return ((state >> i) & 1); }
int n, m, res, dad[N + 5];
vector<int> g[N + 5];
char s[N + 5];
struct Clara {
int l, r, state;
Clara(int L = 0, int R = 0, int State = 0) {
l = L;
r = R;
state = State;
}
int getmin() { return min(l, r); }
void add(Clara tmp) {
l = min(oo, l + tmp.l);
r = min(oo, r + tmp.r);
}
} node[N + 5];
pair<int, int> getdad(int u) {
if (dad[u] < 0) return pair<int, int>(u, 0);
pair<int, int> tmp = getdad(dad[u]);
dad[u] = tmp.first;
node[u].state ^= tmp.second;
return pair<int, int>(tmp.first, node[u].state);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> (s + 1);
for (int i = 1; i <= m; i++) {
int c, k;
node[i] = Clara(1, 0, 0);
dad[i] = -1;
cin >> c;
for (int j = 1; j <= c; j++) {
cin >> k;
g[k].push_back(i);
}
}
for (int i = 1; i <= n; i++) {
int type = s[i] - '0';
if (g[i].size() == 1) {
pair<int, int> u = getdad(g[i][0]);
res -= node[u.first].getmin();
if ((!type && !u.second) || (type && u.second))
node[u.first].add(Clara(0, oo, 0));
else
node[u.first].add(Clara(oo, 0, 0));
res += node[u.first].getmin();
} else if (g[i].size() == 2) {
pair<int, int> u = getdad(g[i][0]);
pair<int, int> v = getdad(g[i][1]);
if (u.first != v.first) {
res -= node[u.first].getmin() + node[v.first].getmin();
if (dad[u.first] > dad[v.first]) swap(u, v);
if ((type && u.second != v.second) || (!type && u.second == v.second)) {
swap(node[v.first].l, node[v.first].r);
node[v.first].state = 1;
}
node[u.first].add(node[v.first]);
dad[u.first] += dad[v.first];
dad[v.first] = u.first;
res += node[u.first].getmin();
}
}
cout << res << '\n';
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300000 + 10;
const int apsz = 26;
const int INF = 10000007;
const unsigned long long mod = 97;
const int maxm = 10000 + 10;
int n, k;
char s[maxn];
int st[maxn];
vector<int> epos[maxn];
int cnt[maxn << 1];
int fa[maxn << 1];
int fd(int x) { return x == fa[x] ? x : fa[x] = fd(fa[x]); }
inline int calc(int x) {
int y = x + k;
x = fd(x), y = fd(y);
if (y == 0 || x == 0) return cnt[x + y];
return min(cnt[x], cnt[y]);
}
void merge(int x, int y) {
x = fd(x), y = fd(y);
if (x == y) return;
if (y == 0) swap(x, y);
fa[y] = x;
if (x) cnt[x] += cnt[y];
}
int main(void) {
scanf("%d", &(n)), scanf("%d", &(k));
scanf("%s", s + 1);
for (int i = (1); i <= (n); ++i) st[i] = s[i] - '0';
for (int i = (1); i <= (k); ++i) {
int sz, x;
scanf("%d", &(sz));
for (; sz--;) {
scanf("%d", &(x));
epos[x].push_back(i);
}
}
for (int i = (1); i <= (k * 2); ++i) fa[i] = i;
for (int i = (1); i <= (k); ++i) cnt[i] = 1;
int ans = 0;
for (int i = (1); i <= (n); ++i) {
if (epos[i].size() == 1) {
int u = epos[i][0];
ans -= calc(u);
if (st[i] == 0)
fa[fd(u + k)] = 0;
else
fa[fd(u)] = 0;
ans += calc(u);
} else if (epos[i].size() == 2) {
int y, x;
x = epos[i][0], y = epos[i][1];
if (st[i] == 1) {
if (fd(x) != fd(y) || fd(x + k) != fd(y + k)) {
ans -= calc(x) + calc(y);
merge(x, y), merge(x + k, y + k);
ans += calc(x);
}
} else {
if (fd(x) != fd(y + k) || fd(y) != fd(x + k)) {
ans -= calc(x) + calc(y);
merge(x + k, y), merge(y + k, x);
ans += calc(x);
}
}
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 600005, INF = 1000000000;
int N, K, a[MAXN];
vector<int> V[MAXN];
char S[MAXN];
int fa[MAXN], val[MAXN], ans;
int get(int x) {
if (fa[x] != x) fa[x] = get(fa[x]);
return fa[x];
}
void merge(int x, int y) {
x = get(x), y = get(y);
if (x != y) fa[x] = y, val[y] += val[x];
}
inline int va(int x) { return min(val[get(x)], val[get(x + K)]); }
int main() {
scanf("%d%d%s", &N, &K, S + 1);
int i, j;
for (i = 1; i <= K; ++i) {
int c, x;
scanf("%d", &c);
while (c--) scanf("%d", &x), V[x].push_back(i);
}
for (i = 1; i <= K * 2; ++i) fa[i] = i, val[i] = i > K;
fa[K * 2 + 1] = K * 2 + 1, val[K * 2 + 1] = INF;
for (i = 1; i <= N; ++i) {
if (V[i].size() == 1) {
int x = V[i][0] + (S[i] == '1') * K;
ans -= va(V[i][0]), merge(x, K * 2 + 1), ans += va(V[i][0]);
} else if (V[i].size() == 2) {
int x = V[i][0], y = V[i][1];
if (S[i] == '0') {
if (get(x) != get(y + K))
ans -= va(x) + va(y), merge(x, y + K), merge(x + K, y), ans += va(x);
} else {
if (get(x) != get(y))
ans -= va(x) + va(y), merge(x, y), merge(x + K, y + K), ans += va(x);
}
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec[300005];
int par[300005], sz[300005], bit[300005], sister[300005], ans;
int find(int node) {
if (par[node] == node) return node;
par[node] = par[par[node]];
return find(par[node]);
}
int Union(int a, int b) {
if (!b) return a;
if (sz[a] < sz[b]) swap(a, b);
par[b] = a;
sz[a] += sz[b];
bit[a] = max(bit[b], bit[a]);
return a;
}
void adjustans(int node1, int node2) {
if (!node2) {
if (bit[node1] == 1) ans -= sz[node1];
return;
}
if (bit[node1] == -1 && bit[node2] == -1)
ans -= min(sz[node1], sz[node2]);
else if (bit[node1] == 1)
ans -= sz[node1];
else if (bit[node2] == 1)
ans -= sz[node2];
}
void connect(int node1, int node2, bool flag) {
int a = find(node1);
int b = find(node2);
if (a == b || sister[a] == b) return;
adjustans(a, sister[a]);
adjustans(b, sister[b]);
int A, B;
if (!flag) {
A = Union(b, sister[a]);
B = Union(a, sister[b]);
} else {
A = Union(a, b);
if (!sister[a] && !sister[b]) {
if (bit[A] == 1) ans += sz[A];
return;
} else if (!sister[a])
B = Union(sister[b], sister[a]);
else
B = Union(sister[a], sister[b]);
}
sister[A] = B;
sister[B] = A;
if (bit[A] == -1 && bit[B] == -1)
ans += min(sz[A], sz[B]);
else if (bit[A] == 1 || !bit[B]) {
bit[A] = 1;
bit[B] = 0;
ans += sz[A];
} else if (!bit[A] || bit[B] == 1) {
bit[A] = 0;
bit[B] = 1;
ans += sz[B];
}
}
int main() {
memset(bit, -1, sizeof(bit));
int n, k, c, x;
string str;
cin >> n >> k;
cin >> str;
for (int i = 1; i <= k; ++i) {
par[i] = i;
sz[i] = 1;
cin >> c;
while (c--) {
cin >> x;
vec[x].push_back(i);
}
}
for (int i = 1; i <= n; ++i) {
if (vec[i].size() == 1) {
int val = find(vec[i][0]);
if (str[i - 1] == '0' && bit[val] == -1) {
if (!sister[val])
ans += sz[val];
else {
ans += (sz[val] - min(sz[val], sz[sister[val]]));
bit[sister[val]] = 0;
}
bit[val] = 1;
} else if (str[i - 1] == '1' && bit[val] == -1) {
bit[val] = 0;
if (sister[val]) {
bit[sister[val]] = 1;
ans += (sz[sister[val]] - min(sz[val], sz[sister[val]]));
}
}
} else if (vec[i].size() == 2) {
if (str[i - 1] == '0')
connect(vec[i][0], vec[i][1], 0);
else
connect(vec[i][0], vec[i][1], 1);
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, K, p[301000], tot, UF[301000], UP[301000], C[301000][2], T[301000];
char s[301000];
vector<int> g[301000], u[301000];
int Find(int a) {
int x = a, s = 0;
while (x != UF[x]) {
s ^= UP[x];
x = UF[x];
}
int t = 0, root = x;
x = a;
while (x != UF[x]) {
int y = UF[x];
int z = UP[x];
UP[x] = t ^ s;
UF[x] = root;
t ^= z;
x = y;
}
return root;
}
int Get(int a) {
if (!T[a]) return min(C[a][0], C[a][1]);
return C[a][!(T[a] - 2)];
}
void Minus(int a) { tot -= Get(a); }
void Plus(int a) { tot += Get(a); }
void f1(int a, int c) {
int x = Find(a);
int d = UP[a];
int ck = d ^ c;
Minus(x);
T[x] = ck + 2;
Plus(x);
}
void f2(int a, int b, int c) {
int r1 = Find(a), r2 = Find(b);
int d1 = UP[a], d2 = UP[b];
int d = d1 ^ d2 ^ c;
if (r1 == r2) return;
Minus(r1);
Minus(r2);
C[r1][0] += C[r2][d];
C[r1][1] += C[r2][d ^ 1];
if (!T[r1] && T[r2]) {
T[r1] = ((T[r2] - 2) ^ d) + 2;
}
UF[r2] = r1;
UP[r2] = d;
Plus(r1);
}
void Process() {
int i, j;
scanf("%d%d", &n, &K);
scanf("%s", s + 1);
for (i = 1; i <= K; i++) {
int sz;
scanf("%d", &sz);
g[i].resize(sz);
for (j = 0; j < sz; j++) {
scanf("%d", &g[i][j]);
u[g[i][j]].push_back(i);
}
}
for (i = 1; i <= K; i++) UF[i] = i, C[i][0] = 1;
for (i = 1; i <= n; i++) {
int c = '1' - s[i];
if (u[i].empty()) {
} else if (u[i].size() == 1) {
f1(u[i][0], c);
} else {
int a = u[i][0], b = u[i][1];
f2(a, b, c);
}
printf("%d\n", tot);
}
}
int main() {
int Tcase = 1;
while (Tcase--) {
Process();
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const int inf = 1e9;
int d[maxn], fa[maxn];
int n, k;
char s[maxn];
vector<int> vec[maxn];
int get(int x) {
if (x == fa[x]) return x;
return fa[x] = get(fa[x]);
}
void merge(int x, int y) {
int fx = get(x), fy = get(y);
if (fx != fy) {
fa[fx] = fy;
d[fy] += d[fx];
}
}
int val(int x) { return min(d[get(x)], d[get(x + k)]); }
int main() {
scanf("%d%d%s", &n, &k, s + 1);
for (int i = 1; i <= k; i++) {
int t, x;
scanf("%d", &t);
while (t--) scanf("%d", &x), vec[x].push_back(i);
}
for (int i = 1; i <= 2 * k; i++) fa[i] = i, d[i] = i > k;
fa[2 * k + 1] = 2 * k + 1;
d[2 * k + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vec[i].size() == 1) {
int x = vec[i][0];
ans -= val(x);
merge(x + (s[i] == '1' ? k : 0), 2 * k + 1);
ans += val(x);
} else if (vec[i].size() == 2) {
int x = vec[i][0], y = vec[i][1];
if (s[i] == '1' && get(x) != get(y)) {
ans -= val(x) + val(y);
merge(x, y), merge(x + k, y + k);
ans += val(x);
} else if (s[i] == '0' && get(x) != get(y + k)) {
ans -= val(x) + val(y);
merge(x, y + k), merge(x + k, y);
ans += val(x);
}
}
printf("%d\n", ans);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct perem {
long long t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
long long n, k, m, c, vas, cc = 1000000;
vector<long long> vv;
string s;
vector<vector<long long>> la;
vector<perem> pr;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
la.resize(n, vector<long long>(0));
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() > 0) {
long long a = la[i][0];
bool b1 = s[i] == '1' ? 1 : 0;
while (a != -1) {
b1 ^= pr[a].q;
if (pr[a].p != -1)
a = pr[a].p;
else
break;
}
if (la[i].size() == 1) {
if (!b1) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
} else {
long long b = la[i][1];
while (b != -1) {
b1 ^= pr[b].q;
if (pr[b].p != -1)
b = pr[b].p;
else
break;
}
if (a != b) {
long long kl = 0;
if (!b1) {
if (pr[a].l < pr[b].l) {
vas += pr[a].l;
pr[a].q ^= 1;
} else {
vas += pr[b].l;
pr[b].q ^= 1;
}
kl = abs(pr[a].l - pr[b].l);
} else
kl = min(pr[a].l + pr[b].l, cc);
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
}
}
if (i)
vv.emplace_back(vv.back() + vas);
else
vv.emplace_back(vas);
}
for (long long i : vv) cout << i << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, k, s, x, op[N][2];
char ch[N];
int p[N << 1], val[N << 1];
int find(int u) { return p[u] == u ? p[u] : p[u] = find(p[u]); }
void merge(int a, int b) {
if (a == b) return;
val[b] += val[a];
p[a] = b;
}
int main() {
scanf("%d%d%s", &n, &k, ch + 1);
for (int i = 1; i <= k; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
op[x][bool(op[x][0])] = i;
}
}
for (int i = 1; i <= k; i++) val[i] = 1, p[i] = i, p[i + k] = i + k;
p[k + k + 1] = k + k + 1;
val[k + k + 1] = inf;
int now = 0;
for (int i = 1; i <= n; i++) {
if (op[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (op[i][1]) {
if (find(op[i][0]) == find(op[i][1])) goto qwq;
now -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
now -= min(val[find(op[i][1])], val[find(op[i][1] + k)]);
merge(find(op[i][0]), find(op[i][1]));
merge(find(op[i][0] + k), find(op[i][1] + k));
now += min(val[find(op[i][1])], val[find(op[i][1] + k)]);
} else {
now -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
merge(find(op[i][0]), find(k + k + 1));
now += val[find(op[i][0] + k)];
}
} else {
if (op[i][1]) {
if (find(op[i][0]) == find(op[i][1] + k)) goto qwq;
now -= min(val[find(op[i][1])], val[find(op[i][1] + k)]);
now -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
merge(find(op[i][0]), find(op[i][1] + k)),
merge(find(op[i][1]), find(op[i][0] + k));
now += min(val[find(op[i][1] + k)], val[find(op[i][0] + k)]);
} else {
now -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
merge(find(op[i][0] + k), find(k + k + 1));
now += val[find(op[i][0])];
}
}
qwq:
printf("%d\n", now);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-10;
const int MOD = 998857459;
const int INF = 0x3f3f3f3f;
const int maxn = 3e5 + 10;
const int maxm = 5e6 + 10;
int n, k, op[maxn][2], p[maxn << 1], val[maxn << 1];
char str[maxn];
int find(int first) {
return p[first] == first ? p[first] : p[first] = find(p[first]);
}
void merge(int first, int second) {
if (first == second) return;
val[second] += val[first];
p[first] = second;
}
int main() {
cin >> n >> k;
scanf("%s", str + 1);
for (int i = 1, sz, a; i <= k; ++i) {
scanf("%d", &sz);
while (sz--) {
scanf("%d", &a);
op[a][bool(op[a][0])] = i;
}
val[i] = 1;
p[i] = i;
p[i + k] = i + k;
}
val[0] = INF;
int now = 0;
for (int i = 1; i <= n; ++i) {
int fa = find(op[i][0]), fb = find(op[i][1]);
int rfa = find(op[i][0] + k), rfb = find(op[i][1] + k);
if (!op[i][0]) goto out;
if (str[i] == '1') {
if (op[i][1]) {
if (fa == fb) goto out;
now -= min(val[fa], val[rfa]);
now -= min(val[fb], val[rfb]);
merge(fa, fb);
merge(rfa, rfb);
now += min(val[fb], val[rfb]);
} else {
now -= min(val[fa], val[rfa]);
merge(fa, find(0));
now += val[rfa];
}
} else {
if (op[i][1]) {
if (fa == rfb) goto out;
now -= min(val[fa], val[rfa]);
now -= min(val[fb], val[rfb]);
merge(fa, rfb);
merge(fb, rfa);
now += min(val[rfb], val[rfa]);
} else {
now -= min(val[fa], val[rfa]);
merge(rfa, find(0));
now += val[fa];
}
}
out:
printf("%d\n", now);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] == u ? fa[u] : fa[u] = find(fa[u]); }
void uni(int a, int b) {
if (find(a) == find(b)) return;
val[find(b)] += val[find(a)];
fa[find(a)] = find(b);
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1, fa[i] = i, fa[i + kk] = i + kk;
fa[kk + kk + 1] = kk + kk + 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1]), uni(k[i][0] + kk, k[i][1] + kk);
ans += min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0], kk + kk + 1);
ans += val[find(k[i][0] + kk)];
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1] + kk), uni(k[i][1], k[i][0] + kk);
ans += min(val[find(k[i][1] + kk)], val[find(k[i][0] + kk)]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0] + kk, kk + kk + 1);
ans += val[find(k[i][0])];
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long double PI = 3.141592653589793238462643383279502884197;
long long fac[1] = {1}, inv[1] = {1};
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long mp(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return ret;
}
long long cmb(long long r, long long c) {
return (c > r || c < 0) ? 0 : fac[r] * inv[c] % MOD * inv[r - c] % MOD;
}
char s[300001];
vector<int> v[300000];
int p[600001];
int rotn[600001];
char vis[600001];
int find(int a) {
if (p[a] == -1) return a;
return p[a] = find(p[a]);
}
void merge(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
if (a > b) swap(a, b);
p[b] = a;
rotn[a] = min((int)1e9, rotn[b] + rotn[a]);
}
int main() {
memset(p, -1, sizeof(p));
int n, k;
scanf("%d %d", &n, &k);
scanf("%s", s);
for (int i = 0; i < n; i++) s[i] -= '0';
for (int i = 0; i < k; i++) rotn[i] = 1;
for (int i = 0; i < k; i++) {
int t;
scanf("%d", &t);
for (int j = 0; j < t; j++) {
int tt;
scanf("%d", &tt);
tt--;
v[tt].push_back(i);
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j : v[i]) {
if (vis[find(j)]) ans -= rotn[find(j)], vis[find(j)] = 0;
if (vis[find(j + k)]) ans -= rotn[find(j + k)], vis[find(j + k)] = 0;
}
if (s[i] == 0) {
if ((int)(v[i]).size() == 2) {
merge(v[i][0] + k, v[i][1]);
merge(v[i][0], v[i][1] + k);
} else
rotn[find(v[i][0] + k)] = 1e9;
} else {
if ((int)(v[i]).size() == 2) {
merge(v[i][0], v[i][1]);
merge(v[i][0] + k, v[i][1] + k);
} else if ((int)(v[i]).size() == 1)
rotn[find(v[i][0])] = 1e9;
}
for (int j : v[i]) {
if (vis[find(j)] || vis[find(j + k)]) continue;
int ne;
if (rotn[find(j)] > rotn[find(j + k)])
ne = find(j + k);
else
ne = find(j);
vis[ne] = 1;
ans += rotn[ne];
}
printf("%d\n", ans);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
const int lim = 1000 * 1000 + 5;
int nbElem, nbSub;
vector<int> subset[lim];
int side[lim];
int isIn[lim][2];
string ini;
int rep = 0;
int drepr[lim];
int dsz[lim];
int cnt[lim][2];
int dfind(int x) {
if (drepr[x] != x) drepr[x] = dfind(drepr[x]);
return drepr[x];
}
void add(int cc, int s0, int s1) {
cc = dfind(cc);
rep -= min(cnt[cc][0], cnt[cc][1]);
cnt[cc][0] = min(lim, cnt[cc][0] + s0);
cnt[cc][1] = min(lim, cnt[cc][1] + s1);
rep += min(cnt[cc][0], cnt[cc][1]);
}
void dmerge(int a, int b) {
a = dfind(a);
b = dfind(b);
if (a == b) return;
if (dsz[a] < dsz[b]) swap(a, b);
add(a, cnt[b][0], cnt[b][1]);
add(b, -cnt[b][0], -cnt[b][1]);
dsz[a] += dsz[b];
drepr[b] = a;
}
void dfs(int nod) {
cnt[nod][side[nod]] = 1;
for (int elem : subset[nod]) {
if (isIn[elem][1] == -1) continue;
int oth = isIn[elem][0] + isIn[elem][1] - nod;
if (side[oth] == -1) {
side[oth] = side[nod] ^ (ini[elem] == '0');
dfs(oth);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> nbElem >> nbSub;
cin >> ini;
fill(side, side + lim, -1);
iota(drepr, drepr + lim, 0);
fill_n(&isIn[0][0], 2 * lim, -1);
for (int sub = 0; sub < nbSub; ++sub) {
int st;
cin >> st;
subset[sub].resize(st);
for (int pos = 0; pos < st; ++pos) {
int elem;
cin >> elem;
--elem;
subset[sub][pos] = elem;
if (isIn[elem][0] == -1)
isIn[elem][0] = sub;
else
isIn[elem][1] = sub;
}
}
for (int sub = 0; sub < nbSub; ++sub) {
if (side[sub] == -1) {
side[sub] = 0;
dfs(sub);
}
}
for (int elem = 0; elem < nbElem; ++elem) {
int n0 = isIn[elem][0], n1 = isIn[elem][1];
if (n0 != -1 && n1 == -1) {
int destroy = side[n0] ^ (ini[elem] == '0');
if (destroy == 1)
add(n0, 0, lim);
else
add(n0, lim, 0);
} else if (n0 != -1) {
dmerge(n0, n1);
}
cout << rep << "\n";
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int MAXN = N;
const int mx = 5e5;
const int inf = 1e9;
int arr[MAXN];
vector<int> v1[MAXN];
struct DSU {
int tot = 0;
int par[MAXN];
int cost[MAXN];
void init() {
for (int i = 0; i < N; i++) {
par[i] = i;
cost[i] = (i % 2 == 0);
}
cost[2 * mx] = 0;
cost[2 * mx + 1] = inf;
tot = 0;
}
int getpar(int a) {
if (par[a] == a) {
return a;
}
return par[a] = getpar(par[a]);
}
void merge(int a, int b, int curr) {
int a_true = 2 * a;
int b_true = 2 * b;
int a_false = 2 * a + 1;
int b_false = 2 * b + 1;
a_true = getpar(a_true);
a_false = getpar(a_false);
b_true = getpar(b_true);
b_false = getpar(b_false);
if (curr) {
if (a_true == b_true) {
return;
}
tot -= min(cost[a_true], cost[a_false]);
tot -= min(cost[b_true], cost[b_false]);
cost[b_true] += cost[a_true];
cost[b_false] += cost[a_false];
par[a_true] = b_true;
par[a_false] = b_false;
} else {
if (a_true == b_false) {
return;
}
tot -= min(cost[a_true], cost[a_false]);
tot -= min(cost[b_true], cost[b_false]);
cost[b_false] += cost[a_true];
cost[b_true] += cost[a_false];
par[a_false] = b_true;
par[a_true] = b_false;
}
tot += min(cost[b_true], cost[b_false]);
}
} dsu;
int main() {
int n, k;
cin >> n >> k;
string str;
cin >> str;
for (int i = 1; i <= n; i++) {
arr[i] = str[i - 1] - '0';
}
for (int i = 1; i <= k; i++) {
int c;
cin >> c;
while (c--) {
int a;
cin >> a;
v1[a].push_back(i);
}
}
dsu.init();
for (int i = 1; i <= n; i++) {
if (v1[i].size() == 1) {
dsu.merge(v1[i][0], mx, arr[i] == 0);
} else if (v1[i].size() == 2) {
dsu.merge(v1[i][0], v1[i][1], arr[i] == 1);
}
cout << dsu.tot << endl;
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct UF {
vector<int> e;
UF(int n) : e(n, -1) {}
int find(int x) { return e[x] < 0 ? x : e[x] = find(e[x]); }
bool join(int a, int b) {
a = find(a), b = find(b);
if (a == b) return false;
if (e[a] > e[b]) swap(a, b);
e[a] += e[b];
e[b] = a;
return true;
}
};
char s[300030];
pair<int, int> a[300030];
vector<pair<int, int>> g[300030];
int t, n, k, m, x, d[300030], cnt[3][300030], ans;
void dfs(int v, int p, int s) {
if (s)
d[v] = d[p];
else
d[v] = 3 - d[p];
for (auto u : g[v])
if (!d[u.first]) dfs(u.first, v, u.second);
}
int main() {
scanf("%d%d%s", &n, &k, s + 1);
UF uf(k + 1);
d[k + 1] = 2;
for (int i = 1; i <= n; i++) s[i] -= '0';
for (int i = 1; i <= k; i++)
for (int j = !scanf("%d", &m); j < m; j++)
if (scanf("%d", &x), a[x].first) {
a[x].second = i;
g[a[x].first].emplace_back(i, s[x]);
g[i].emplace_back(a[x].first, s[x]);
} else
a[x].first = i;
for (int i = 1; i <= n; i++)
if (a[i].first && a[i].second == 0) g[0].emplace_back(a[i].first, s[i]);
for (int i = 0; i <= k; i++)
if (!d[i]) dfs(i, k + 1, 0);
for (int i = 1; i <= k; i++) cnt[d[i]][i] = 1;
cnt[1][0] = 0x3f3f3f3f;
for (int i = 1; i <= n; i++) {
int u = uf.find(a[i].first), v = uf.find(a[i].second);
if (uf.join(u, v)) {
ans -= min(cnt[1][u], cnt[2][u]);
ans -= min(cnt[1][v], cnt[2][v]);
for (int j = 1; j <= 2; j++)
cnt[j][u] = cnt[j][v] = cnt[j][u] + cnt[j][v];
ans += min(cnt[1][u], cnt[2][u]);
}
printf("%d\n", ans);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T& x) {
x = 0;
int fl = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') fl = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
x *= fl;
}
template <typename T, typename... Args>
inline void read(T& t, Args&... args) {
read(t);
read(args...);
}
const int N = 300005;
const int INF = 1e9;
int n, k, c;
vector<int> vec[N];
char s[N];
int fa[N << 1], sz[N << 1];
inline int lowbit(int x) { return x & -x; }
inline int findfa(int x) { return x == fa[x] ? x : fa[x] = findfa(fa[x]); }
inline void unionn(int x, int y) {
x = findfa(x), y = findfa(y);
fa[y] = x;
if (sz[x] < INF) sz[x] += sz[y];
}
int main() {
read(n, k);
scanf("%s", s + 1);
for (int i = 1; i <= k; i++) {
read(c);
for (int j = 1; j <= c; j++) {
int x;
read(x);
vec[x].push_back(i);
}
}
for (int i = 1; i <= k * 2; i++) fa[i] = i, sz[i] = (i <= k);
fa[k * 2 + 1] = k * 2 + 1, sz[k * 2 + 1] = INF;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vec[i].size() == 1) {
if (findfa(k * 2 + 1) != findfa(vec[i][0] + k * (s[i] == '0'))) {
ans -= min(sz[findfa(vec[i][0])], sz[findfa(vec[i][0] + k)]);
unionn(k * 2 + 1, vec[i][0] + k * (s[i] == '0'));
ans += min(sz[findfa(vec[i][0])], sz[findfa(vec[i][0] + k)]);
}
} else if (vec[i].size() == 2) {
if (s[i] == '0') {
if (findfa(vec[i][0]) != findfa(vec[i][1] + k)) {
ans -= min(sz[findfa(vec[i][0])], sz[findfa(vec[i][0] + k)]);
ans -= min(sz[findfa(vec[i][1])], sz[findfa(vec[i][1] + k)]);
unionn(vec[i][0], vec[i][1] + k);
unionn(vec[i][0] + k, vec[i][1]);
ans += min(sz[findfa(vec[i][0])], sz[findfa(vec[i][0] + k)]);
}
} else {
if (findfa(vec[i][0]) != findfa(vec[i][1])) {
ans -= min(sz[findfa(vec[i][0])], sz[findfa(vec[i][0] + k)]);
ans -= min(sz[findfa(vec[i][1])], sz[findfa(vec[i][1] + k)]);
unionn(vec[i][0], vec[i][1]);
unionn(vec[i][0] + k, vec[i][1] + k);
ans += min(sz[findfa(vec[i][0])], sz[findfa(vec[i][0] + k)]);
}
}
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 6e5 + 5;
int n, K;
char S[MAXN >> 1];
vector<int> A[MAXN];
namespace DSU {
int fa[MAXN], size[MAXN];
inline void init() {
for (int i = 1; i <= K; ++i) fa[i] = i, fa[i + K] = i + K, size[i + K] = 1;
}
int findfa(int u) { return fa[u] == u ? u : fa[u] = findfa(fa[u]); }
int calc(int u) {
int v = u <= K ? u + K : u - K;
u = findfa(u), v = findfa(v);
if (!u || !v) return size[u + v];
return min(size[u], size[v]);
}
void join(int u, int v) {
u = findfa(u), v = findfa(v);
if (!v) swap(u, v);
fa[v] = u;
if (u) size[u] += size[v];
}
} // namespace DSU
int main() {
scanf("%d%d", &n, &K);
DSU::init();
scanf("%s", S + 1);
for (int x, y, i = 1; i <= K; ++i) {
scanf("%d", &y);
while (y--) scanf("%d", &x), A[x].push_back(i);
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (A[i].size() == 1) {
int x = A[i][0];
ans -= DSU::calc(x);
if (S[i] == '0')
DSU::fa[DSU::findfa(x)] = 0;
else
DSU::fa[DSU::findfa(x + K)] = 0;
ans += DSU::calc(x);
}
if (A[i].size() == 2) {
int x = A[i][0], y = A[i][1];
if (S[i] == '0') {
if (DSU::findfa(x) != DSU::findfa(y + K)) {
ans -= DSU::calc(x) + DSU::calc(y);
DSU::join(x, y + K), DSU::join(y, x + K);
ans += DSU::calc(x);
}
} else {
if (DSU::findfa(x) != DSU::findfa(y)) {
ans -= DSU::calc(x) + DSU::calc(y);
DSU::join(x, y), DSU::join(x + K, y + K);
ans += DSU::calc(x);
}
}
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k;
char s[300005];
vector<int> bel[300005];
int fa[300005 * 2], val[300005 * 2];
int getfa(int now) { return fa[now] == now ? now : fa[now] = getfa(fa[now]); }
int getans(int now) {
int now2;
if (now <= k)
now2 = k + now;
else
now2 = now - k;
int xx = getfa(now), yy = getfa(now2);
if (xx == 0 || yy == 0) return val[xx + yy];
return min(val[xx], val[yy]);
}
void merge(int x, int y) {
int xx = getfa(x), yy = getfa(y);
if (xx == yy) return;
if (yy == 0) swap(xx, yy);
fa[yy] = xx;
if (xx != 0) val[xx] += val[yy];
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
for (int i = 1; i <= k; i++) {
int c;
scanf("%d", &c);
for (int j = 1; j <= c; j++) {
int x;
scanf("%d", &x);
bel[x].push_back(i);
}
fa[i] = i;
fa[i + k] = i + k;
val[i + k] = 1;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int len = bel[i].size();
if (len == 0) {
printf("%d\n", ans);
continue;
}
if (len == 1) {
int now = bel[i][0];
ans -= getans(now);
if (s[i] == '1')
fa[getfa(now + k)] = 0;
else
fa[getfa(now)] = 0;
ans += getans(now);
}
if (len == 2) {
int now1 = bel[i][0];
int now2 = bel[i][1];
if (s[i] == '1') {
if (getfa(now1) != getfa(now2)) {
ans -= getans(now1);
ans -= getans(now2);
merge(now1, now2);
merge(now1 + k, now2 + k);
ans += getans(now1);
}
} else {
if (getfa(now1 + k) != getfa(now2)) {
ans -= getans(now1);
ans -= getans(now2);
merge(now1 + k, now2);
merge(now1, now2 + k);
ans += getans(now1);
}
}
}
printf("%d\n", ans);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int INF = 1000000007;
string s;
int n, k, c, v, ans;
int fat[1000100], siz[1000100];
vector<int> edge[1000100];
struct node {
int l, r, xo;
node(int _l = 0, int _r = 0, int _xo = 0) : l(_l), r(_r), xo(_xo) {}
int get() { return min(l, r); }
void operator+=(node th) {
l += th.l;
r += th.r;
if (l > INF) l = INF;
if (r > INF) r = INF;
}
} val[1000100];
pair<int, int> uu, vv;
pair<int, int> trace(int x) {
if (fat[x] < 0) return make_pair(x, 0);
pair<int, int> pp = trace(fat[x]);
fat[x] = pp.first;
val[x].xo ^= pp.second;
return make_pair(fat[x], val[x].xo);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k >> s;
s = "?" + s;
for (int i = 1; i <= k; i++) {
fat[i] = -1;
siz[i] = 1;
val[i] = node(1, 0, 0);
cin >> c;
for (int j = 1; j <= c; j++) {
cin >> v;
edge[v].push_back(i);
}
}
int ans = 0;
int id;
for (int i = 1; i <= n; i++) {
int tp = (s[i] - '0') ^ 1;
if (edge[i].size() == 1) {
id = edge[i][0];
uu = trace(id);
ans -= val[uu.first].get();
val[uu.first] += node((tp == uu.second) * INF, (tp != uu.second) * INF);
ans += val[uu.first].get();
} else if (edge[i].size() == 2) {
id = edge[i][0];
uu = trace(id);
id = edge[i][1];
vv = trace(id);
if (uu.first != vv.first) {
ans -= (val[uu.first].get() + val[vv.first].get());
if (siz[uu.first] > siz[vv.first]) swap(uu, vv);
if (uu.second ^ vv.second ^ tp) {
swap(val[vv.first].l, val[vv.first].r);
val[vv.first].xo = 1;
}
siz[uu.first] += siz[vv.first];
fat[vv.first] = uu.first;
val[uu.first] += val[vv.first];
ans += val[uu.first].get();
}
}
cout << ans << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
char op[300005];
int n, k, fa[300005], v[300005], num[300005], sz[300005], ans, gx[300005];
vector<int> vec[300005];
int ff(int x) {
if (fa[x] == x) return x;
int f = ff(fa[x]);
v[x] ^= v[fa[x]];
return fa[x] = f;
}
inline void merge(int x, int y, int p) {
if (ff(x) == ff(y)) return;
int fx = ff(x), fy = ff(y);
if (fx == 0) swap(fx, fy);
v[fx] = p ^ v[x] ^ v[y];
sz[fy] += sz[fx];
num[fy] += v[fx] ? sz[fx] - num[fx] : num[fx];
ans -= gx[fy] + gx[fx];
if (fy == 0)
gx[fy] = num[fy];
else
gx[fy] = min(sz[fy] - num[fy], num[fy]);
ans += gx[fy], fa[fx] = fy;
}
int main() {
scanf("%d%d%s", &n, &k, op + 1);
for (int i = 0; i <= k; i++) fa[i] = i, sz[i] = 1;
for (int i = 1, c, x; i <= k; i++) {
scanf("%d", &c);
while (c--) scanf("%d", &x), vec[x].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (vec[i].size() == 1) vec[i].push_back(0);
}
for (int i = 1; i <= n; i++) {
if (!vec[i].empty()) merge(vec[i][0], vec[i][1], op[i] == '0');
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
int n, k, fa[maxn], f[maxn][2], val[maxn], pos[maxn][2], ans;
char s[maxn];
int getfa(int x) {
if (fa[x] == x) return x;
int F = fa[x];
fa[x] = getfa(F);
val[x] ^= val[F];
return fa[x];
}
void merge(int x, int y, int z) {
getfa(x), getfa(y);
z ^= (val[x] ^ val[y]);
x = fa[x], y = fa[y];
if (x == y) return;
if (x > y) swap(x, y);
if (!x)
ans -= f[x][0];
else
ans -= min(f[x][0], f[x][1]);
ans -= min(f[y][0], f[y][1]);
f[x][0] += f[y][z];
f[x][1] += f[y][z ^ 1];
fa[y] = x, val[y] = z;
if (!x)
ans += f[x][0];
else
ans += min(f[x][0], f[x][1]);
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
for (int i = 1, cnt; i <= k; i++) {
scanf("%d", &cnt);
for (int j = 1, x; j <= cnt; j++) {
scanf("%d", &x);
if (pos[x][0])
pos[x][1] = i;
else
pos[x][0] = i;
}
}
for (int i = 1; i <= k; i++) fa[i] = i, f[i][1] = 1;
for (int i = 1; i <= n; i++) {
if (!pos[i][0]) {
printf("%d\n", ans);
continue;
}
merge(pos[i][0], pos[i][1], (s[i] - '0') ^ 1);
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct perem {
int t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
int n, k, m, c, vas, cc = 1000000, kl;
vector<int> vv;
string s;
vector<vector<int>> la;
vector<perem> pr;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
la.resize(n, vector<int>(0));
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() > 0) {
int a = la[i][0];
bool d = s[i] == '1' ? 1 : 0;
for (;; a = pr[a].p) {
d ^= pr[a].q;
if (pr[a].p == -1) break;
}
if (la[i].size() == 1) {
if (!d) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
} else {
int b = la[i][1];
for (;; b = pr[b].p) {
d ^= pr[b].q;
if (pr[b].p == -1) break;
}
if (a != b) {
if (!d) {
if (pr[a].l > pr[b].l) swap(a, b);
vas += pr[a].l;
pr[a].q ^= 1;
kl = abs(pr[a].l - pr[b].l);
} else
kl = min(pr[a].l + pr[b].l, cc);
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
}
}
if (i)
vv.emplace_back(vv.back() + vas);
else
vv.emplace_back(vas);
}
for (int i : vv) cout << i << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 10;
int n, k, l[maxn][2];
int fa[maxn], sz[maxn];
string s;
int get_fa(int x) {
if (x == fa[x]) return x;
return fa[x] = get_fa(fa[x]);
}
int calc(int x) {
int y = x <= k ? x + k : x - k;
x = get_fa(x), y = get_fa(y);
if (x == 0 || y == 0) return sz[x + y];
return min(sz[x], sz[y]);
}
void merge_dis(int x, int y) {
x = get_fa(x);
y = get_fa(y);
if (y == 0) {
swap(x, y);
}
fa[y] = x;
if (x != 0) sz[x] += sz[y];
}
int main() {
scanf("%d%d", &n, &k);
cin >> s;
for (int i = 1; i <= k; i++) fa[i] = i, fa[i + k] = i + k, sz[i + k] = 1;
for (int i = 1, c; i <= k; i++) {
scanf("%d", &c);
for (int j = 0, x; j < c; j++) {
scanf("%d", &x);
if (l[x][0] == 0)
l[x][0] = i;
else
l[x][1] = i;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (l[i][1] == 0) {
int x = l[i][0];
if (x) {
ans -= calc(x);
if (s[i - 1] == '1')
fa[get_fa(x + k)] = 0;
else
fa[get_fa(x)] = 0;
ans += calc(x);
}
} else {
int x = l[i][0], y = l[i][1];
if (s[i - 1] == '1') {
if (get_fa(x) != get_fa(y)) {
ans -= calc(x);
ans -= calc(y);
merge_dis(x, y);
merge_dis(x + k, y + k);
ans += calc(x);
}
} else {
if (get_fa(x + k) != get_fa(y)) {
ans -= calc(x);
ans -= calc(y);
merge_dis(x + k, y);
merge_dis(x, y + k);
ans += calc(x);
}
}
}
cout << ans << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int fa[300005];
int x[300005], y[300005];
int f[300005][2];
int a[300005][3], b[300005];
int p;
char s[300005];
int main() {
scanf("%d%d%s", &n, &m, s);
for (int i = 1; i <= m; i++) {
int ha;
scanf("%d", &ha);
while (ha--) {
int haha;
scanf("%d", &haha);
a[haha][++b[haha]] = i;
}
fa[i] = i;
f[i][0] = 1;
y[i] = -1;
}
for (int i = 1; i <= n; i++) {
if (b[i] == 1) {
int j = a[i][1];
int l = j, r = 0;
for (; fa[l] != l; l = fa[l]) r ^= x[l];
r ^= (s[i - 1] == '1');
if (y[l] == -1) {
y[l] = r;
p -= min(f[l][0], f[l][1]);
p += f[l][r];
}
} else if (b[i] == 2) {
int j = a[i][1], k = a[i][2], l = x[j], u = x[k];
while (j != fa[j]) {
j = fa[j];
l ^= x[j];
}
while (k != fa[k]) {
k = fa[k];
u ^= x[k];
}
if (j != k) {
if (f[j][0] + f[j][1] < f[k][0] + f[k][1]) swap(j, k);
if (y[j] == -1)
p -= min(f[j][0], f[j][1]);
else
p -= f[j][y[j]];
if (y[k] == -1)
p -= min(f[k][0], f[k][1]);
else
p -= f[k][y[k]];
fa[k] = j;
if (l ^ u ^ (s[i - 1] == '0')) {
x[k] = 1;
swap(f[k][0], f[k][1]);
if (y[k] != -1) y[k] ^= 1;
}
f[j][0] += f[k][0];
f[j][1] += f[k][1];
if (y[k] != -1) y[j] = y[k];
if (y[j] == -1)
p += min(f[j][0], f[j][1]);
else
p += f[j][y[j]];
}
}
printf("%d\n", p);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long poww(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
const long long MAXN = 1e6 + 10;
const long long INF = 8e18;
const long long MOD = 1e9 + 7;
bool Q[MAXN];
int state[MAXN], par[MAXN], c_par[MAXN], S[MAXN], C[3][MAXN], cost[MAXN],
col[MAXN], tot_cost, n, k;
vector<int> V[MAXN], BP_C[MAXN], CC_C[MAXN];
inline void Update(int v, int c, bool neg = false) {
state[v] = c;
if (c == 0) {
if (neg) tot_cost -= cost[v];
cost[v] = min(C[1][v], C[2][v]);
tot_cost += cost[v];
return;
}
if (neg) tot_cost -= cost[v];
cost[v] = C[c][v];
tot_cost += cost[v];
}
inline void Union(int v, int u, int t1, int t2) {
tot_cost -= cost[v];
tot_cost -= cost[u];
if (BP_C[v].size() > BP_C[u].size()) swap(v, u);
if (col[t1] == col[t2]) {
if (state[v]) state[v] = 3 - state[v];
for (int e : BP_C[v]) col[e] = 3 - col[e];
swap(C[1][v], C[2][v]);
}
for (int e : BP_C[v]) {
c_par[e] = u;
C[col[e]][u] += S[e];
BP_C[u].push_back(e);
}
if (state[u] == 0) state[u] = state[v];
Update(u, state[u]);
BP_C[v].clear();
C[1][v] = C[2][v] = 0;
}
inline void Union2(int v, int u) {
if (CC_C[v].size() > CC_C[u].size()) swap(v, u);
if (v == u) return;
int t1 = u, t2 = v;
u = c_par[u], v = c_par[v];
if (u != v) {
tot_cost -= cost[v];
tot_cost -= cost[u];
if (BP_C[v].size() > BP_C[u].size()) swap(v, u);
if (col[t1] != col[t2]) {
if (state[v]) state[v] = 3 - state[v];
for (int e : BP_C[v]) col[e] = 3 - col[e];
swap(C[1][v], C[2][v]);
}
C[1][u] += C[1][v];
C[2][u] += C[2][v];
for (int e : BP_C[v]) {
c_par[e] = u;
BP_C[u].push_back(e);
}
if (state[u] == 0) state[u] = state[v];
Update(u, state[u]);
BP_C[v].clear();
C[1][v] = C[2][v] = 0;
}
u = t1;
v = t2;
for (int e : CC_C[v]) {
par[e] = u;
CC_C[u].push_back(e);
}
S[u] += S[v];
S[v] = 0;
CC_C[v].clear();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
Q[i] = (c == '1');
}
for (int i = 1; i <= k; i++) {
int c;
cin >> c;
while (c--) {
int e;
cin >> e;
V[e].push_back(i);
}
par[i] = i;
CC_C[i].push_back(i);
S[i] = 1;
col[i] = 1;
C[1][i] = 1;
c_par[i] = i;
BP_C[i].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (V[i].size() == 1) {
int ind = V[i].front(), v = par[ind], p_st = c_par[v], c = col[v];
if (Q[i])
Update(p_st, 3 - c, true);
else
Update(p_st, c, true);
} else if (V[i].size() == 2) {
int ind1 = V[i][0], ind2 = V[i][1], v = par[ind1], u = par[ind2],
p1 = c_par[v], p2 = c_par[u];
if (Q[i] == 0) {
if (p1 != p2) Union(p1, p2, u, v);
} else {
Union2(u, v);
}
}
cout << tot_cost << '\n';
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 10;
int n, k, l[maxn][2];
int fa[maxn], sz[maxn];
string s;
int get_fa(int x) {
if (x == fa[x]) return x;
return fa[x] = get_fa(fa[x]);
}
int calc(int x) {
int y = x <= k ? x + k : x - k;
x = get_fa(x), y = get_fa(y);
if (x == 0 || y == 0) return sz[x + y];
return min(sz[x], sz[y]);
}
void merge_dis(int x, int y) {
x = get_fa(x);
y = get_fa(y);
if (y == 0) {
swap(x, y);
}
fa[y] = x;
if (x != 0) sz[x] += sz[y];
}
int main() {
scanf("%d%d", &n, &k);
cin >> s;
for (int i = 1; i <= (int)3e5; i++)
fa[i] = i, fa[i + k] = i + k, sz[i + k] = 1;
for (int i = 1, c; i <= k; i++) {
scanf("%d", &c);
for (int j = 0, x; j < c; j++) {
scanf("%d", &x);
if (l[x][0] == 0)
l[x][0] = i;
else
l[x][1] = i;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (l[i][1] == 0) {
int x = l[i][0];
if (x) {
ans -= calc(x);
if (s[i - 1] == '1')
fa[get_fa(x + k)] = 0;
else
fa[get_fa(x)] = 0;
ans += calc(x);
}
} else {
int x = l[i][0], y = l[i][1];
if (s[i - 1] == '1') {
if (get_fa(x) != get_fa(y)) {
ans -= calc(x);
ans -= calc(y);
merge_dis(x, y);
merge_dis(x + k, y + k);
ans += calc(y);
}
} else {
if (get_fa(x + k) != get_fa(y)) {
ans -= calc(x);
ans -= calc(y);
merge_dis(x + k, y);
merge_dis(x, y + k);
ans += calc(x);
}
}
}
cout << ans << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[630000];
int fa[630000];
int val[630000];
vector<int> belong[630000];
int Push(int x) { return x; }
int Unpush(int x) { return m + x; }
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
bool vis[630000];
void merge(int x, int y) {
int u = find(x), v = find(y);
if (u == v) return;
val[v] += val[u];
if (vis[u]) vis[v] = 1;
fa[u] = v;
}
int value(int x) {
if (vis[find(x)]) return 1000000000;
return val[find(x)];
}
int main() {
scanf("%d%d", &n, &m);
scanf("%s", s + 1);
for (int i = 1; i <= m + m; i++) fa[i] = i;
for (int i = 1; i <= m; i++) {
val[Push(i)] = 1;
int c;
scanf("%d", &c);
for (int j = 1; j <= c; j++) {
int x;
scanf("%d", &x);
belong[x].push_back(i);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (belong[i].size() == 0) {
} else if (belong[i].size() == 1) {
int v = belong[i][0];
ans -= min(value(Push(v)), value(Unpush(v)));
if (s[i] == '0') {
vis[find(Unpush(v))] = 1;
} else {
vis[find(Push(v))] = 1;
}
ans += min(value(Push(v)), value(Unpush(v)));
} else {
int u = belong[i][0], v = belong[i][1];
if (find(Push(u)) == find(Push(v)) || find(Push(u)) == find(Unpush(v)) ||
find(Push(v)) == find(Unpush(u)) ||
find(Unpush(u)) == find(Unpush(v))) {
} else if (s[i] == '0') {
ans -= min(value(Push(u)), value(Unpush(u)));
ans -= min(value(Push(v)), value(Unpush(v)));
merge(Push(u), Unpush(v));
merge(Push(v), Unpush(u));
ans += min(value(Push(u)), value(Unpush(u)));
} else {
ans -= min(value(Push(u)), value(Unpush(u)));
ans -= min(value(Push(v)), value(Unpush(v)));
merge(Push(u), Push(v));
merge(Unpush(u), Unpush(v));
ans += min(value(Push(u)), value(Unpush(u)));
}
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const long long INFLL = 4e18L;
const int MOD = 0;
const int N = 3e5 + 3;
const int BLUE = 1, RED = 2;
int n, k;
char init_state[N];
vector<int> has[N];
int color[N];
vector<int> adj_same[N], adj_diff[N];
struct DSU {
vector<int> _leader, _size, _forced, _r, _b;
DSU() {}
DSU(int _n) {
_leader.assign(_n + 1, 0);
for (int i = 1; i <= _n; ++i) _leader[i] = i;
_size.assign(_n + 1, 1);
_forced.assign(_n + 1, 0);
_r.assign(_n + 1, 0);
for (int i = 1; i <= _n; ++i) _r[i] = color[i] == RED;
_b.assign(_n + 1, 0);
for (int i = 1; i <= _n; ++i) _b[i] = color[i] == BLUE;
}
int leader(int x) {
return (_leader[x] == x) ? x : _leader[x] = leader(_leader[x]);
}
void unite(int x, int y) {
x = leader(x);
y = leader(y);
if (x == y) return;
_leader[y] = x;
if (_forced[y]) _forced[x] = _forced[y];
_size[x] += _size[y];
_r[x] += _r[y];
_b[x] += _b[y];
}
int get_ans(int x) {
x = leader(x);
if (_forced[x] == RED) return _r[x];
if (_forced[x] == BLUE) return _b[x];
return min(_r[x], _b[x]);
}
};
void dfs(int i, int c) {
color[i] = c;
for (int j : adj_same[i])
if (!color[j]) {
color[j] = c;
dfs(j, c);
}
for (int j : adj_diff[i])
if (!color[j]) {
color[j] = RED + BLUE - c;
dfs(j, RED + BLUE - c);
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(16);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> init_state[i];
for (int i = 1; i <= k; ++i) {
int nb;
cin >> nb;
while (nb--) {
int j;
cin >> j;
has[j].push_back(i);
}
}
for (int i = 1; i <= n; ++i) {
if ((int)has[i].size() < 2) continue;
int x = has[i].front();
int y = has[i].back();
if (init_state[i] == '0') {
adj_diff[x].push_back(y);
adj_diff[y].push_back(x);
} else if (init_state[i] == '1') {
adj_same[x].push_back(y);
adj_same[y].push_back(x);
}
}
for (int i = 1; i <= k; ++i)
if (!color[i]) dfs(i, RED);
DSU dsu(k);
int ans = 0;
for (int i = 1; i <= n; ++i) {
if ((int)has[i].size() == 1) {
int x = has[i].front();
int lx = dsu.leader(x);
ans -= dsu.get_ans(lx);
if (init_state[i] == '0')
dsu._forced[lx] = color[x];
else if (init_state[i] == '1')
dsu._forced[lx] = RED + BLUE - color[x];
ans += dsu.get_ans(lx);
} else if ((int)has[i].size() == 2) {
int x = has[i].front();
int y = has[i].back();
int lx = dsu.leader(x);
int ly = dsu.leader(y);
if (lx != ly) {
ans -= dsu.get_ans(lx);
ans -= dsu.get_ans(ly);
dsu.unite(lx, ly);
ans += dsu.get_ans(dsu.leader(lx));
}
}
cout << ans << endl;
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 10;
int n, k, l[maxn][2];
int fa[maxn], sz[maxn];
string s;
int get_fa(int x) {
if (x == fa[x]) return x;
return fa[x] = get_fa(fa[x]);
}
int calc(int x) {
int y;
if (x <= k)
y = x + k;
else
y = x - k;
x = get_fa(x), y = get_fa(y);
if (x == 0 || y == 0) return sz[x + y];
return min(sz[x], sz[y]);
}
void merge_dis(int x, int y) {
x = get_fa(x);
y = get_fa(y);
if (y == 0) {
swap(x, y);
}
fa[y] = x;
if (x != 0) sz[x] += sz[y];
}
int main() {
scanf("%d%d", &n, &k);
cin >> s;
for (int i = 1; i <= (int)3e5; i++)
fa[i] = i, fa[i + k] = i + k, sz[i + k] = 1;
for (int i = 1, c; i <= k; i++) {
scanf("%d", &c);
for (int j = 0, x; j < c; j++) {
scanf("%d", &x);
if (l[x][0] == 0)
l[x][0] = i;
else
l[x][1] = i;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (l[i][1] == 0) {
int x = l[i][0];
if (x) {
ans -= calc(x);
if (s[i - 1] == '1')
fa[get_fa(x + k)] = 0;
else
fa[get_fa(x)] = 0;
ans += calc(x);
}
} else {
int x = l[i][0], y = l[i][1];
if (s[i - 1] == '1') {
if (get_fa(x) != get_fa(y)) {
ans -= calc(x);
ans -= calc(y);
merge_dis(x, y);
merge_dis(x + k, y + k);
ans += calc(x);
}
} else {
if (get_fa(x + k) != get_fa(y)) {
ans -= calc(x);
ans -= calc(y);
merge_dis(x + k, y);
merge_dis(x, y + k);
ans += calc(x);
}
}
}
cout << ans << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct perem {
int t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
int n, k, m, c, vas, cc = 1000000, kl;
vector<int> vv;
string s;
vector<vector<int>> la;
vector<perem> pr;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
la.resize(n, vector<int>(0));
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() > 0) {
int a = la[i][0];
bool b1 = s[i] == '1' ? 1 : 0;
while (a != -1) {
b1 ^= pr[a].q;
if (pr[a].p != -1)
a = pr[a].p;
else
break;
}
if (la[i].size() == 1) {
if (!b1) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
} else {
int b = la[i][1];
while (b != -1) {
b1 ^= pr[b].q;
if (pr[b].p != -1)
b = pr[b].p;
else
break;
}
if (a != b) {
if (!b1) {
if (pr[a].l < pr[b].l) {
vas += pr[a].l;
pr[a].q ^= 1;
} else {
vas += pr[b].l;
pr[b].q ^= 1;
}
kl = abs(pr[a].l - pr[b].l);
} else
kl = min(pr[a].l + pr[b].l, cc);
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
}
}
if (i)
vv.emplace_back(vv.back() + vas);
else
vv.emplace_back(vas);
}
for (int i : vv) cout << i << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 900000;
int papa[MAXN], peso[MAXN], custo[MAXN];
int k;
bool obg[MAXN];
int find(int a) {
if (papa[a] == -1) return a;
return papa[a] = find(papa[a]);
}
bool juntos(int a, int b) { return find(a) == find(b); }
void uni(int a, int b) {
a = find(a);
b = find(b);
if (peso[a] < peso[b]) swap(a, b);
peso[a] += peso[b];
papa[b] = a;
custo[a] += custo[b];
obg[a] = obg[a] || obg[b];
}
int con(int a) {
int aa = find(a + k);
a = find(a);
if (obg[a]) return custo[a];
if (obg[aa]) return custo[aa];
return min(custo[a], custo[aa]);
}
char word[MAXN];
vector<int> lam[MAXN];
int main() {
int n;
scanf("%d%d", &n, &k);
scanf("%s", word);
for (int i = 0; i < k; i++) {
int c;
scanf("%d", &c);
for (int j = 0; j < c; j++) {
int num;
scanf("%d", &num);
lam[num - 1].emplace_back(i);
}
}
memset(papa, -1, sizeof papa);
int res = 0;
for (int i = 0; i < k; i++) custo[i] = 1;
for (int i = 0; i < n; i++) {
if (lam[i].size() == 0) {
} else if (lam[i].size() == 1) {
int a = lam[i][0];
res -= con(a);
obg[find(word[i] == '0' ? a : a + k)] = true;
res += con(a);
} else if (lam[i].size() == 2) {
int a = lam[i][0];
int b = lam[i][1];
if (!juntos(a, b) && !juntos(a, b + k)) {
res -= con(a) + con(b);
if (word[i] == '0') {
uni(a, b + k);
uni(b, a + k);
} else {
uni(a, b);
uni(a + k, b + k);
}
res += con(a);
}
}
printf("%d\n", res);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 6E5 + 10;
int n, k, l[N][2];
int fa[N], sc[N];
string s;
int find(int x) {
if (x == fa[x]) return x;
return fa[x] = find(fa[x]);
}
int cal(int x) {
int y = x <= k ? x + k : x - k;
int xx = find(x), yy = find(y);
if (xx == 0 || yy == 0) return sc[xx + yy];
return min(sc[xx], sc[yy]);
}
void merge(int x, int y) {
int xx = find(x), yy = find(y);
if (xx == 0)
fa[yy] = xx, sc[xx] += sc[yy];
else
fa[xx] = yy, sc[yy] += sc[xx];
}
int main() {
scanf("%d%d", &n, &k);
cin >> s;
for (int i = 1; i <= k; i++) fa[i] = i, fa[i + k] = i + k, sc[i + k] = 1;
for (int i = 1, c; i <= k; i++) {
scanf("%d", &c);
for (int j = 0, v; j < c; j++) {
scanf("%d", &v);
if (l[v][0])
l[v][1] = i;
else
l[v][0] = i;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (l[i][1] == 0) {
int x = l[i][0];
if (x) {
ans -= cal(x);
if (s[i - 1] == '1')
fa[find(x + k)] = 0;
else
fa[find(x)] = 0;
ans += cal(x);
}
} else {
int x = l[i][0], y = l[i][1];
if (s[i - 1] == '1') {
if (find(x) != find(y)) {
ans -= cal(x);
ans -= cal(y);
merge(x, y);
merge(x + k, y + k);
ans += cal(x);
}
} else {
if (find(x) != find(y + k)) {
ans -= cal(x);
ans -= cal(y);
merge(x, y + k);
merge(x + k, y);
ans += cal(x);
}
}
}
cout << ans << '\n';
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int MAX_N = 6e5 + 5;
int n, k, a[MAX_N >> 1];
vector<int> op[MAX_N >> 1];
int fa[MAX_N], val[MAX_N];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void unit(int x, int y) {
int fx = find(x), fy = find(y);
if (fx != fy) fa[fy] = fx, val[fx] += val[fy];
}
int get_min(int x) { return min(val[find(x)], val[find(x + k)]); }
int main() {
scanf("%d", &n), scanf("%d", &k);
for (register int i = 1; i <= n; i++) scanf("%1d", &a[i]);
for (register int i = 1; i <= k; i++) {
int x, y;
scanf("%d", &x);
while (x--) scanf("%d", &y), op[y].push_back(i);
}
for (register int i = 1; i <= 2 * k + 1; i++) fa[i] = i, val[i] = (i <= k);
int mx = 2 * k + 1;
val[mx] = inf;
int ans = 0;
for (register int i = 1; i <= n; i++) {
if (op[i].size() == 1) {
int tmp = op[i][0] + k * (a[i] == 0);
ans -= get_min(op[i][0]);
unit(tmp, mx);
ans += get_min(op[i][0]);
} else if (op[i].size() == 2) {
int x = op[i][0], y = op[i][1];
if (a[i] == 0 && find(x) != find(y + k)) {
ans -= (get_min(x) + get_min(y));
unit(x, y + k), unit(x + k, y);
ans += get_min(x);
}
if (a[i] == 1 && find(x) != find(y)) {
ans -= (get_min(x) + get_min(y));
unit(x, y), unit(x + k, y + k);
ans += get_min(x);
}
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, pre[300005 * 2];
char s[300005];
inline int find(int x) { return x == pre[x] ? x : pre[x] = find(pre[x]); }
int val[300005 * 2], tmp, m;
vector<int> ve[300005];
int ans;
inline int getmin(int x) { return min(val[find(x)], val[find(x + k)]); }
inline void merge(int x, int y) {
int xx = find(x), yy = find(y);
if (xx != yy) {
pre[xx] = yy;
val[yy] += val[xx];
}
}
int main() {
scanf("%d%d%s", &n, &k, s + 1);
for (int i = 1; i <= k; ++i) {
scanf("%d", &m);
while (m--) {
scanf("%d", &tmp);
ve[tmp].push_back(i);
}
}
for (int i = 1; i <= k; ++i) {
pre[i] = i, val[i] = 1;
pre[i + k] = i + k, val[i + k] = 0;
}
pre[2 * k + 1] = 2 * k + 1, val[2 * k + 1] = 0x3f3f3f3f;
ans = 0;
for (int i = 1; i <= n; ++i) {
if (s[i] == '0') {
if (ve[i].size() == 1) {
int id = ve[i][0];
ans -= getmin(id);
merge(id + k, 2 * k + 1);
ans += getmin(id);
} else {
int id1 = ve[i][0], id2 = ve[i][1];
if (find(id1) != find(id2 + k)) {
ans -= getmin(id1) + getmin(id2);
merge(id1, id2 + k), merge(id1 + k, id2);
ans += getmin(id1);
}
}
} else {
if (ve[i].size() == 1) {
int id = ve[i][0];
ans -= getmin(id);
merge(id, 2 * k + 1);
ans += getmin(id);
} else if (ve[i].size() == 2) {
int id1 = ve[i][0], id2 = ve[i][1];
if (find(id1) != find(id2)) {
ans -= getmin(id1) + getmin(id2);
merge(id1, id2), merge(id1 + k, id2 + k);
ans += getmin(id1);
}
}
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] == u ? fa[u] : fa[u] = find(fa[u]); }
void uni(int a, int b) {
if (find(a) == find(b)) return;
val[find(b)] += val[find(a)];
fa[find(a)] = find(b);
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1, fa[i] = i, fa[i + kk] = i + kk;
fa[kk + kk + 1] = kk + kk + 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1]), uni(k[i][0] + kk, k[i][1] + kk);
ans += mix(k[i][1]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0], kk + kk + 1);
ans += val[find(k[i][0] + kk)];
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1] + kk), uni(k[i][1], k[i][0] + kk);
ans += mix(k[i][0]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0] + kk, kk + kk + 1);
ans += mix(k[i][0]);
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x;
vector<int> vec[300010];
char c[300010];
int fa[300010 << 1], sz[300010 << 1];
int lim[300010 << 1];
int find(int x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
int main() {
scanf("%d%d%s", &n, &k, c + 1);
for (int i = 1; i <= k; i++) {
scanf("%d", &m);
for (int j = 1; j <= m; j++) {
scanf("%d", &x);
vec[x].push_back(i);
}
}
for (int i = 1; i <= k; i++) {
fa[i * 2 - 1] = i * 2 - 1;
sz[i * 2 - 1] = 1;
fa[i * 2] = i * 2;
sz[i * 2] = 0;
lim[i * 2 - 1] = lim[i * 2] = -1;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vec[i].size() == 1) {
int x = vec[i][0];
int f1 = find(x * 2 - 1), f0 = find(x * 2);
int s1 = sz[f1], s0 = sz[f0];
if (lim[f1] != -1)
ans -= lim[f1] ? s1 : s0;
else if (lim[f0] != -1)
ans -= lim[f0] ? s0 : s1;
else
ans -= min(s0, s1);
lim[f1] = (c[i] == '0');
lim[f0] = lim[f1] ^ 1;
ans += lim[f1] ? s1 : s0;
} else if (vec[i].size() == 2) {
int x = vec[i][0], y = vec[i][1];
int fx1 = find(x * 2 - 1), fx0 = find(x * 2);
int sx1 = sz[fx1], sx0 = sz[fx0];
int fy1 = find(y * 2 - 1), fy0 = find(y * 2);
int sy1 = sz[fy1], sy0 = sz[fy0];
if (fx0 != fy0 && fx0 != fy1) {
if (lim[fx1] == -1)
ans -= min(sx0, sx1);
else
ans -= lim[fx1] ? sx1 : sx0;
if (lim[fy1] == -1)
ans -= min(sy0, sy1);
else
ans -= lim[fy1] ? sy1 : sy0;
if (c[i] == '1') {
fa[fx1] = fy1;
fa[fx0] = fy0;
sz[fy1] += sz[fx1];
sz[fy0] += sz[fx0];
if (lim[fx1] != -1) {
lim[fy1] = lim[fx1];
lim[fy0] = lim[fy1] ^ 1;
} else if (lim[fx0] != -1) {
lim[fy0] = lim[fx0];
lim[fy1] = lim[fy0] ^ 1;
}
} else {
fa[fx1] = fy0;
fa[fx0] = fy1;
sz[fy0] += sz[fx1];
sz[fy1] += sz[fx0];
if (lim[fx1] != -1) {
lim[fy0] = lim[fx1];
lim[fy1] = lim[fy0] ^ 1;
} else if (lim[fx0] != -1) {
lim[fy1] = lim[fx0];
lim[fy0] = lim[fy1] ^ 1;
}
}
int f1 = find(x * 2 - 1), f0 = find(x * 2);
int s1 = sz[f1], s0 = sz[f0];
if (lim[f1] == -1)
ans += min(s0, s1);
else
ans += lim[f1] ? s1 : s0;
}
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 7;
int n, k;
string s;
int l[maxn][2], r[maxn], cnt[maxn];
int getroot(int x) { return r[x] == x ? x : r[x] = getroot(r[x]); }
int calc(int x) {
int y = x + k;
x = getroot(x);
y = getroot(y);
if (x == 0 || y == 0) {
return cnt[x + y];
}
return min(cnt[x], cnt[y]);
}
void fmerge(int x, int y) {
x = getroot(x);
y = getroot(y);
if (y == 0) {
swap(x, y);
}
r[y] = x;
if (x != 0) {
cnt[x] += cnt[y];
}
}
int main() {
cin >> n >> k;
cin >> s;
for (int i = 1; i <= k; i++) {
int c;
cin >> c;
for (int j = 0; j < c; j++) {
int x;
cin >> x;
if (l[x][0] == 0)
l[x][0] = i;
else
l[x][1] = i;
}
r[i] = i;
r[i + k] = i + k;
cnt[i + k] = 1;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (l[i][1] == 0) {
int x = l[i][0];
if (x) {
ans -= calc(x);
if (s[i - 1] == '1') {
r[getroot(x + k)] = 0;
} else {
r[getroot(x)] = 0;
}
ans += calc(x);
}
} else {
int x = l[i][0], y = l[i][1];
if (s[i - 1] == '1') {
if (getroot(x) != getroot(y)) {
ans -= calc(x);
ans -= calc(y);
fmerge(x, y);
fmerge(x + k, y + k);
ans += calc(x);
}
} else {
if (getroot(x + k) != getroot(y)) {
ans -= calc(x);
ans -= calc(y);
fmerge(x + k, y);
fmerge(x, y + k);
ans += calc(x);
}
}
}
cout << ans << endl;
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long inf = 1000000;
const int N = 300000;
vector<int> tree(2 * N + 4);
vector<int> ranks(2 * N + 4, 0);
char str[N + 4];
int find(int x) { return x == tree[x] ? x : tree[x] = find(tree[x]); }
void link(int x, int y) {
if (ranks[x] > ranks[y]) {
tree[y] = x;
} else {
tree[x] = y;
if (ranks[x] == ranks[y]) {
ranks[y]++;
}
}
}
long long sum = 0;
vector<vector<int>> graph(N);
vector<int> dists(2 * N);
bool visited[2 * N] = {false};
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin.exceptions(cin.failbit);
int n, k;
cin >> n >> k;
cin >> str;
for (int i = 0; i < k; i++) {
tree[i] = i;
tree[i + N] = i + N;
dists[i] = 1;
dists[i + N] = 0;
}
for (int i = 0; i < k; i++) {
int len;
cin >> len;
for (int a = 0; a < len; a++) {
int e;
cin >> e;
e--;
graph[e].push_back(i);
}
}
for (int i = 0; i < n; i++) {
if (graph[i].empty()) {
cout << sum << "\n";
continue;
}
if (graph[i].size() == 1) {
if (str[i] == '0') {
if (!visited[graph[i][0]]) {
visited[graph[i][0]] = true;
sum++;
visited[graph[i][0] + N] = true;
dists[graph[i][0] + N] = inf;
} else {
int x = find(graph[i][0]);
int y = find(graph[i][0] + N);
sum -= min(dists[x], dists[y]);
dists[y] = inf;
sum += dists[x];
}
} else {
if (!visited[graph[i][0]]) {
visited[graph[i][0]] = true;
visited[graph[i][0] + N] = true;
dists[graph[i][0]] = inf;
} else {
int x = find(graph[i][0]);
int y = find(graph[i][0] + N);
sum -= min(dists[x], dists[y]);
dists[x] = inf;
sum += dists[y];
}
}
} else {
if (graph[i].size() > 2) {
cout << "?????\n";
}
int x1 = find(graph[i][0]);
int x2 = find(graph[i][0] + N);
int y1 = find(graph[i][1]);
int y2 = find(graph[i][1] + N);
if (!visited[graph[i][0]]) {
visited[graph[i][0]] = true;
visited[graph[i][0] + N] = true;
}
if (!visited[graph[i][1]]) {
visited[graph[i][1]] = true;
visited[graph[i][1] + N] = true;
}
sum -= min(dists[x1], dists[x2]);
sum -= min(dists[y1], dists[y2]);
if (str[i] == '0') {
if (x1 == y2) {
sum += min(dists[x1], dists[x2]);
} else if (dists[x1] == inf) {
tree[y2] = x1;
y2 = x1;
} else if (dists[y2] == inf) {
tree[x1] = y2;
x1 = y2;
} else {
tree[y2] = x1;
dists[x1] += dists[y2];
y2 = x1;
}
if (dists[x2] == inf) {
tree[y1] = x2;
y1 = x2;
} else if (dists[y1] == inf) {
tree[x2] = y1;
x2 = y1;
} else if (x2 != y1) {
tree[x2] = y1;
dists[y1] += dists[x2];
x2 = y1;
}
sum += min(dists[x1], dists[x2]);
} else {
if (x1 == y1) {
sum += min(dists[x1], dists[x2]);
} else if (dists[x1] == inf) {
tree[y1] = x1;
y1 = x1;
} else if (dists[y1] == inf) {
tree[x1] = y1;
x1 = y1;
} else {
tree[y1] = x1;
dists[x1] += dists[y1];
y1 = x1;
}
if (dists[x2] == inf) {
tree[y2] = x2;
y2 = x2;
} else if (dists[y2] == inf) {
tree[x2] = y2;
x2 = y2;
} else if (x2 != y2) {
tree[x2] = y2;
dists[y2] += dists[x2];
x2 = y2;
}
sum += min(dists[x1], dists[x2]);
}
}
cout << sum << "\n";
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long ans = 0;
long long val[600010];
int have[600010][2], fa[600010];
char str[600010];
int n, k;
int find(int x) { return x == fa[x] ? x : (fa[x] = find(fa[x])); }
int other(int u) { return u <= k ? u + k : u - k; }
void update(int u, long long x, long long y) {
ans -= min(val[u], val[other(u)]);
ans += min(x, y);
val[u] = x;
val[other(u)] = y;
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", str + 1);
for (int i = 1; i <= k; i++) {
int c;
scanf("%d", &c);
while (c--) {
int a;
scanf("%d", &a);
if (have[a][0])
have[a][1] = i;
else
have[a][0] = i;
}
val[i] = 0, val[i + k] = 1;
fa[i] = i, fa[i + k] = i + k;
}
for (int i = 1; i <= n; i++) {
if (str[i] == '0') {
int x = find(have[i][0]), y = find(have[i][1]);
if (!y)
update(x, 1e7, val[other(x)]);
else {
long long uy = val[y], vy = val[other(y)];
update(y, 0, 0);
fa[y] = other(x);
fa[other(y)] = x;
update(x, val[x] + vy, val[other(x)] + uy);
}
} else {
int x = find(have[i][0]), y = find(have[i][1]);
if (!x) {
printf("%lld\n", ans);
continue;
}
if (!y)
update(x, val[x], 1e7);
else {
long long uy = val[y], vy = val[other(y)];
update(y, 0, 0);
fa[y] = x;
fa[other(y)] = other(x);
update(x, val[x] + uy, val[other(x)] + vy);
}
}
printf("%lld\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int w = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
w = (w << 3) + (w << 1) + ch - 48;
ch = getchar();
}
return w * f;
}
int n, m, f[600010], ans, siz[600010], st[600010], a[300010][2];
inline int find(int x) {
if (f[x] == x)
return f[x];
else
return f[x] = find(f[x]);
}
inline void merge(int x, int y) {
int fx = find(x);
int fy = find(y);
if (fx == fy) return;
f[fx] = fy;
siz[fy] += siz[fx];
return;
}
signed main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) {
char ch;
cin >> ch;
st[i] = ch - '0';
}
for (int i = 1; i <= m; i++) {
int tot = read();
for (int j = 1; j <= tot; j++) {
int x = read();
if (!a[x][0])
a[x][0] = i;
else
a[x][1] = i;
}
}
m++;
for (int i = 0; i <= 2 * m; i++) {
f[i] = i;
if (i <= m) siz[i] = 1;
}
siz[0] = 0x3f3f3f3f;
siz[m] = 0;
for (int i = 1; i <= n; i++) {
int x = a[i][0];
int y = a[i][1];
if (!x) {
cout << ans << endl;
continue;
}
if (st[i] == 0 && find(x) != find(y + m)) {
ans -= min(siz[find(x)], siz[find(x + m)]);
ans -= min(siz[find(y)], siz[find(y + m)]);
merge(x, y + m);
merge(x + m, y);
ans += min(siz[find(x)], siz[find(x + m)]);
cout << ans << endl;
continue;
}
if (st[i] == 1 && find(x) != find(y)) {
ans -= min(siz[find(x)], siz[find(x + m)]);
ans -= min(siz[find(y)], siz[find(y + m)]);
merge(x, y);
merge(x + m, y + m);
ans += min(siz[find(x)], siz[find(x + m)]);
cout << ans << endl;
continue;
}
cout << ans << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, k, s, x, op[N][2];
char ch[N];
int p[N << 1], val[N << 1];
int find(int u) { return p[u] == u ? p[u] : p[u] = find(p[u]); }
void uni(int a, int b) {
if (a == b) return;
val[b] += val[a];
p[a] = b;
}
int main() {
scanf("%d%d%s", &n, &k, ch + 1);
for (int i = 1; i <= k; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
op[x][bool(op[x][0])] = i;
}
}
for (int i = 1; i <= k; i++) val[i] = 1, p[i] = i, p[i + k] = i + k;
p[k + k + 1] = k + k + 1;
val[k + k + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (op[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (op[i][1]) {
if (find(op[i][0]) == find(op[i][1])) goto qwq;
ans -= min(val[find(op[i][1])], val[find(op[i][1] + k)]);
ans -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
uni(find(op[i][0]), find(op[i][1])),
uni(find(op[i][0] + k), find(op[i][1] + k));
ans += min(val[find(op[i][1])], val[find(op[i][1] + k)]);
} else {
ans -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
uni(find(op[i][0]), find(k + k + 1));
ans += val[find(op[i][0] + k)];
}
} else {
if (op[i][1]) {
if (find(op[i][0]) == find(op[i][1] + k)) goto qwq;
ans -= min(val[find(op[i][1])], val[find(op[i][1] + k)]);
ans -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
uni(find(op[i][0]), find(op[i][1] + k)),
uni(find(op[i][1]), find(op[i][0] + k));
ans += min(val[find(op[i][1] + k)], val[find(op[i][0] + k)]);
} else {
ans -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
uni(find(op[i][0] + k), find(k + k + 1));
ans += val[find(op[i][0])];
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 7;
using ll = long long;
string s;
int n, k;
int fa[maxn];
vector<int> st[maxn];
const int inf = 0x3f3f3f3f;
ll sz[maxn];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
void Union(int x, int y) {
x = find(x), y = find(y);
if (x != y) {
fa[y] = x;
sz[x] += sz[y];
}
}
int main() {
for (int i = 0; i < maxn; ++i) fa[i] = i;
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
cin >> s;
for (int i = 0; i < k; ++i) {
sz[i] = 1;
int c;
cin >> c;
for (int j = 0, tmp; j < c; ++j) {
cin >> tmp;
--tmp;
st[tmp].push_back(i);
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
if (st[i].size() == 0)
assert(s[i] == '1');
else if (st[i].size() == 1) {
int a1 = st[i][0];
ans -= min(sz[find(a1)], sz[find(a1 + k)]);
if (s[i] == '1')
sz[find(a1)] += inf;
else
sz[find(a1 + k)] += inf;
ans += min(sz[find(a1)], sz[find(a1 + k)]);
} else {
int u = st[i][0], v = st[i][1];
ans -= min(sz[find(u)], sz[find(u + k)]);
if (find(v) != find(u) && find(u) != find(v + k)) {
ans -= min(sz[find(v)], sz[find(v + k)]);
}
if (s[i] == '0') {
Union(u + k, v);
Union(u, v + k);
} else {
Union(u, v);
Union(u + k, v + k);
}
ans += min(sz[find(u)], sz[find(u + k)]);
if (find(u) != find(v) && find(u) != find(v + k))
ans += min(sz[find(v)], sz[find(v + k)]);
}
cout << ans << '\n';
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
int dp[maxn][2], fa[maxn * 2], cnt[maxn * 2], n, k;
char buf[maxn];
int Find(int x) { return x == fa[x] ? x : fa[x] = Find(fa[x]); }
int calc(int x) {
int y = (x <= k ? x + k : x - k);
x = Find(x), y = Find(y);
if (x == 0 || y == 0) return cnt[x + y];
return min(cnt[x], cnt[y]);
}
void Unite(int x, int y) {
x = Find(x), y = Find(y);
if (x == 0) swap(x, y);
fa[x] = y;
if (y) cnt[y] += cnt[x];
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", buf + 1);
for (int i = 1; i <= k; ++i) {
int q;
scanf("%d", &q);
while (q--) {
int num;
scanf("%d", &num);
if (dp[num][0])
dp[num][1] = i;
else
dp[num][0] = i;
}
fa[i] = i, fa[i + k] = i + k;
cnt[i + k] = 1;
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (dp[i][1] == 0) {
int x = dp[i][0];
if (x) {
ans -= calc(x);
if (buf[i] == '0')
fa[Find(x)] = 0;
else
fa[Find(x + k)] = 0;
ans += calc(x);
}
} else {
int x = dp[i][0], y = dp[i][1];
if (buf[i] == '1') {
if (Find(x) != Find(y)) {
ans -= calc(x), ans -= calc(y);
Unite(x, y);
Unite(x + k, y + k);
ans += calc(x);
}
} else {
if (Find(x) != Find(y + k)) {
ans -= calc(x);
ans -= calc(y + k);
Unite(x, y + k);
Unite(y, x + k);
ans += calc(x);
}
}
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] == u ? fa[u] : fa[u] = find(fa[u]); }
void uni(int a, int b) {
if (find(a) == find(b)) return;
val[find(b)] += val[find(a)];
fa[find(a)] = find(b);
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1, fa[i] = i, fa[i + kk] = i + kk;
fa[kk + kk + 1] = kk + kk + 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(k[i][0], k[i][1]), uni(k[i][0] + kk, k[i][1] + kk);
ans += min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
} else {
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(k[i][0], kk + kk + 1);
ans += val[find(k[i][0] + kk)];
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(k[i][0], k[i][1] + kk), uni(k[i][1], k[i][0] + kk);
ans += min(val[find(k[i][1] + kk)], val[find(k[i][0] + kk)]);
} else {
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(k[i][0] + kk, kk + kk + 1);
ans += val[find(k[i][0])];
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9 + 5;
const int N = 600010;
class DSU {
public:
int p[N], cost[N];
int n;
int ans = 0;
DSU(int _n) : n(_n) {
for (int i = 0; i < n; i++) {
cost[2 * i + 1] = 1;
cost[2 * i] = 0;
}
cost[2 * n] = inf;
cost[2 * n + 1] = 0;
for (int i = 0; i < 2 * n + 2; i++) {
p[i] = i;
}
}
int find(int x) { return (x == p[x] ? x : (p[x] = find(p[x]))); }
void unite(int x, int y, bool same) {
assert(0 <= 2 * x && 2 * x + 1 < 2 * n + 2);
assert(0 <= 2 * y && 2 * y + 1 < 2 * n + 2);
int x_true = find(2 * x + 1), y_true = find(2 * y + 1);
int x_false = find(2 * x), y_false = find(2 * y);
if (same) {
if (x_true != y_true) {
assert(x_false != y_false);
ans -= min(cost[x_true], cost[x_false]);
ans -= min(cost[y_true], cost[y_false]);
cost[y_true] += cost[x_true];
cost[y_false] += cost[x_false];
p[x_true] = y_true;
p[x_false] = y_false;
ans += min(cost[y_true], cost[y_false]);
} else {
return;
}
} else {
if (x_true != y_false) {
assert(x_false != y_true);
ans -= min(cost[x_true], cost[x_false]);
ans -= min(cost[y_true], cost[y_false]);
cost[y_true] += cost[x_false];
cost[y_false] += cost[x_true];
p[x_true] = y_false;
p[x_false] = y_true;
ans += min(cost[y_true], cost[y_false]);
} else {
return;
}
}
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<vector<int>> has(n);
for (int i = 0; i < k; i++) {
int size;
cin >> size;
while (size--) {
int x;
cin >> x;
--x;
has[x].push_back(i);
}
}
DSU dsu(k);
int dummy = k;
for (int i = 0; i < n; i++) {
if ((int)has[i].size() == 2) {
dsu.unite(has[i][0], has[i][1], s[i] == '1');
} else if ((int)has[i].size() == 1) {
dsu.unite(has[i].back(), dummy, s[i] == '0');
} else {
assert(s[i] == '1');
}
cout << dsu.ans << '\n';
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 10;
int f[maxn], n, k, w[maxn];
vector<int> v[maxn];
int Find(int x) { return f[x] == x ? x : f[x] = Find(f[x]); }
int ask(int x) {
int y = (x <= k) ? x + k : x - k;
x = Find(x);
y = Find(y);
if (x == 0)
return w[y];
else if (y == 0)
return w[x];
else
return min(w[x], w[y]);
}
void Merge(int x, int y) {
x = Find(x), y = Find(y);
if (y == 0) swap(x, y);
f[y] = x;
if (x != 0) w[x] += w[y];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
string s;
cin >> s;
for (long long i = 1; i <= (long long)k; ++i) {
int x;
cin >> x;
for (long long j = 1; j <= (long long)x; ++j) {
int tem;
cin >> tem;
v[tem].push_back(i);
}
f[i] = i;
f[i + k] = i + k;
w[i + k] = 1;
}
int ans = 0;
for (long long i = 1; i <= (long long)n; ++i) {
if (v[i].size() == 1) {
int x = v[i][0];
if (x) {
ans -= ask(x);
if (s[i - 1] == '1')
f[Find(x + k)] = 0;
else
f[Find(x)] = 0;
ans += ask(x);
}
} else {
int x = 0, y = 0;
if (v[i].size() == 2) {
x = v[i][0], y = v[i][1];
}
if (s[i - 1] == '1') {
if (Find(x) != Find(y)) {
ans -= (ask(x) + ask(y));
Merge(x, y);
Merge(x + k, y + k);
ans += ask(x);
}
} else {
if (Find(x + k) != Find(y)) {
ans -= (ask(x) + ask(y));
Merge(x + k, y);
Merge(x, y + k);
ans += ask(x);
}
}
}
cout << ans << "\n";
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct DS {
int rank, cost, parent;
bool forced;
} ds[4 * 300100];
int ans;
char status[300100];
vector<int> subs[300100];
int neg(int n) { return n + 300100; }
int find(int n) {
if (n == ds[n].parent) return n;
return ds[n].parent = find(ds[n].parent);
}
void join(int n1, int n2) {
int s1 = find(n1), s2 = find(n2);
if (s1 != s2) {
if (ds[s1].rank < ds[s2].rank) swap(s1, s2);
ds[s2].parent = s1;
ds[s1].cost += ds[s2].cost;
ds[s1].rank += ds[s2].rank;
ds[s1].forced |= ds[s2].forced;
}
}
int main() {
int n, k, qtd, v, s1, s2, ns1, ns2, mini;
scanf("%d %d", &n, &k);
getchar();
scanf("%s", status);
for (int i = 0; i < k; i++) {
scanf("%d", &qtd);
for (int j = 0; j < qtd; j++) {
scanf("%d", &v);
subs[v].emplace_back(i);
}
ds[i].rank = 1;
ds[i].cost = 1;
ds[i].parent = i;
ds[i].forced = false;
ds[neg(i)].rank = 1;
ds[neg(i)].cost = 0;
ds[neg(i)].parent = neg(i);
ds[neg(i)].forced = false;
}
for (int i = 1; i <= n; i++) {
if (status[i - 1] == '1') {
if (subs[i].size() == 2) {
s1 = find(subs[i][0]);
s2 = find(subs[i][1]);
ns1 = find(neg(subs[i][0]));
ns2 = find(neg(subs[i][1]));
mini = -1;
if (ds[s1].forced) ans -= ds[s1].cost, mini = 0;
if (ds[ns1].forced) ans -= ds[ns1].cost, mini = 0;
if (mini == -1) {
mini = min(ds[s1].cost, ds[ns1].cost);
ans -= mini;
}
mini = -1;
if (ds[s2].forced and s1 != s2 and ns1 != s2)
ans -= ds[s2].cost, mini = 0;
if (ds[ns2].forced and s1 != ns2 and ns1 != ns2)
ans -= ds[ns2].cost, mini = 0;
if (mini == -1 and s1 != s2 and s1 != ns2 and ns1 != s2 and
ns1 != ns2) {
mini = min(ds[s2].cost, ds[ns2].cost);
ans -= mini;
}
join(s1, s2);
join(ns1, ns2);
s1 = find(subs[i][0]);
s2 = find(subs[i][1]);
ns1 = find(neg(subs[i][0]));
ns2 = find(neg(subs[i][1]));
mini = -1;
if (ds[s1].forced) ans += ds[s1].cost, mini = 0;
if (ds[ns1].forced) ans += ds[ns1].cost, mini = 0;
if (mini == -1) mini = min(ds[s1].cost, ds[ns1].cost);
ans += mini;
} else {
if (subs[i].size() == 1) {
s1 = find(subs[i][0]);
ns1 = find(neg(subs[i][0]));
if (not ds[ns1].forced) {
ans -= min(ds[s1].cost, ds[ns1].cost);
ds[ns1].forced = true;
ans += ds[ns1].cost;
}
}
}
} else {
if (subs[i].size() == 2) {
s1 = find(subs[i][0]);
ns2 = find(neg(subs[i][1]));
ns1 = find(neg(subs[i][0]));
s2 = find(subs[i][1]);
mini = -1;
if (ds[s1].forced) ans -= ds[s1].cost, mini = 0;
if (ds[ns1].forced) ans -= ds[ns1].cost, mini = 0;
if (mini == -1) {
mini = min(ds[s1].cost, ds[ns1].cost);
ans -= mini;
}
mini = -1;
if (ds[s2].forced and s1 != s2 and ns1 != s2)
ans -= ds[s2].cost, mini = 0;
if (ds[ns2].forced and s1 != ns2 and ns1 != ns2)
ans -= ds[ns2].cost, mini = 0;
if (mini == -1 and s1 != s2 and s1 != ns2 and ns1 != s2 and
ns1 != ns2) {
mini = min(ds[s2].cost, ds[ns2].cost);
ans -= mini;
}
join(s1, ns2);
join(ns1, s2);
s1 = find(subs[i][0]);
ns2 = find(neg(subs[i][1]));
ns1 = find(neg(subs[i][0]));
s2 = find(subs[i][1]);
mini = -1;
if (ds[s1].forced) ans += ds[s1].cost, mini = 0;
if (ds[ns1].forced) ans += ds[ns1].cost, mini = 0;
if (mini == -1) mini = min(ds[s1].cost, ds[ns1].cost);
ans += mini;
} else {
if (subs[i].size() == 1) {
s1 = find(subs[i][0]);
ns1 = find(neg(subs[i][0]));
if (not ds[s1].forced) {
ans -= min(ds[s1].cost, ds[ns1].cost);
ds[s1].forced = true;
ans += ds[s1].cost;
}
}
}
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long llINF = 2e18, llMOD = 1e9 + 7;
const int INF = 2e9, MOD = 1e9 + 7, P = 179, N = 2e3 + 1, K = 23000, L = 18;
const long double EPS = 1e-6, ldINF = 1e18, PI = acos(-1);
template <typename T>
inline void sort_uniq(vector<T>& v) {
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
}
template <typename T>
inline int sign(T a) {
if (a > 0) {
return 1;
} else if (a == 0) {
return 0;
} else {
return -1;
}
}
template <typename T, typename P>
bool eq(T a, P b) {
return abs(a - b) <= EPS;
}
const char sep[] = " ";
template <typename T, typename P>
istream& operator>>(istream& in, pair<T, P>& p) {
in >> p.first >> p.second;
return in;
}
template <typename T>
void in_seg(istream& in, T* dst_begin, T* dst_end) {
while (dst_begin != dst_end) {
in >> (*dst_begin);
++dst_begin;
}
}
template <typename T>
istream& operator>>(istream& in, vector<T>& v) {
for (T& i : v) {
in >> i;
}
return in;
}
template <typename T, typename P>
ostream& operator<<(ostream& out, pair<T, P> const& p) {
out << p.first << ' ' << p.second;
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> const& v) {
for (T const& i : v) {
out << i << sep;
}
if (!v.empty()) {
out << '\n';
}
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<vector<T>> const& v) {
for (vector<T> const& i : v) {
out << i;
}
return out;
}
void set_precision(ostream& out, int val) {
out.setf(out.fixed, out.floatfield);
out.precision(val);
}
struct edge {
int v, u, x;
};
class Dsu {
int n;
vector<int> p, sz, p_xor, r_st, ans;
int cur_ans = 0;
int dsu_get(int v) {
if (v == p[v]) {
return v;
}
int par = p[v], res = dsu_get(p[v]);
p_xor[v] ^= p_xor[par];
p[v] = res;
return res;
}
int get_vrt_ans(int v) {
v = dsu_get(v);
if (r_st[v] == 0) {
return ans[v];
} else if (r_st[v] == 1) {
return sz[v] - ans[v];
} else {
return min(ans[v], sz[v] - ans[v]);
}
}
void dsu_unite(int v, int u, int x) {
int p_v = dsu_get(v);
int p_u = dsu_get(u);
if (p_v == p_u) {
assert(x == (p_xor[u] ^ p_xor[v]));
return;
}
cur_ans -= get_vrt_ans(p_v);
cur_ans -= get_vrt_ans(p_u);
if (sz[p_v] < sz[p_u]) {
swap(v, u);
swap(p_v, p_u);
}
p_xor[p_u] = p_xor[u] ^ p_xor[v] ^ x;
if (r_st[p_u] != 2) {
if (r_st[p_v] == 2) {
r_st[p_v] = r_st[p_u] ^ p_xor[p_u];
} else {
assert(r_st[p_v] == (r_st[p_u] ^ p_xor[p_u]));
}
}
if (p_xor[p_u]) {
ans[p_v] += sz[p_u] - ans[p_u];
} else {
ans[p_v] += ans[p_u];
}
p[p_u] = p_v;
sz[p_v] += sz[p_u];
cur_ans += get_vrt_ans(p_v);
}
public:
Dsu(vector<int> r_st)
: n(r_st.size()), p(n), sz(n, 1), p_xor(n), r_st(r_st), ans(n) {
for (int i = 0; i < n; i++) {
p[i] = i;
}
}
int get_ans() { return cur_ans; }
void set_rst(int v, int st) {
int p_v = dsu_get(v);
if (r_st[p_v] != 2) {
assert(r_st[p_v] == (st ^ p_xor[v]));
return;
}
cur_ans -= get_vrt_ans(p_v);
r_st[p_v] = st ^ p_xor[v];
cur_ans += get_vrt_ans(p_v);
}
void unite(int v, int u, int x) { dsu_unite(v, u, x); }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
string s;
vector<vector<int>> v_mask(n);
vector<int> mask_st(k, 2);
vector<vector<edge>> e(n);
cin >> s;
for (int i = 0, c; i < k; i++) {
cin >> c;
for (int j = 0, x; j < c; j++) {
cin >> x;
v_mask[x - 1].push_back(i);
}
}
int ban_bit = n;
for (int i = 0; i < n; i++) {
if (v_mask[i].size() == 1) {
if (s[i] == '0') {
mask_st[v_mask[i][0]] = 1;
} else {
mask_st[v_mask[i][0]] = 0;
}
} else if (v_mask[i].size() == 2) {
int v = v_mask[i][0];
int u = v_mask[i][1];
if (s[i] == '0') {
e[i].push_back({v, u, 1});
} else {
e[i].push_back({v, u, 0});
}
} else {
assert(v_mask[i].size() == 0);
}
}
Dsu dsu(vector<int>(k, 2));
for (int i = 0; i < n; i++) {
for (auto [v, u, x] : e[i]) {
dsu.unite(v, u, x);
}
if (v_mask[i].size() == 1) {
dsu.set_rst(v_mask[i][0], mask_st[v_mask[i][0]]);
}
cout << dsu.get_ans() << '\n';
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 1e6, INF = 1e9 + 10;
vector<long long> v[MX];
long long par[MX], s0[MX], s1[MX], col[MX], ans = 0;
pair<long long, long long> GETPAR(long long v) {
if (par[v] == v) return {v, 0};
pair<long long, long long> ans = GETPAR(par[v]);
return {par[v] = ans.first, col[v] ^= ans.second};
}
void MERGE(long long a, long long b, long long stt) {
pair<long long, long long> u = GETPAR(a), v = GETPAR(b);
if (u.first == v.first) return;
ans -= min(s0[u.first], s1[u.first]) + min(s0[v.first], s1[v.first]);
if (stt ^ u.second ^ v.second) {
swap(s0[v.first], s1[v.first]);
col[v.first] = 1;
}
par[v.first] = u.first;
s0[u.first] += s0[v.first];
s1[u.first] += s1[v.first];
ans += min(s0[u.first], s1[u.first]);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, k;
string s;
cin >> n >> k >> s;
for (long long i = 0; i < k; i++) {
s0[i] = 1;
par[i] = i;
long long l;
cin >> l;
while (l--) {
long long x;
cin >> x;
x--;
v[x].push_back(i);
}
}
for (long long i = 0; i < n; i++) {
if (v[i].size() == 1) {
par[i + k] = i + k;
s0[i + k] = INF;
MERGE(v[i][0], i + k, s[i] == '0');
}
if (v[i].size() == 2) MERGE(v[i][0], v[i][1], s[i] == '0');
cout << ans << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int test = 0;
const int MAXN = 300009;
const long long MOD = 119 << 23 | 1;
class {
public:
vector<int> V[MAXN];
int fa[MAXN * 2], cnt[MAXN * 2];
int n, m;
int findfa(int x) {
if (fa[x] == x) return x;
return fa[x] = findfa(fa[x]);
}
void merge(int x, int y) {
x = findfa(x);
y = findfa(y);
if (x == y) return;
if (x > y) swap(x, y);
fa[y] = x;
cnt[x] += cnt[y];
}
void solve() {
cin >> n >> m;
string s;
cin >> s;
for (int i = 1; i <= m; ++i) {
int c;
cin >> c;
for (int j = 0; j < c; ++j) {
int v;
cin >> v;
V[v].push_back(i);
}
fa[i] = i;
fa[i + m] = i + m;
cnt[i + m] = 1;
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
bool on = s[i - 1] == '1';
if (V[i].size() == 1) {
int p = V[i][0];
if (on) {
ans -= cost(p);
merge(p + m, 0);
ans += cost(p);
} else {
ans -= cost(p);
merge(p, 0);
ans += cost(p);
}
} else if (V[i].size() == 2) {
int p0 = V[i][0], p1 = V[i][1];
if (on) {
if (findfa(p0) != findfa(p1)) {
ans -= cost(p0);
ans -= cost(p1);
merge(p0, p1);
merge(p0 + m, p1 + m);
ans += cost(p0);
} else {
;
}
} else {
if (findfa(p0) != findfa(p1 + m)) {
ans -= cost(p0);
ans -= cost(p1);
merge(p0, p1 + m);
merge(p0 + m, p1);
ans += cost(p0);
} else {
;
}
}
}
cout << ans << '\n';
}
}
int cost(int x) {
int y;
if (x <= m) {
y = m + x;
} else {
y = x - m;
}
x = findfa(x);
y = findfa(y);
if (x == 0)
return cnt[y];
else if (y == 0)
return cnt[x];
return min(cnt[x], cnt[y]);
}
} NSPACE;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
NSPACE.solve();
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-10;
const int MOD = 998857459;
const int INF = 0x3f3f3f3f;
const int maxn = 3e5 + 10;
const int maxm = 5e6 + 10;
int n, k, op[maxn][2], p[maxn << 2];
long long val[maxn << 2];
char str[maxn];
int find(int first) {
return p[first] == first ? p[first] : p[first] = find(p[first]);
}
void merge(int first, int second) {
if (first == second) return;
val[second] += val[first];
p[first] = second;
}
int main() {
cin >> n >> k;
scanf("%s", str + 1);
for (int i = 1, sz, a; i <= k; ++i) {
scanf("%d", &sz);
while (sz--) {
scanf("%d", &a);
if (!op[a][0])
op[a][0] = i;
else
op[a][1] = i;
}
}
for (int i = 1; i <= k; ++i) p[i] = i, p[i + k] = i + k, val[i] = 1;
p[k * 2 + 1] = k * 2 + 1;
val[k * 2 + 1] = INF;
int now = 0;
for (int i = 1; i <= n; ++i) {
if (!op[i][0]) goto out;
if (str[i] == '1') {
if (op[i][1]) {
if (find(op[i][0]) == find(op[i][1])) goto out;
now -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
now -= min(val[find(op[i][1])], val[find(op[i][1] + k)]);
merge(find(op[i][0]), find(op[i][1]));
merge(find(op[i][0] + k), find(op[i][1] + k));
now += min(val[find(op[i][1])], val[find(op[i][1] + k)]);
} else {
now -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
merge(find(op[i][0]), find(k * 2 + 1));
now += val[find(op[i][0] + k)];
}
} else {
if (op[i][1]) {
if (find(op[i][0]) == find(op[i][1] + k)) goto out;
now -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
now -= min(val[find(op[i][1])], val[find(op[i][1] + k)]);
merge(find(op[i][0]), find(op[i][1] + k));
merge(find(op[i][1]), find(op[i][0] + k));
now += min(val[find(op[i][1] + k)], val[find(op[i][0] + k)]);
} else {
now -= min(val[find(op[i][0])], val[find(op[i][0] + k)]);
merge(find(op[i][0] + k), find(k * 2 + 1));
now += val[find(op[i][0])];
}
}
out:
printf("%d\n", now);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9 + 7;
class DSU {
private:
vector<int> comp, siz;
vector<int> tp;
vector<int> onc, offc;
public:
DSU(int n) : comp(n), siz(n, 1), tp(n, 0), onc(n, 0), offc(n, 1) {
for (int i = 0; i < n; ++i) comp[i] = i;
offc[n - 1] = INF;
}
pair<int, int> getc(int i) {
if (comp[i] != i) {
auto sub = getc(comp[i]);
comp[i] = sub.first;
tp[i] ^= sub.second;
}
return {comp[i], tp[i]};
}
int join(int a, int b, int t) {
int at, bt;
tie(a, at) = getc(a);
tie(b, bt) = getc(b);
t ^= at ^ bt;
if (a == b) return 0;
int add = -(min(onc[a], offc[a]) + min(onc[b], offc[b]));
siz[a] += siz[b];
comp[b] = a;
tp[b] = t;
if (tp[b]) {
onc[a] += offc[b];
offc[a] += onc[b];
} else {
onc[a] += onc[b];
offc[a] += offc[b];
}
add += min(onc[a], offc[a]);
return add;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<pair<int, int>> lamps(n, {k, k});
string str;
cin >> str;
for (int j = 0; j < k; ++j) {
int c;
cin >> c;
for (int i = 0; i < c; ++i) {
int x;
cin >> x;
--x;
if (lamps[x].first == k)
lamps[x].first = j;
else if (lamps[x].second == k)
lamps[x].second = j;
}
}
DSU dsu(k + 1);
int res = 0;
for (int i = 0; i < n; ++i) {
res += dsu.join(lamps[i].first, lamps[i].second, str[i] == '0');
cout << res << '\n';
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] == u ? fa[u] : fa[u] = find(fa[u]); }
void uni(int a, int b) {
if (find(a) == find(b)) return;
val[find(b)] += val[find(a)];
fa[find(a)] = find(b);
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1, fa[i] = i, fa[i + kk] = i + kk;
fa[kk + kk + 1] = kk + kk + 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(find(k[i][0]), find(k[i][1])),
uni(find(k[i][0] + kk), find(k[i][1] + kk));
ans += min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
} else {
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(find(k[i][0]), find(kk + kk + 1));
ans += val[find(k[i][0] + kk)];
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(find(k[i][0]), find(k[i][1] + kk)),
uni(find(k[i][1]), find(k[i][0] + kk));
ans += min(val[find(k[i][1] + kk)], val[find(k[i][0] + kk)]);
} else {
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(find(k[i][0] + kk), find(kk + kk + 1));
ans += val[find(k[i][0])];
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, const T& b) {
return a > b ? a = b, true : false;
}
template <class T>
bool umax(T& a, const T& b) {
return a < b ? a = b, true : false;
}
template <long long sz>
using tut = array<long long, sz>;
const long long N = 3e5 + 5;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
const long double Pi = acos(-1);
const long long MX = 2e16;
long long n, m, k, t, q, ans, res, a[N];
long long in[N][2], cc[N], cnt[N][2];
long long par[N], sz[N];
vector<long long> edges[N];
string s;
void dfs(long long u) {
cnt[u][cc[u]]++;
for (auto x : edges[u]) {
if (in[x][1] == -1) continue;
long long to = in[x][0] + in[x][1] - u;
if (~cc[to]) continue;
cc[to] = cc[u] ^ (s[x] == '0');
dfs(to);
}
}
long long f(long long x) { return (par[x] == x ? x : par[x] = f(par[x])); }
void add(long long a, long long s0, long long s1) {
a = f(a);
res -= min(cnt[a][0], cnt[a][1]);
cnt[a][0] += s0, cnt[a][1] += s1;
res += min(cnt[a][0], cnt[a][1]);
}
void merge(long long a, long long b) {
a = f(a), b = f(b);
if (a == b) return;
if (sz[b] > sz[a]) swap(a, b);
add(a, cnt[b][0], cnt[b][1]);
add(b, -cnt[b][0], -cnt[b][1]);
sz[a] += sz[b], par[b] = a;
}
void solve(long long t_case) {
cin >> n >> k >> s;
s = '$' + s;
memset(in, -1, sizeof in), memset(cc, -1, sizeof cc);
for (long long i = 0; i < k; i++) {
sz[i] = 1, par[i] = i;
long long c;
cin >> c;
for (long long j = 0; j < c; j++) {
long long x;
cin >> x, edges[i].push_back(x);
if (~in[x][0])
in[x][1] = i;
else
in[x][0] = i;
}
}
for (long long i = 0; i < k; i++) {
if (~cc[i]) continue;
cc[i] = 0, dfs(i);
}
for (long long i = 1; i <= n; i++) {
long long c0 = in[i][0], c1 = in[i][1];
if (~c0 && c1 == -1) {
if (s[i] == '0') {
if (cc[c0])
add(c0, mod, 0);
else
add(c0, 0, mod);
} else {
if (cc[c0])
add(c0, 0, mod);
else
add(c0, mod, 0);
}
}
if (~c0 && ~c1) {
merge(c0, c1);
}
cout << res << "\n";
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (0) {
long long t;
cin >> t;
for (long long t_case = 1; t_case <= t; t_case++) solve(t_case);
} else
solve(1);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6e5 + 7;
int n, k;
string s;
int l[maxn][2], r[maxn], cnt[maxn];
int getroot(int x) { return r[x] == x ? x : r[x] = getroot(r[x]); }
int calc(int x) {
int y = x <= k ? x + k : x - k;
x = getroot(x);
y = getroot(y);
if (x == 0 || y == 0) {
return cnt[x + y];
}
return min(cnt[x], cnt[y]);
}
void fmerge(int x, int y) {
x = getroot(x);
y = getroot(y);
if (y == 0) {
swap(x, y);
}
r[y] = x;
cnt[x] += cnt[y];
}
int main() {
cin >> n >> k;
cin >> s;
for (int i = 1; i <= k; i++) {
int c;
cin >> c;
for (int j = 0; j < c; j++) {
int x;
cin >> x;
if (l[x][0] == 0)
l[x][0] = i;
else
l[x][1] = i;
}
r[i] = i;
r[i + k] = i + k;
cnt[i + k] = 1;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (l[i][1] == 0) {
int x = l[i][0];
if (x) {
ans -= calc(x);
if (s[i - 1] == '1') {
r[getroot(x + k)] = 0;
} else {
r[getroot(x)] = 0;
}
ans += calc(x);
}
} else {
int x = l[i][0], y = l[i][1];
if (s[i - 1] == '1') {
if (getroot(x) != getroot(y)) {
ans -= calc(x);
ans -= calc(y);
fmerge(x, y);
fmerge(x + k, y + k);
ans += calc(x);
}
} else {
if (getroot(x + k) != getroot(y)) {
ans -= calc(x);
ans -= calc(y);
fmerge(x + k, y);
fmerge(x, y + k);
ans += calc(x);
}
}
}
cout << ans << endl;
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
vector<int> g[maxn];
int f[maxn], d[maxn], L[maxn], R[maxn], fix[maxn], gt[maxn], ans = 0;
int n, k;
char str[maxn];
int calc(int x) {
if (fix[x])
return gt[x] ? R[x] : L[x];
else
return min(L[x], R[x]);
}
int find(int x) {
if (f[x] == x) return x;
int t = f[x];
f[x] = find(f[x]);
d[x] ^= d[t];
return f[x];
}
void merge(int u, int v, int dd) {
int fa = find(u), fb = find(v);
if (fa != fb) {
ans -= calc(fa) + calc(fb);
f[fa] = fb;
d[fa] = d[u] ^ d[v] ^ dd;
L[fb] += d[fa] ? R[fa] : L[fa];
R[fb] += d[fa] ? L[fa] : R[fa];
fix[fb] |= fix[fa];
if (fix[fa]) gt[fb] = gt[fa] ^ d[fa];
ans += calc(fb);
}
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", str + 1);
for (int i = 1; i <= k; i++) {
int c, x;
scanf("%d", &c);
for (int j = 1; j <= c; j++) scanf("%d", &x), g[x].push_back(i);
}
for (int i = 1; i <= k; i++) f[i] = i, d[i] = 0, L[i] = 1;
for (int i = 1; i <= n; i++) {
if (str[i] == '0') {
if (g[i].size() == 1) {
int x = g[i][0];
int c = find(x);
ans -= calc(c);
fix[c] = 1;
gt[c] = d[x];
ans += calc(c);
} else if (g[i].size() == 2) {
int x = g[i][0], y = g[i][1];
merge(x, y, 1);
}
} else {
if (g[i].size() == 1) {
int x = g[i][0];
int c = find(x);
ans -= calc(c);
fix[c] = 1;
gt[c] = d[x] ^ 1;
ans += calc(c);
} else if (g[i].size() == 2) {
int x = g[i][0], y = g[i][1];
merge(x, y, 0);
}
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
const int maxn = 6e5 + 5;
int fa[maxn], val[maxn], ans;
vector<int> V[maxn];
int n, k;
string s;
void init() {
for (int i = 0; i < maxn; ++i) fa[i] = i;
}
int getfa(int x) { return x == fa[x] ? x : fa[x] = getfa(fa[x]); }
void merge(int x, int y) {
int fx = getfa(x), fy = getfa(y);
if (fx != fy) {
fa[fx] = fy;
val[fy] += val[fx];
}
}
int va(int x) { return min(val[getfa(x)], val[getfa(x + k)]); }
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> s;
for (int i = 1; i <= k; ++i) {
int c;
cin >> c;
for (int j = 1; j <= c; ++j) {
int tmp;
cin >> tmp;
V[tmp].push_back(i);
}
}
for (int i = 1; i <= 2 * k; ++i) fa[i] = i, val[i] = i > k;
fa[2 * k + 1] = 2 * k + 1, val[2 * k + 1] = 0x3f3f3f3f;
for (int i = 1; i <= n; ++i) {
if (V[i].size() == 1) {
int x = V[i][0] + (s[i - 1] == '1') * k;
ans -= va(V[i][0]);
merge(x, k * 2 + 1);
ans += va(V[i][0]);
} else if (V[i].size() == 2) {
int x = V[i][0], y = V[i][1];
if (s[i - 1] == '0') {
if (getfa(x) != getfa(y + k)) {
ans -= va(x) + va(y);
merge(x, y + k);
merge(x + k, y);
ans += va(x);
}
} else {
if (getfa(x) != getfa(y)) {
ans -= va(x) + va(y);
merge(x, y);
merge(x + k, y + k);
ans += va(x);
}
}
}
cout << ans << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
enum class LampConstraint { Distinct, Same };
enum class LampSetState { On, Off, PhantomA, PhantomB };
bool isLampSetStateKnown(LampSetState st) {
return st == LampSetState::On || st == LampSetState::Off;
}
typedef struct Edge {
int nodeId;
LampConstraint cons;
Edge(int nodeId_, LampConstraint cons_) : nodeId(nodeId_), cons(cons_) {}
} Edge;
bool compareEdges(const Edge &a, const Edge &b) {
if (a.nodeId < b.nodeId) return true;
if (a.nodeId > b.nodeId) return true;
return a.cons < b.cons;
}
typedef struct LampSetInfo {
LampSetState state;
int ownerId;
int componentSize;
int onColorSize;
int offColorSize;
explicit LampSetInfo(int id)
: state(LampSetState::PhantomA),
ownerId(id),
componentSize(1),
onColorSize(1),
offColorSize(0){};
} LampSetInfo;
typedef std::set<Edge, decltype(compareEdges) *> Edges;
int componentOnBestSize(std::vector<LampSetInfo> &nodes, int nodeId) {
LampSetInfo &s = nodes[nodeId];
int ownerId = s.ownerId;
if (s.state == LampSetState::On || s.state == LampSetState::Off) {
return nodes[ownerId].onColorSize;
} else {
return std::min(nodes[ownerId].onColorSize, nodes[ownerId].offColorSize);
}
}
LampSetState deducedState(const LampConstraint &cons, LampSetState st) {
switch (cons) {
case LampConstraint::Same:
return st;
case LampConstraint::Distinct:
switch (st) {
case LampSetState::On:
return LampSetState::Off;
case LampSetState::Off:
return LampSetState::On;
case LampSetState::PhantomA:
return LampSetState::PhantomB;
case LampSetState::PhantomB:
return LampSetState::PhantomA;
}
}
}
void propagateLampState(const std::vector<Edges> &graph,
std::vector<LampSetInfo> &nodes, int startNodeId,
LampSetState learnedState) {
std::set<int> visited;
std::stack<std::pair<int, LampSetState>> nodeIds;
nodeIds.push(std::make_pair(startNodeId, learnedState));
int onCount = 0;
while (!nodeIds.empty()) {
std::pair<int, LampSetState> currentNode = nodeIds.top();
nodeIds.pop();
if (visited.find(currentNode.first) != visited.end()) continue;
nodes[currentNode.first].state = currentNode.second;
onCount += ((currentNode.second == LampSetState::On ||
currentNode.second == LampSetState::PhantomA)
? 1
: 0);
visited.insert(currentNode.first);
for (const Edge &e : graph[currentNode.first]) {
if (visited.find(e.nodeId) == visited.end())
nodeIds.push(
std::make_pair(e.nodeId, deducedState(e.cons, currentNode.second)));
}
}
int ownerId = nodes[startNodeId].ownerId;
nodes[ownerId].onColorSize = onCount;
nodes[ownerId].offColorSize = nodes[ownerId].componentSize - onCount;
}
void switchOwner(std::vector<Edges> &graph, std::vector<LampSetInfo> &nodes,
int startNodeId, int newOwner) {
std::set<int> visited;
std::stack<int> nodeIds;
nodeIds.push(startNodeId);
while (!nodeIds.empty()) {
int currentNode = nodeIds.top();
nodeIds.pop();
if (visited.find(currentNode) != visited.end()) continue;
visited.insert(currentNode);
nodes[currentNode].ownerId = newOwner;
for (auto &e : graph[currentNode]) {
if (visited.find(e.nodeId) == visited.end()) nodeIds.push(e.nodeId);
}
}
}
int main() {
int n, k;
long long result = 0;
std::string lamps;
std::vector<LampSetInfo> nodes;
std::cin >> n >> k;
std::cin >> lamps;
std::vector<std::vector<int>> setsForLamp(n);
std::vector<Edges> graph(k, Edges(compareEdges));
for (int i = 0; i < k; i++) {
int c;
nodes.push_back(LampSetInfo(i));
std::cin >> c;
for (int j = 0; j < c; j++) {
int a;
std::cin >> a;
setsForLamp[a - 1].push_back(i);
}
}
for (int i = 0; i < n; i++) {
LampSetState learnedState;
LampConstraint cons;
int startNode;
int a, b, ownerA, ownerB;
switch (setsForLamp[i].size()) {
case 0:
if (lamps[i] != '1')
throw std::runtime_error("Conflicting enforced states of lamps!");
break;
case 1:
startNode = setsForLamp[i][0];
learnedState = (lamps[i] == '1' ? LampSetState::Off : LampSetState::On);
if (!isLampSetStateKnown(nodes[startNode].state)) {
result -= componentOnBestSize(nodes, startNode);
propagateLampState(graph, nodes, startNode, learnedState);
result += componentOnBestSize(nodes, startNode);
} else {
if (learnedState != nodes[startNode].state)
throw std::runtime_error("Conflicting enforced states of lamps!");
}
break;
case 2:
a = setsForLamp[i][0];
b = setsForLamp[i][1];
ownerA = nodes[a].ownerId;
ownerB = nodes[b].ownerId;
cons =
(lamps[i] == '1' ? LampConstraint::Same : LampConstraint::Distinct);
if (nodes[ownerA].componentSize > nodes[ownerB].componentSize) {
std::swap(a, b);
std::swap(ownerA, ownerB);
}
if (ownerA != ownerB) {
result -= componentOnBestSize(nodes, ownerA);
result -= componentOnBestSize(nodes, ownerB);
if (isLampSetStateKnown(nodes[a].state) &&
!isLampSetStateKnown(nodes[b].state)) {
propagateLampState(graph, nodes, b,
deducedState(cons, nodes[a].state));
} else if (isLampSetStateKnown(nodes[b].state) &&
!isLampSetStateKnown(nodes[a].state)) {
propagateLampState(graph, nodes, a,
deducedState(cons, nodes[b].state));
} else if (!isLampSetStateKnown(nodes[b].state) &&
!isLampSetStateKnown(nodes[a].state)) {
propagateLampState(graph, nodes, a,
deducedState(cons, nodes[b].state));
}
nodes[ownerB].onColorSize += nodes[ownerA].onColorSize;
nodes[ownerB].offColorSize += nodes[ownerA].offColorSize;
nodes[ownerB].componentSize += nodes[ownerA].componentSize;
result += componentOnBestSize(nodes, ownerB);
switchOwner(graph, nodes, a, ownerB);
}
graph[a].insert(Edge(b, cons));
graph[b].insert(Edge(a, cons));
break;
default:
throw std::runtime_error("Malformed input data!");
}
std::cout << result << std::endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct perem {
int t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
int n, k, m, c, vas, vvas, cc = 1000000, kl;
string s;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
vector<vector<int>> la(n, vector<int>(0));
vector<perem> pr(k);
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() > 0) {
int a = la[i][0];
bool d = s[i] == '1' ? 1 : 0;
for (;; a = pr[a].p) {
d ^= pr[a].q;
if (pr[a].p == -1) break;
}
if (la[i].size() == 1) {
if (!d) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
} else {
int b = la[i][1];
for (;; b = pr[b].p) {
d ^= pr[b].q;
if (pr[b].p == -1) break;
}
if (a != b) {
if (!d) {
if (pr[a].l > pr[b].l) swap(a, b);
vas += pr[a].l;
pr[a].q ^= 1;
kl = abs(pr[a].l - pr[b].l);
} else
kl = min(pr[a].l + pr[b].l, cc);
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
}
}
cout << vvas + vas << endl;
vvas += vas;
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct DS {
int n;
vector<int> s;
vector<int> count;
DS(int n) : n(n), s(n, -1), count(n, 0) {}
int find(int i) { return s[i] < 0 ? i : (s[i] = find(s[i])); }
int counted(int i) { return count[find(i)]; }
void mark(int i, int x) { count[find(i)] += x; }
int onion(int a, int b) {
a = find(a);
b = find(b);
if (a == b) {
return 0;
}
if (s[a] == s[b]) s[a]--;
if (s[a] <= s[b]) {
s[b] = a;
count[a] += count[b];
} else {
s[a] = b;
count[b] += count[a];
}
return 1;
}
};
int main() {
int n, k;
cin >> n >> k;
vector<int> l(n);
string L;
cin >> L;
for (int i = 0; i < n; i++) {
l[i] = L[i] - '0';
}
vector<vector<int> > s(n);
for (int i = 0; i < k; i++) {
int c;
cin >> c;
while (c--) {
int l;
cin >> l;
l--;
s[l].push_back(i);
}
}
DS ds(2 * k + 1);
for (int i = 0; i < k; i++) ds.mark(i, 1);
int sum = 0;
vector<int> contrib(2 * k + 1, 0);
auto reset = [&](int i) {
sum -= contrib[ds.find(i)];
contrib[ds.find(i)] = 0;
};
auto set = [&](int i, int k) {
contrib[ds.find(i)] = k;
sum += contrib[ds.find(i)];
};
for (int i = 0; i < n; i++) {
if (false) {
cout << i << ":";
for (int p : s[i]) cout << " " << p;
cout << endl;
}
if (s[i].size() == 0) {
} else if (s[i].size() == 1) {
reset(2 * k);
reset(s[i][0] + k);
reset(s[i][0]);
if (l[i] == 1) {
ds.onion(2 * k, s[i][0] + k);
} else {
ds.onion(2 * k, s[i][0]);
}
set(2 * k, ds.counted(2 * k));
} else {
reset(s[i][0]);
reset(s[i][1]);
reset(s[i][0] + k);
reset(s[i][1] + k);
if (l[i] == 1) {
ds.onion(s[i][0], s[i][1]);
ds.onion(s[i][0] + k, s[i][1] + k);
} else {
ds.onion(s[i][0] + k, s[i][1]);
ds.onion(s[i][0], s[i][1] + k);
}
int A = ds.find(s[i][0]);
int B = ds.find(s[i][0] + k);
if (A == ds.find(2 * k)) {
set(A, ds.counted(A));
} else if (B == ds.find(2 * k)) {
set(B, ds.counted(B));
} else if (ds.counted(A) < ds.counted(B)) {
set(A, ds.counted(A));
} else {
set(B, ds.counted(B));
}
}
cout << sum << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int inf = 0x3f3f3f3f;
const int MAXN = 0x7fffffff;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
void file() {}
const int N = 3e5 + 5;
int fat[N * 2], Size[N * 2], n, k;
vector<int> vec[N];
int find(int x) { return fat[x] == x ? x : fat[x] = find(fat[x]); }
int calc(int x) {
int y = (x <= k ? x + k : x - k);
x = find(x);
y = find(y);
if (x == 0 || y == 0) return Size[x + y];
return min(Size[x], Size[y]);
}
void merge(int x, int y) {
x = find(x);
y = find(y);
if (y == 0) swap(x, y);
fat[y] = x;
if (x != 0) Size[x] += Size[y];
}
signed main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
string str;
cin >> n >> k >> str;
for (int i = 1; i <= k; i++) fat[i] = i, fat[i + k] = i + k, Size[i] = 1;
for (int i = 1; i <= k; i++) {
int tn;
cin >> tn;
for (int j = 0; j < tn; j++) {
int pos;
cin >> pos;
vec[pos].push_back(i);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vec[i].size() == 1) {
int x = vec[i][0];
ans -= calc(x);
if (str[i - 1] == '1')
fat[find(x)] = 0;
else
fat[find(x + k)] = 0;
ans += calc(x);
} else if (vec[i].size() == 2) {
int x = vec[i][0], y = vec[i][1];
if (str[i - 1] == '1') {
if (find(x) != find(y)) {
ans -= calc(x);
ans -= calc(y);
merge(x, y);
merge(x + k, y + k);
ans += calc(x);
}
} else {
if (find(x) != find(y + k)) {
ans -= calc(x);
ans -= calc(y);
merge(x, y + k);
merge(x + k, y);
ans += calc(x);
}
}
}
cout << ans << "\n";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
const int lim = 1000 * 1000 + 5;
int nbElem, nbSub;
vector<int> subset[lim];
int side[lim];
int isIn[lim][2];
string ini;
int rep = 0;
int drepr[lim];
int dsz[lim];
int cnt[lim][2];
int dfind(int x) {
if (drepr[x] != x) drepr[x] = dfind(drepr[x]);
return drepr[x];
}
void add(int cc, int s0, int s1) {
cc = dfind(cc);
rep -= min(cnt[cc][0], cnt[cc][1]);
cnt[cc][0] = min(lim, cnt[cc][0] + s0);
cnt[cc][1] = min(lim, cnt[cc][1] + s1);
rep += min(cnt[cc][0], cnt[cc][1]);
}
void dmerge(int a, int b) {
a = dfind(a);
b = dfind(b);
if (a == b) return;
if (dsz[a] < dsz[b]) swap(a, b);
add(a, cnt[b][0], cnt[b][1]);
add(b, -cnt[b][0], -cnt[b][1]);
dsz[a] += dsz[b];
drepr[b] = a;
}
void dfs(int nod) {
cnt[nod][side[nod]] = 1;
for (int elem : subset[nod]) {
if (isIn[elem][1] == -1) continue;
int oth = isIn[elem][0] + isIn[elem][1] - nod;
if (side[oth] == -1) {
side[oth] = side[nod] ^ (ini[elem] == '0');
dfs(oth);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> nbElem >> nbSub;
cin >> ini;
fill(side, side + lim, -1);
iota(drepr, drepr + lim, 0);
fill_n(&isIn[0][0], 2 * lim, -1);
for (int sub = 0; sub < nbSub; ++sub) {
int st;
cin >> st;
subset[sub].resize(st);
for (int pos = 0; pos < st; ++pos) {
int elem;
cin >> elem;
--elem;
subset[sub][pos] = elem;
if (isIn[elem][0] == -1)
isIn[elem][0] = sub;
else
isIn[elem][1] = sub;
}
}
for (int sub = 0; sub < nbSub; ++sub) {
if (side[sub] == -1) {
side[sub] = 0;
dfs(sub);
}
}
for (int elem = 0; elem < nbElem; ++elem) {
int n0 = isIn[elem][0], n1 = isIn[elem][1];
if (n0 != -1 && n1 == -1) {
int destroy = side[n0] ^ (ini[elem] == '0');
if (destroy == 1)
add(n0, 0, lim);
else
add(n0, lim, 0);
} else if (n0 != -1) {
dmerge(n0, n1);
}
cout << rep << "\n";
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 5;
int pre[N], si[N], num[N / 2], n, m;
bool vis[N];
char s[N];
vector<vector<int> > v(N / 2);
int findd(int x) {
if (pre[x] == x) return x;
pre[x] = findd(pre[x]);
if (vis[x]) vis[pre[x]] = 1;
return pre[x];
}
inline int id(int x) { return x > m ? x - m : x; }
int un(int a, int b) {
int x = findd(a);
int y = findd(b);
if (x == y) return -1;
int aa = id(x);
int bb = id(y);
if (aa < bb) {
pre[y] = x, si[x] += si[y];
if (vis[y]) vis[x] = 1;
return aa;
} else {
pre[x] = y, si[y] += si[x];
if (vis[x]) vis[y] = 1;
return bb;
}
}
int main() {
scanf("%d%d", &n, &m);
scanf("%s", s + 1);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d", &a);
while (a--) {
scanf("%d", &b);
v[b].push_back(i);
}
}
for (int i = 1; i <= m; i++) {
pre[i] = i, si[i] = 1;
pre[i + m] = i + m, si[i + m] = 0;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == '0') {
if (v[i].size() == 1) {
int a = findd(v[i][0]);
int b = a > m ? a - m : a + m;
vis[b] = 1;
ans += si[a] - num[id(a)];
num[id(a)] = si[a];
}
if (v[i].size() == 2) {
int a = v[i][0], b = v[i][1];
int sum = num[id(findd(a))] + num[id(findd(b))];
int x = un(a, b + m);
un(b, a + m);
if (x != -1) {
if (vis[x]) {
ans += si[x + m] - sum;
num[x] = si[x + m];
} else if (vis[x + m]) {
ans += si[x] - sum;
num[x] = si[x];
} else {
ans += min(si[x], si[x + m]) - sum;
num[x] = min(si[x], si[x + m]);
}
}
}
} else {
if (v[i].size() == 1) {
int a = findd(v[i][0] + m);
int b = a > m ? a - m : a + m;
vis[b] = 1;
ans += si[a] - num[id(a)];
num[id(a)] = si[a];
}
if (v[i].size() == 2) {
int a = v[i][0], b = v[i][1];
int sum = num[id(findd(a))] + num[id(findd(b))];
int x = un(a, b);
un(b + m, a + m);
if (x != -1) {
if (vis[x]) {
ans += si[x + m] - sum;
num[x] = si[x + m];
} else if (vis[x + m]) {
ans += si[x] - sum;
num[x] = si[x];
} else {
ans += min(si[x], si[x + m]) - sum;
num[x] = min(si[x], si[x + m]);
}
}
}
}
printf("%d\n", ans);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
int dp[maxn][2], fa[maxn * 2], cnt[maxn * 2], n, k;
char buf[maxn];
int Find(int x) { return x == fa[x] ? x : fa[x] = Find(fa[x]); }
int calc(int x) {
int y;
if (x <= k)
y = x + k;
else
y = x - k;
x = Find(x), y = Find(y);
if (x == 0 || y == 0) return cnt[x + y];
return min(cnt[x], cnt[y]);
}
void Unite(int x, int y) {
x = Find(x), y = Find(y);
if (y == 0) swap(x, y);
fa[y] = x;
if (x) cnt[x] += cnt[y];
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", buf + 1);
for (int i = 1; i <= k; ++i) {
int q, id;
scanf("%d", &q);
while (q--) {
scanf("%d", &id);
if (dp[id][0])
dp[id][1] = i;
else
dp[id][0] = i;
}
fa[i] = i;
fa[i + k] = i + k;
cnt[i + k] = 1;
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (dp[i][1] == 0) {
int x = dp[i][0];
if (x) {
ans -= calc(x);
if (buf[i] == '1')
fa[Find(x + k)] = 0;
else
fa[Find(x)] = 0;
ans += calc(x);
}
} else {
int x = dp[i][0], y = dp[i][1];
if (buf[i] == '1') {
if (Find(x) != Find(y)) {
ans -= calc(x), ans -= calc(y);
Unite(x, y);
Unite(x + k, y + k);
ans += calc(x);
}
} else {
if (Find(x) != Find(y + k)) {
ans -= calc(x), ans -= calc(y);
Unite(x, y + k);
Unite(x + k, y);
ans += calc(x);
}
}
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[600005];
int k;
int mx[600005], a[300005], fa[600005];
int find(int x) {
if (fa[x] != x) {
fa[x] = find(fa[x]);
}
return fa[x];
}
void mer(int x, int y) {
int fx = find(x), fy = find(y);
if (fx != fy) {
mx[fx] += mx[fy];
fa[fy] = fx;
}
}
int get(int x) { return min(mx[find(x)], mx[find(x + k)]); }
int main(int argc, char** argv) {
int n;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%1d", &a[i]);
for (int i = 1; i <= 2 * k + 1; i++) {
fa[i] = i;
mx[i] = i > k;
}
mx[2 * k + 1] = 1e8;
for (int i = 1; i <= k; i++) {
int c;
scanf("%d", &c);
while (c--) {
int x;
scanf("%d", &x);
v[x].push_back(i);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (v[i].size() == 1) {
int f = v[i][0];
if (a[i] == 1) {
ans -= get(f);
mer(f + k, 2 * k + 1);
ans += get(f);
} else {
ans -= get(f);
mer(f, 2 * k + 1);
ans += get(f);
}
}
if (v[i].size() == 2) {
int z = v[i][0], x = v[i][1];
if (a[i] == 1) {
if (find(x) != find(z)) {
ans -= get(x) + get(z);
mer(z + k, x + k);
mer(z, x);
ans += get(z);
}
} else {
if (find(x) != find(z + k)) {
ans -= get(x) + get(z);
mer(z + k, x);
mer(z, x + k);
ans += get(z);
}
}
}
cout << ans << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 10;
const long long inf = 1e9 + 10;
int f[N], vist[N];
char s[N];
long long val[N];
vector<int> vec[N];
int find(int x) {
if (f[x] == x) return x;
f[x] = find(f[x]);
return f[x];
}
void myunion(int x, int y) {
if (x < y) {
f[y] = x;
val[x] += val[y];
} else {
f[x] = y;
val[y] += val[x];
}
}
int main() {
int n, m, i, j, tot, x, y, fx, fy, type, ans = 0;
scanf("%d%d", &n, &m);
scanf("%s", s + 1);
for (i = 1; i <= m; i++) {
scanf("%d", &tot);
for (j = 1; j <= tot; j++) {
scanf("%d", &x);
vec[x].push_back(i);
}
}
for (i = 1; i <= m; i++) {
f[i] = i;
f[i + m] = m + i;
val[i] = 1;
}
for (i = 1; i <= n; i++) {
type = s[i] - '0';
if (vec[i].size() == 1) {
x = vec[i][0];
y = x + m;
fx = find(x);
fy = find(y);
if (vist[fx] || vist[fy]) ans -= min(val[fx], val[fy]);
vist[fx] = vist[fy] = 1;
if (type == 0) {
val[fy] = inf;
ans += val[fx];
} else {
val[fx] = inf;
ans += val[fy];
}
} else if (vec[i].size() == 2) {
x = vec[i][0];
y = vec[i][1];
if (type == 0) {
if (find(x) != find(y + m)) {
if (vist[find(x)]) ans -= min(val[find(x)], val[find(x + m)]);
if (vist[find(y)]) ans -= min(val[find(y)], val[find(y + m)]);
myunion(find(x), find(y + m));
myunion(find(y), find(x + m));
ans += min(val[find(x)], val[find(x + m)]);
}
} else {
if (find(x) != find(y)) {
if (vist[find(x)]) ans -= min(val[find(x)], val[find(x + m)]);
if (vist[find(y)]) ans -= min(val[find(y)], val[find(y + m)]);
myunion(find(x), find(y));
myunion(find(x + m), find(y + m));
ans += min(val[find(x)], val[find(x + m)]);
}
}
vist[find(x)] = vist[find(x + m)] = vist[find(y)] = vist[find(y + m)] = 1;
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] ? fa[u] = find(fa[u]) : u; }
void uni(int a, int b) {
if (find(a) == find(b)) return;
val[find(b)] += val[find(a)];
fa[find(a)] = find(b);
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1]), uni(k[i][0] + kk, k[i][1] + kk);
ans += mix(k[i][1]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0], kk + kk + 1);
ans += val[find(k[i][0] + kk)];
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1] + kk), uni(k[i][0] + kk, k[i][1]);
ans += mix(k[i][0]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0] + kk, kk + kk + 1);
ans += mix(k[i][0]);
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x;
vector<int> vec[300010];
char c[300010];
int fa[300010 << 1], sz[300010 << 1];
int lim[300010 << 1];
int find(int x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
int main() {
scanf("%d%d%s", &n, &k, c + 1);
for (int i = 1; i <= k; i++) {
scanf("%d", &m);
for (int j = 1; j <= m; j++) {
scanf("%d", &x);
vec[x].push_back(i);
}
}
for (int i = 1; i <= k; i++) {
fa[i * 2 - 1] = i * 2 - 1;
sz[i * 2 - 1] = 1;
fa[i * 2] = i * 2;
sz[i * 2] = 0;
lim[i * 2 - 1] = lim[i * 2] = -1;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (vec[i].size() == 1) {
int x = vec[i][0];
int f1 = find(x * 2 - 1), f0 = find(x * 2);
int s1 = sz[f1], s0 = sz[f0];
if (lim[f1] == -1)
ans -= min(s0, s1);
else
ans -= lim[f1] ? s1 : s0;
lim[f1] = (c[i] == '0');
lim[f0] = lim[f1] ^ 1;
ans += lim[f1] ? s1 : s0;
} else if (vec[i].size() == 2) {
int x = vec[i][0], y = vec[i][1];
int fx1 = find(x * 2 - 1), fx0 = find(x * 2);
int sx1 = sz[fx1], sx0 = sz[fx0];
int fy1 = find(y * 2 - 1), fy0 = find(y * 2);
int sy1 = sz[fy1], sy0 = sz[fy0];
if (fx0 != fy0 && fx0 != fy1) {
if (lim[fx1] == -1)
ans -= min(sx0, sx1);
else
ans -= lim[fx1] ? sx1 : sx0;
if (lim[fy1] == -1)
ans -= min(sy0, sy1);
else
ans -= lim[fy1] ? sy1 : sy0;
if (c[i] == '1') {
fa[fx1] = fy1;
fa[fx0] = fy0;
sz[fy1] += sz[fx1];
sz[fy0] += sz[fx0];
if (lim[fx1] != -1) {
lim[fy1] = lim[fx1];
lim[fy0] = lim[fy1] ^ 1;
}
} else {
fa[fx1] = fy0;
fa[fx0] = fy1;
sz[fy0] += sz[fx1];
sz[fy1] += sz[fx0];
if (lim[fx1] != -1) {
lim[fy0] = lim[fx1];
lim[fy1] = lim[fy0] ^ 1;
}
}
int f1 = find(x * 2 - 1), f0 = find(x * 2);
int s1 = sz[f1], s0 = sz[f0];
if (lim[f1] == -1)
ans += min(s0, s1);
else
ans += lim[f1] ? s1 : s0;
}
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int val[300000 + 100], sum[300000 + 100][2], head[300000 + 100];
int f[300000 + 100];
vector<int> V[300000 + 100];
int n, k;
int ans;
int findd(int x) {
if (f[x] == x) return x;
int F = f[x];
f[x] = findd(f[x]);
val[x] = val[x] ^ val[F];
return f[x];
}
char s[300000 + 100];
void init() {
for (int i = 0; i <= max(n, k); i++) f[i] = i;
for (int i = 1; i <= max(n, k); i++) {
sum[i][0] = 0;
sum[i][1] = 1;
}
memset(head, -1, sizeof(head));
}
int get(int x) {
if (head[x] == -1) return min(sum[x][0], sum[x][1]);
return sum[x][head[x]];
}
void build(int x, int y, int v) {
int X = findd(x);
int Y = findd(y);
if (X != Y) {
ans -= get(X);
ans -= get(Y);
sum[Y][0] += sum[X][v ^ val[x] ^ val[y]];
sum[Y][1] += sum[X][1 ^ v ^ val[x] ^ val[y]];
if (head[X] != -1 && head[Y] == -1) {
head[Y] = v ^ val[x] ^ val[y] ^ head[X];
}
val[X] = val[x] ^ val[y] ^ v;
f[X] = Y;
ans += get(Y);
}
}
void work(int x, int v) {
int X = findd(x);
ans -= get(X);
if (head[X] == -1) head[X] = v ^ val[x];
ans += get(X);
}
int main() {
int T;
cin >> n >> k;
scanf("%s", s + 1);
for (int i = 1; i <= k; i++) {
scanf("%d", &T);
int cpy = T;
int x;
while (T--) {
scanf("%d", &x);
V[x].push_back(i);
}
}
init();
for (int i = 1; i <= n; i++) {
if (V[i].size() == 1) {
work(V[i][0], 1 ^ (s[i] - '0'));
} else if (V[i].size() == 2) {
build(V[i][0], V[i][1], 1 ^ (s[i] - '0'));
}
printf("%d\n", ans);
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k;
string s;
vector<int> a[300001];
int p[1000001];
long long f[1000001];
const int Max = 6e5;
const int T = 3e5;
int root(int u) {
if (u == p[u]) return u;
return p[u] = root(p[u]);
}
void Merge(int u, int v) {
u = root(u);
v = root(v);
int ru = root(u);
int rv = root(v);
p[rv] = ru;
f[ru] += f[rv];
}
int main() {
cin >> n >> k >> s;
s = '.' + s;
for (int i = 1; i <= Max; i++) {
p[i] = i;
f[i] = -1;
}
for (int i = 1; i <= k; i++) {
int len;
cin >> len;
while (len--) {
int x;
cin >> x;
a[x].push_back(i);
}
}
int res = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == '0') {
if (a[i].size() == 1) {
int u = a[i][0];
if (f[root(u + T)] == -1) {
f[root(u + T)] = 1;
res++;
}
if (f[root(u)] != -1) {
res -= min(f[root(u)], f[root(u + T)]);
f[root(u)] = 1e9;
res += min(f[root(u)], f[root(u + T)]);
}
f[root(u)] = 1e9;
} else if (a[i].size() == 2) {
int u = a[i][0];
int v = a[i][1];
if (f[root(u)] == -1) f[root(u)] = 0;
if (f[root(u + T)] == -1) f[root(u + T)] = 1;
if (f[root(v)] == -1) f[root(v)] = 0;
if (f[root(v + T)] == -1) f[root(v + T)] = 1;
if (root(u) != root(v + T)) {
res -= min(f[root(u)], f[root(u + T)]);
res -= min(f[root(v)], f[root(v + T)]);
Merge(u, v + T);
Merge(u + T, v);
res += min(f[root(u)], f[root(u + T)]);
}
}
} else {
if (a[i].size() == 1) {
int u = a[i][0];
if (f[root(u + T)] != -1) {
res -= min(f[root(u)], f[root(u + T)]);
f[root(u + T)] = 1e9;
res += min(f[root(u)], f[root(u + T)]);
}
if (f[root(u)] == -1) f[root(u)] = 0;
f[root(u + T)] = 1e9;
} else if (a[i].size() == 2) {
int u = a[i][0];
int v = a[i][1];
if (f[root(u)] == -1) f[root(u)] = 0;
if (f[root(u + T)] == -1) f[root(u + T)] = 1;
if (f[root(v)] == -1) f[root(v)] = 0;
if (f[root(v + T)] == -1) f[root(v + T)] = 1;
if (root(u) != root(v)) {
res -= min(f[root(u)], f[root(u + T)]);
res -= min(f[root(v)], f[root(v + T)]);
Merge(u, v);
Merge(u + T, v + T);
res += min(f[root(u)], f[root(u + T)]);
}
}
}
cout << res << "\n";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 6E5 + 10;
int n, k, l[N][2];
int fa[N], sc[N];
string s;
int find(int x) {
if (x == fa[x]) return x;
return fa[x] = find(fa[x]);
}
int cal(int x) {
int y = x <= k ? x + k : x - k;
int xx = find(x), yy = find(y);
if (xx == 0 || yy == 0) return sc[xx + yy];
return min(sc[xx], sc[yy]);
}
void merge(int x, int y) {
int xx = find(x), yy = find(y);
if (xx == 0)
fa[yy] = xx, sc[xx] += sc[yy];
else
fa[xx] = yy, sc[yy] += sc[xx];
}
int main() {
scanf("%d%d", &n, &k);
cin >> s;
for (int i = 1; i <= k; i++) fa[i] = i, fa[i + k] = i + k, sc[i + k] = 1;
for (int i = 1, c; i <= k; i++) {
scanf("%d", &c);
for (int j = 0, v; j < c; j++) {
scanf("%d", &v);
if (l[v][0])
l[v][1] = i;
else
l[v][0] = i;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (l[i][1] == 0) {
int x = l[i][0];
if (x) {
ans -= cal(x);
if (s[i - 1] == '1')
fa[find(x + k)] = 0;
else
fa[find(x)] = 0;
ans += cal(x);
}
} else {
int x = l[i][0], y = l[i][1];
if (s[i - 1] == '1') {
if (find(x) != find(y)) {
ans -= cal(x);
ans -= cal(y);
merge(x, y);
merge(x + k, y + k);
ans += cal(x);
}
} else {
if (find(x) != find(y + k)) {
ans -= cal(x);
ans -= cal(y);
merge(x, y + k);
merge(x + k, y);
ans += cal(x);
}
}
}
cout << ans << '\n';
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300000 + 10;
const int apsz = 26;
const int INF = 10000007;
const unsigned long long mod = 97;
const int maxm = 10000 + 10;
struct rev {
int c0, c1, tag;
void maintain() {
c0 = min(c0, INF);
c1 = min(c1, INF);
}
};
rev info[maxn];
int dsu[maxn];
pair<int, int> fd(int u) {
if (dsu[u] < 0) return {u, 0};
pair<int, int> tmp = fd(dsu[u]);
info[u].tag ^= tmp.second;
dsu[u] = tmp.first;
return (pair<int, int>){tmp.first, info[u].tag};
}
int st[maxn];
char s[maxn];
int n, k;
vector<int> edge[maxn];
int main(void) {
scanf("%d", &(n)), scanf("%d", &(k));
scanf("%s", s + 1);
for (int i = (1); i <= (n); ++i) st[i] = s[i] - '0';
for (int i = (1); i <= (k); ++i) {
info[i] = (rev){0, 1, 0};
dsu[i] = -1;
int sz;
scanf("%d", &(sz));
for (; sz--;) {
int x;
scanf("%d", &(x));
edge[x].push_back(i);
}
}
long long ans = 0;
for (int i = (1); i <= (n); ++i) {
int co = st[i];
if (edge[i].size() == 1) {
pair<int, int> t = fd(edge[i][0]);
int u = t.first;
ans -= min(info[u].c0, info[u].c1);
if (co == 1) {
if (t.second == 0)
info[u].c1 = INF;
else
info[u].c0 = INF;
} else if (co == 0) {
if (t.second == 0)
info[u].c0 = INF;
else
info[u].c1 = INF;
}
ans += min(info[u].c0, info[u].c1);
} else if (edge[i].size() == 2) {
pair<int, int> x, y;
x = fd(edge[i][0]);
y = fd(edge[i][1]);
if (x.first != y.first) {
if (dsu[x.first] > dsu[y.first]) swap(x, y);
ans -= min(info[x.first].c0, info[x.first].c1);
ans -= min(info[y.first].c0, info[y.first].c1);
if (co == 1) {
if (x.second != y.second) {
info[y.first].tag ^= 1;
swap(info[y.first].c0, info[y.first].c1);
}
} else {
if (x.second == y.second) {
info[y.first].tag ^= 1;
swap(info[y.first].c0, info[y.first].c1);
}
}
info[x.first].c0 += info[y.first].c0;
info[x.first].c1 += info[y.first].c1;
info[x.first].maintain();
ans += min(info[x.first].c0, info[x.first].c1);
dsu[x.first] += dsu[y.first];
dsu[y.first] = x.first;
}
}
printf("%lld\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] == u ? fa[u] : fa[u] = find(fa[u]); }
void uni(int a, int b) {
if (find(a) == find(b)) return;
val[find(b)] += val[find(a)];
fa[find(a)] = find(b);
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1, fa[i] = i, fa[i + kk] = i + kk;
fa[kk + kk + 1] = kk + kk + 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1]), uni(k[i][0] + kk, k[i][1] + kk);
ans += mix(k[i][1]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0], kk + kk + 1);
ans += val[find(k[i][0] + kk)];
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1] + kk), uni(k[i][0] + kk, k[i][1]);
ans += mix(k[i][0]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0] + kk, kk + kk + 1);
ans += mix(k[i][0]);
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] == u ? fa[u] : fa[u] = find(fa[u]); }
void uni(int a, int b) {
if (a == b) return;
val[b] += val[a];
fa[a] = b;
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1, fa[i] = i, fa[i + kk] = i + kk;
fa[kk + kk + 1] = kk + kk + 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(find(k[i][0]), find(k[i][1])),
uni(find(k[i][0] + kk), find(k[i][1] + kk));
ans += min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
} else {
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(find(k[i][0]), find(kk + kk + 1));
ans += val[find(k[i][0] + kk)];
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= min(val[find(k[i][1])], val[find(k[i][1] + kk)]);
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(find(k[i][0]), find(k[i][1] + kk)),
uni(find(k[i][1]), find(k[i][0] + kk));
ans += min(val[find(k[i][1] + kk)], val[find(k[i][0] + kk)]);
} else {
ans -= min(val[find(k[i][0])], val[find(k[i][0] + kk)]);
uni(find(k[i][0] + kk), find(kk + kk + 1));
ans += val[find(k[i][0])];
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 810000;
int fa[MAXN], val[MAXN], vec[MAXN][3];
int n, k, ans;
char str[MAXN];
int getfa(int x) {
if (fa[x] == x) return x;
return fa[x] = getfa(fa[x]);
}
void merge(int x, int y) {
int p = getfa(x), q = getfa(y);
if (p == q) return;
fa[p] = q;
val[q] += val[p];
}
int getval(int x) { return min(val[getfa(x)], val[getfa(x + k)]); }
int main() {
scanf("%d%d%s", &n, &k, str + 1);
int tc;
for (int i = 1; i <= k; i++) {
scanf("%d", &tc);
int tx;
for (int j = 1; j <= tc; j++) {
scanf("%d", &tx);
vec[tx][++vec[tx][0]] = i;
}
}
for (int i = 1; i <= k; i++) fa[i] = i, val[i] = 0;
for (int i = k + 1; i <= 2 * k; i++) fa[i] = i, val[i] = 1;
fa[k << 1 | 1] = k << 1 | 1;
val[k << 1 | 1] = 1000000;
for (int i = 1; i <= n; i++) {
if (vec[i][0] == 2) {
if (str[i] == '0') {
if (getfa(vec[i][1]) != getfa(vec[i][2] + k)) {
ans -= getval(vec[i][1]) + getval(vec[i][2]);
merge(vec[i][1], vec[i][2] + k);
merge(vec[i][1] + k, vec[i][2]);
ans += getval(vec[i][1]);
}
} else {
if (getfa(vec[i][1]) != getfa(vec[i][2])) {
ans -= getval(vec[i][1]) + getval(vec[i][2]);
merge(vec[i][1] + k, vec[i][2] + k);
merge(vec[i][1], vec[i][2]);
ans += getval(vec[i][1]);
}
}
} else if (vec[i][0] == 1) {
if (str[i] == '0') {
ans -= getval(vec[i][1]);
merge(vec[i][1], k << 1 | 1);
ans += getval(vec[i][1]);
} else {
ans -= getval(vec[i][1]);
merge(vec[i][1] + k, k << 1 | 1);
ans += getval(vec[i][1]);
}
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 69;
int n, k;
string initial;
int dsu[N];
int sz[N];
int szsame[N];
int parity[N];
int restrict[N];
vector<int> belong[N];
int curr = 0;
int getVal(int u) {
if (restrict[u] == 0) return szsame[u];
if (restrict[u] == 1) return (sz[u] - szsame[u]);
return min(szsame[u], sz[u] - szsame[u]);
}
pair<int, int> find(int u) {
if (dsu[u] != u) {
pair<int, int> res = find(dsu[u]);
dsu[u] = res.first;
if (parity[u])
parity[u] = res.second;
else
parity[u] = res.second ^ 1;
return make_pair(dsu[u], parity[u]);
}
return make_pair(u, 1);
}
int funion(int u, int v, bool same) {
pair<int, int> r1 = find(u);
pair<int, int> r2 = find(v);
if (r1.first == r2.first) return 0;
if (sz[r1.first] < sz[r2.first]) swap(r1, r2);
int init = getVal(r1.first) + getVal(r2.first);
dsu[r2.first] = r1.first;
sz[r1.first] += sz[r2.first];
bool rsame = true;
if (same && r1.second != r2.second) rsame = false;
if (!same && r1.second == r2.second) rsame = false;
if (!rsame) parity[r2.first] = 0;
if (restrict[r2.first] < 2) {
if (rsame)
restrict[r1.first] = restrict[r2.first];
else
restrict[r1.first] = restrict[r2.first] ^ 1;
}
if (rsame)
szsame[r1.first] += szsame[r2.first];
else
szsame[r1.first] += sz[r2.first] - szsame[r2.first];
return getVal(r1.first) - init;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
cin >> initial;
for (int i = 0; i < k; i++) {
int t;
cin >> t;
for (int j = 0; j < t; j++) {
int l;
cin >> l;
l--;
belong[l].push_back(i);
}
dsu[i] = i;
sz[i] = 1;
szsame[i] = 1;
parity[i] = 1;
restrict[i] = 2;
}
for (int i = 0; i < n; i++) {
if (belong[i].size() == 1) {
int u = belong[i][0];
pair<int, int> res = find(u);
int init = getVal(res.first);
if (initial[i] == '0') {
if (res.second)
restrict[res.first] = 0;
else
restrict[res.first] = 1;
} else {
if (res.second)
restrict[res.first] = 1;
else
restrict[res.first] = 0;
}
curr += getVal(res.first) - init;
} else if (belong[i].size() == 2) {
bool same = (initial[i] == '1');
int u = belong[i][0];
int v = belong[i][1];
curr += funion(u, v, same);
}
cout << curr << '\n';
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline long long read1() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int N = 3e5 + 10;
int n, k;
vector<int> q[N];
int f[N], val[N], sz[N][2], vis[N], ans;
int Find(int x) {
if (x == f[x]) return x;
Find(f[x]);
val[x] ^= val[f[x]];
f[x] = f[f[x]];
return f[x];
}
int getval(int x) {
if (vis[x] == -1)
return min(sz[x][0], sz[x][1]);
else
return sz[x][vis[x]];
}
void merge(int u, int v, int c) {
Find(u);
Find(v);
if (f[u] != f[v]) {
ans -= getval(f[u]);
ans -= getval(f[v]);
c ^= val[u] ^ val[v];
u = f[u];
v = f[v];
sz[u][0] += sz[v][c];
sz[u][1] += sz[v][1 - c];
if (vis[v] != -1 && vis[u] == -1) vis[u] = vis[v] ^ c;
f[v] = u;
val[v] = c;
ans += getval(u);
}
}
void sure(int u, int c) {
Find(u);
c ^= val[u];
u = f[u];
ans -= getval(u);
if (vis[u] == -1) vis[u] = c;
ans += getval(u);
}
char ch[N];
int main() {
n = read();
k = read();
scanf("%s", ch + 1);
for (int i = 1; i <= k; i++) {
int num = read();
while (num--) {
int x = read();
q[x].push_back(i);
}
}
for (int i = 1; i <= k; i++)
f[i] = i, sz[i][1] = 1, sz[i][0] = 0, vis[i] = -1;
for (int i = 1; i <= n; i++) {
if (q[i].size() == 2)
merge(q[i][0], q[i][1], 1 - (ch[i] - '0'));
else if (q[i].size() != 0)
sure(q[i][0], 1 - (ch[i] - '0'));
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long n, k, pa[600010], ct[600010], siz[600010], ans = 0;
vector<long long> g[300010];
string s;
long long find(long long x) {
if (x == pa[x]) return x;
pa[x] = find(pa[x]);
return pa[x];
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
cin >> s;
for (long long i = 0; i < k; i++) {
long long t;
cin >> t;
for (long long j = 0; j < t; j++) {
long long x;
cin >> x;
--x;
g[x].push_back(i);
}
}
for (long long i = 0; i < k; i++) {
ct[2 * i + 1] = 1;
ct[2 * i] = 0;
pa[2 * i] = 2 * i;
pa[2 * i + 1] = 2 * i + 1;
siz[2 * i + 1] = 1;
siz[2 * i] = 1;
}
for (long long i = 0; i < n; i++) {
long long a, b;
;
if (((long long)g[i].size()) == 2) {
a = g[i][0];
b = g[i][1];
;
;
long long x1 = find(2 * a), y1 = find(b * 2), x2 = find(2 * a + 1),
y2 = find(2 * b + 1);
if (s[i] == '0') swap(x1, x2);
;
;
if (x1 == y1) {
cout << ans << '\n';
continue;
}
ans -= (min(ct[x1], ct[x2]) + min(ct[y1], ct[y2]));
;
if (siz[x1] > siz[y1]) swap(x1, y1), swap(x2, y2);
siz[y1] += siz[x1];
pa[x1] = y1;
ct[y1] += ct[x1];
ct[x1] = 0;
siz[y2] += siz[x2];
pa[x2] = y2;
ct[y2] += ct[x2];
ct[x2] = 0;
ans += min(ct[y1], ct[y2]);
} else {
if (((long long)g[i].size()) == 0) {
cout << ans << '\n';
continue;
}
long long a = g[i][0], x, delx;
if (s[i] == '1')
x = find(2 * a), delx = find(2 * a + 1);
else
x = find(2 * a + 1), delx = find(2 * a);
ans -= min(ct[x], ct[delx]);
;
ct[delx] = 1e10;
ans += ct[x];
}
cout << ans << '\n';
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)3e5 + 10;
int par[maxn << 1], num[maxn << 1];
inline void makeSet(int size) {
for (int i = 1; i <= size; i++) {
par[i] = i;
}
}
inline int find(int x) {
int k, j, r;
r = x;
while (r != par[r]) {
r = par[r];
}
k = x;
while (k != r) {
j = par[k];
par[k] = r;
k = j;
}
return r;
}
inline void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) {
return;
}
par[x] = y;
num[y] += num[x];
}
inline int calc(int x, int k) { return min(num[find(x)], num[find(x + k)]); }
int belong[maxn][2];
char s[maxn];
int main() {
int n, k, c, tmp;
scanf("%d%d%s", &n, &k, s + 1);
for (int i = 1; i <= k; ++i) {
scanf("%d", &c);
for (int j = 0; j < c; ++j) {
scanf("%d", &tmp);
if (belong[tmp][0]) {
belong[tmp][1] = i;
} else {
belong[tmp][0] = i;
}
}
num[i] = 1;
}
makeSet(k << 1 | 1);
num[k << 1 | 1] = 0x3f3f3f3f;
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (belong[i][1]) {
if (s[i] == '0' && find(belong[i][0]) != find(belong[i][1] + k)) {
ans -= calc(belong[i][0], k) + calc(belong[i][1], k);
unite(belong[i][0], belong[i][1] + k);
unite(belong[i][1], belong[i][0] + k);
ans += calc(belong[i][0], k);
} else if (s[i] == '1' && find(belong[i][0]) != find(belong[i][1])) {
ans -= calc(belong[i][0], k) + calc(belong[i][1], k);
unite(belong[i][0], belong[i][1]);
unite(belong[i][0] + k, belong[i][1] + k);
ans += calc(belong[i][0], k);
}
} else if (belong[i][0]) {
ans -= calc(belong[i][0], k);
if (s[i] == '0') {
unite(belong[i][0] + k, k << 1 | 1);
} else {
unite(belong[i][0], k << 1 | 1);
}
ans += calc(belong[i][0], k);
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, inf = 0x3f3f3f3f;
int n, K, m, x, pos[N][2], ans, fa[N], val[N];
char s[N];
int getfa(int x) { return fa[x] == x ? x : fa[x] = getfa(fa[x]); }
void add(int x, int y) {
int fx = getfa(x), fy = getfa(y);
if (fx != fy) fa[fx] = fy, val[fy] += val[fx];
}
int calc(int x) { return min(val[getfa(x)], val[getfa(x + K)]); }
int main() {
cin >> n >> K;
scanf("%s", s + 1);
for (int i = 1; i <= K; i++) {
scanf("%d", &m);
for (int j = 1; j <= m; j++) {
scanf("%d", &x);
if (pos[x][0])
pos[x][1] = i;
else
pos[x][0] = i;
}
}
for (int i = 0; i <= 2 * K + 1; i++) {
fa[i] = i;
if (i > K) val[i] = 1;
}
val[2 * K + 1] = inf;
for (int i = 1; i <= n; i++) {
if (!pos[i][0]) {
printf("%d\n", ans);
continue;
}
if (!pos[i][1]) {
ans -= calc(pos[i][0]);
if (s[i] == '1')
add(pos[i][0] + K, 2 * K + 1);
else
add(pos[i][0], 2 * K + 1);
ans += calc(pos[i][0]);
} else {
int x = pos[i][0], y = pos[i][1];
if (getfa(x) != getfa(y) && getfa(x) != getfa(y + K)) {
ans -= calc(x) + calc(y);
if (s[i] == '1')
add(x, y), add(x + K, y + K);
else
add(x, y + K), add(x + K, y);
ans += calc(x);
}
}
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct perem {
long long t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
long long n, k, m, c, vas, cc = 1000000;
vector<long long> vv;
string s;
vector<vector<long long>> la;
vector<perem> pr;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
la.resize(n, vector<long long>(0));
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() == 2) {
long long a = la[i][0], b = la[i][1];
bool b1 = 0;
while (a != -1) {
b1 ^= pr[a].q;
if (pr[a].p != -1)
a = pr[a].p;
else
break;
}
bool b2 = 0;
while (b != -1) {
b2 ^= pr[b].q;
if (pr[b].p != -1)
b = pr[b].p;
else
break;
}
if (a != b) {
b1 ^= b2;
long long kl = 0;
if ((b1 and s[i] == '1') or (!b1 and s[i] == '0')) {
if (pr[a].l < pr[b].l) {
vas += pr[a].l;
pr[a].q ^= 1;
} else {
vas += pr[b].l;
pr[b].q ^= 1;
}
kl = abs(pr[a].l - pr[b].l);
} else {
kl = min(pr[a].l + pr[b].l, cc);
}
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
} else if (la[i].size() == 1) {
bool b = 0;
int a = la[i][0];
while (a != -1) {
b ^= pr[a].q;
if (pr[a].p != -1)
a = pr[a].p;
else
break;
}
if ((b and s[i] == '1') or (!b and s[i] == '0')) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
}
if (i)
vv.emplace_back(vv.back() + vas);
else
vv.emplace_back(vas);
}
for (long long i : vv) cout << i << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class t>
inline t read(t &x) {
x = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0) {
putchar('-'), write(-x);
} else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const long long N = 3e5 + 5;
long long n, k, SsEeTt[N][3], f[N << 1], sz[N << 1], s[N], ans, oo;
inline long long min(const long long &x, const long long &y) {
return x < y ? x : y;
}
inline long long getf(const long long &x) {
return f[x] == x ? x : f[x] = getf(f[x]);
}
signed main() {
read(n);
oo = read(k);
for (long long i = 1; i <= n; i++) scanf("%1d", &s[i]);
for (long long i = 1, n, x; i <= k; i++) {
read(n);
while (n--) {
read(x);
if (!SsEeTt[x][1])
SsEeTt[x][1] = i;
else
SsEeTt[x][2] = i;
}
}
for (long long i = 1; i <= k; i++) {
f[i * 2 - 1] = i * 2 - 1;
f[i << 1] = i << 1;
sz[i << 1] = 1;
}
for (long long i = 1, fx, fy, gx, gy; i <= n; i++) {
if (SsEeTt[i][2]) {
if (!s[i]) {
fx = getf(SsEeTt[i][1] * 2 - 1), fy = getf(SsEeTt[i][2] << 1);
if (fx == fy) {
write(ans);
puts("");
continue;
}
gx = getf(SsEeTt[i][1] << 1), gy = getf(SsEeTt[i][2] * 2 - 1);
} else {
fx = getf(SsEeTt[i][1] * 2 - 1), fy = getf(SsEeTt[i][2] * 2 - 1);
if (fx == fy) {
write(ans);
puts("");
continue;
}
gx = getf(SsEeTt[i][1] << 1), gy = getf(SsEeTt[i][2] << 1);
}
ans -= min(sz[fx], sz[gx]) + min(sz[fy], sz[gy]);
f[fx] = fy;
f[gx] = gy;
sz[fy] += sz[fx];
sz[gy] += sz[gx];
ans += min(sz[fy], sz[gy]);
} else if (SsEeTt[i][1]) {
long long fx = getf(SsEeTt[i][1] * 2 - 1), fy = getf(SsEeTt[i][1] * 2);
ans -= min(sz[fx], sz[fy]);
if (!s[i])
sz[fx] += oo;
else
sz[fy] += oo;
ans += min(sz[fx], sz[fy]);
}
write(ans);
puts("");
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5, inf = 1e9;
int n, kk, s, x, k[N][2];
char ch[N];
int fa[N << 1], val[N << 1];
int find(int u) { return fa[u] ? fa[u] = find(fa[u]) : u; }
void uni(int a, int b) {
if (find(a) == find(b)) return;
val[find(b)] += val[find(a)];
fa[find(a)] = find(b);
}
int mix(int a) { return min(val[find(a)], val[find(a + kk)]); };
int main() {
scanf("%d%d%s", &n, &kk, ch + 1);
for (int i = 1; i <= kk; i++) {
scanf("%d", &s);
while (s--) {
scanf("%d", &x);
k[x][bool(k[x][0])] = i;
}
}
for (int i = 1; i <= kk; i++) val[i] = 1;
val[kk + kk + 1] = inf;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (k[i][0] == 0) goto qwq;
if (ch[i] == '1') {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1])) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1]), uni(k[i][0] + kk, k[i][1] + kk);
ans += mix(k[i][0]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0], kk + kk + 1);
ans += val[find(k[i][0] + kk)];
}
} else {
if (k[i][1]) {
if (find(k[i][0]) == find(k[i][1] + kk)) goto qwq;
ans -= mix(k[i][0]) + mix(k[i][1]);
uni(k[i][0], k[i][1] + kk), uni(k[i][0] + kk, k[i][1]);
ans += mix(k[i][0]);
} else {
ans -= mix(k[i][0]);
uni(k[i][0] + kk, kk + kk + 1);
ans += mix(k[i][0]);
}
}
qwq:
printf("%d\n", ans);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 300000 + 10;
char s[N];
int par[N], diff[N];
pair<int, int> find(int x) {
if (par[x] == x) return {x, 0};
auto r = find(par[x]);
par[x] = r.first, diff[x] ^= r.second;
return {par[x], diff[x]};
}
int f[N][2], col[N], ans;
int get(int x) {
if (col[x] == -1) return min(f[x][0], f[x][1]);
return f[x][col[x]];
}
vector<int> p[N];
int main() {
int n, k;
scanf("%d%d", &n, &k);
scanf("%s", s + 1);
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
for (int j = 1; j <= x; j++) {
int y;
scanf("%d", &y);
p[y].push_back(i);
}
}
for (int i = 1; i <= k; i++)
par[i] = i, diff[i] = 0, f[i][0] = 0, f[i][1] = 1, col[i] = -1;
for (int i = 1; i <= n; i++) {
if ((int)p[i].size() == 0)
;
else if ((int)p[i].size() == 1) {
int x = p[i][0], y = find(x).first;
ans -= get(y);
col[y] = diff[x] ^ (s[i] == '0');
ans += get(y);
} else {
int x = find(p[i][0]).first, y = find(p[i][1]).first;
if (x != y) {
ans -= get(x), ans -= get(y);
par[x] = y;
diff[x] = (s[i] == '0') ^ diff[p[i][0]] ^ diff[p[i][1]];
f[y][0] += f[x][0 ^ diff[x]], f[y][1] += f[x][1 ^ diff[x]];
if (col[x] != -1) col[y] = col[x] ^ diff[x];
ans += get(y);
}
}
printf("%d\n", ans);
}
}
| 11 | CPP |
from sys import stdin
input = stdin.readline
n , k = [int(i) for i in input().split()]
pairs = [i + k for i in range(k)] + [i for i in range(k)]
initial_condition = list(map(lambda x: x == '1',input().strip()))
data = [i for i in range(2*k)]
constrain = [-1] * (2*k)
h = [0] * (2*k)
L = [1] * k + [0] * k
dp1 = [-1 for i in range(n)]
dp2 = [-1 for i in range(n)]
for i in range(k):
input()
inp = [int(j) for j in input().split()]
for s in inp:
if dp1[s-1] == -1:dp1[s-1] = i
else:dp2[s-1] = i
pfsums = 0
ans = []
def remove_pfsum(s1):
global pfsums
if constrain[s1] == 1:
pfsums -= L[s1]
elif constrain[pairs[s1]] == 1:
pfsums -= L[pairs[s1]]
else:
pfsums -= min(L[s1],L[pairs[s1]])
def sh(i):
while i != data[i]:
i = data[i]
return i
def upd_pfsum(s1):
global pfsums
if constrain[s1] == 1:
pfsums += L[s1]
elif constrain[pairs[s1]] == 1:
pfsums += L[pairs[s1]]
else:
pfsums += min(L[s1],L[pairs[s1]])
def ms(i,j):
i = sh(i) ; j = sh(j)
cons = max(constrain[i],constrain[j])
if h[i] < h[j]:
data[i] = j
L[j] += L[i]
constrain[j] = cons
return j
else:
data[j] = i
if h[i] == h[j]:
h[i] += 1
L[i] += L[j]
constrain[i] = cons
return i
for i in range(n):
if dp1[i] == -1 and dp2[i] == -1:
pass
elif dp2[i] == -1:
s1 = sh(dp1[i])
remove_pfsum(s1)
constrain[s1] = 0 if initial_condition[i] else 1
constrain[pairs[s1]] = 1 if initial_condition[i] else 0
upd_pfsum(s1)
else:
s1 = sh(dp1[i]) ; s2 = sh(dp2[i])
if s1 == s2 or pairs[s1] == s2:
pass
else:
remove_pfsum(s1)
remove_pfsum(s2)
if initial_condition[i]:
new_s1 = ms(s1,s2)
new_s2 = ms(pairs[s1],pairs[s2])
else:
new_s1 = ms(s1,pairs[s2])
new_s2 = ms(pairs[s1],s2)
pairs[new_s1] = new_s2
pairs[new_s2] = new_s1
upd_pfsum(new_s1)
ans.append(pfsums)
for i in ans:
print(i)
| 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int test = 0;
const int MAXN = 300009;
const long long MOD = 119 << 23 | 1;
class {
public:
vector<int> V[MAXN];
int fa[MAXN * 2], cnt[MAXN * 2];
int n, m;
int curset[MAXN * 2], ans;
int findfa(int x) {
if (fa[x] == x) return x;
return fa[x] = findfa(fa[x]);
}
void merge(int x, int y) {
x = findfa(x);
y = findfa(y);
if (x == y) return;
if (x > y) swap(x, y);
fa[y] = x;
cnt[x] += cnt[y];
}
void solve() {
cin >> n >> m;
string s;
cin >> s;
for (int i = 1; i <= m; ++i) {
int c;
cin >> c;
for (int j = 0; j < c; ++j) {
int v;
cin >> v;
V[v].push_back(i);
}
fa[i] = i;
fa[i + m] = i + m;
cnt[i + m] = 1;
}
ans = 0;
for (int i = 1; i <= n; ++i) {
bool on = s[i - 1] == '1';
if (V[i].size() == 1) {
int p = V[i][0];
if (on) {
del(p);
del(p + m);
merge(p + m, 0);
add(p);
} else {
del(p);
del(p + m);
merge(p, 0);
add(p);
}
} else if (V[i].size() == 2) {
int p0 = V[i][0], p1 = V[i][1];
if (on) {
del(p0);
del(p1);
del(p1 + m);
del(p0 + m);
merge(p0, p1);
merge(p0 + m, p1 + m);
add(p0);
} else {
del(p0);
del(p1);
del(p1 + m);
del(p0 + m);
merge(p0, p1 + m);
merge(p0 + m, p1);
add(p0);
}
}
cout << ans << '\n';
}
}
void add(int x) {
int y = x + m;
x = findfa(x);
y = findfa(y);
if (x == 0)
curset[y] = 1, ans += cnt[y];
else if (y == 0)
curset[x] = 1, ans += cnt[x];
else if (cnt[x] > cnt[y])
curset[y] = 1, ans += cnt[y];
else
curset[x] = 1, ans += cnt[x];
}
void del(int x) {
x = findfa(x);
if (curset[x]) {
ans -= cnt[x];
curset[x] = 0;
}
}
} NSPACE;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
NSPACE.solve();
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct perem {
int t = 0, l = 1, p = -1, q = 0;
};
ifstream fin("AAtest.in.txt");
int n, k, m, c, vas, cc = 1000000, kl;
vector<int> vv;
string s;
vector<vector<int>> la;
vector<perem> pr;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> k >> s;
la.resize(n, vector<int>(0));
pr.resize(k);
for (int(i) = (0); ((i)) < ((k)); ((i))++) {
cin >> m;
for (int(j) = (0); ((j)) < ((m)); ((j))++) {
cin >> c;
la[c - 1].emplace_back(i);
}
}
for (int(i) = (0); ((i)) < ((n)); ((i))++) {
vas = 0;
if (la[i].size() > 0) {
int a = la[i][0];
bool b1 = s[i] == '1' ? 1 : 0;
while (a != -1) {
b1 ^= pr[a].q;
if (pr[a].p != -1)
a = pr[a].p;
else
break;
}
if (la[i].size() == 1) {
if (!b1) {
vas += pr[a].l;
pr[a].q ^= 1;
}
pr[a].l = cc;
} else {
int b = la[i][1];
while (b != -1) {
b1 ^= pr[b].q;
if (pr[b].p != -1)
b = pr[b].p;
else
break;
}
if (a != b) {
if (!b1) {
if (pr[a].l > pr[b].l) swap(a, b);
vas += pr[a].l;
pr[a].q ^= 1;
kl = abs(pr[a].l - pr[b].l);
} else
kl = min(pr[a].l + pr[b].l, cc);
if (pr[a].t < pr[b].t) swap(a, b);
if (pr[a].q) pr[b].q ^= 1;
if (pr[a].t == pr[b].t) pr[a].t++;
pr[a].l = kl;
pr[b].p = a;
}
}
}
if (i)
vv.emplace_back(vv.back() + vas);
else
vv.emplace_back(vas);
}
for (int i : vv) cout << i << endl;
}
| 11 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.