[Codeforces1290C]Prefix Enlightenment

一盏灯最多只会在$2$个集合里出现。

设包含第$i$盏灯的两个集合依次为$L_i,R_i$（若没有则值为$0$）。设$o{p}_S=1$表示集合$S$选过，$o{p}_S=0$表示没选过。

对于第$i$盏灯的情况进行讨论

1. $L_i=0,R_i=0$,说明这盏灯不属于任何集合且$s_i$一定为$1$,故答案不变。
2. $L_i\ne 0,R_i=0$，说明这盏灯只由一个集合控制。如果$o{p}_{L_i}=1\wedge s_i=1$，那么一定要撤销$L_i$的选择。如果$o{p}_{L_i}=0\wedge s_i=0$，那么一定要选$L_i$。其余两种情况，$L_i$状态必须不变。前两种情况，即$o{p}_{L_i}=s_i$时会使得与$L_i$有关联的集合状态发生改变，故答案会发生改变；而后两种不变。
3. $L_i\ne 0,R_i\ne 0$,说明这盏灯只由两个集合同时控制，所以这两个集合有关联.与$2.$同理讨论可得：如果$o{p}_{L_i}\oplus o{p}_{R_i}=s_i$，那么其中一个集合的状态一定要发生改变，优先选择改变总操作次数少且与之关联的集合能够改变状态的集合，答案加上这部分开销。否则，两个集合状态都可以不变，故答案不变。

对于关联性问题,常常使用并查集来解决。

设$Cos{t}_u$表示改变改变集合$u$状态的总代价，$Can{t}_u$表示集合$u$的状态是不是不能改变。

1. 根节点集合$u$的状态要改变，则并查集里所有集合的状态都要取反，这样才能确保不影响$s_{1...i}$。花费代价$Cos{t}_u$，然后$Cos{t}_u$变为其相反数,表示之后撤销的代价.取反可以在根节点打上一个$tag$，子树里的点的实际状态都是原来的状态异或上根节点的$tag$。
2. 由于有合并操作，故某点$x$的实际状态为：$x$到根节点路径上所有节点的$tag$值的异或和。对于一个并查集，只有根节点的$tag$值在之后可能会发生改变，故可以将$x$到根节点儿子这一段$tag$值的异或和合并起来，即路径压缩过程中不引入根节点的$tag$。
3. 将并查集$x$合并到$y$上：$Cost$累加；$Cant$取或；$ta{g}_x$异或上$ta{g}_y$，以确保$x$的子节点状态不变.

时间复杂度$O(n\alpha (m))$

#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
typedef int arr[N];
int n, m, Ans;
char s[N];
arr L, R, fa, tag, Cant, Cost, Size;
inline int Gf(int x) {
    if (!fa[x])
        return x;
    if (!fa[fa[x]]) // 跳过根节点的tag
        return fa[x];
    int p = Gf(fa[x]);
    tag[x] ^= tag[fa[x]];
    return fa[x] = p;
}
inline void Merge(int a, int b) {
    fa[a] = b, 
	Size[b] += Size[a], 
	Cost[b] += Cost[a], 
	Cant[b] |= Cant[a],
    tag[a] ^= tag[b];
}
inline int op(int x) { return tag[x] ^ tag[fa[x]]; }
inline int Calc(int i) {
    if (!L[i])
        return Ans;
    if (!R[i]) {
        int x = Gf(L[i]);
        Cant[x] = 1;
        if (op(L[i]) == (s[i] - '0'))
            Ans += Cost[x], tag[x] ^= 1, Cost[x] = -Cost[x];
        return Ans;
    }
    int x = Gf(L[i]), y = Gf(R[i]);
    if (Size[x] > Size[y])
        swap(x, y);
    if (x == y)
        return Ans;
    if ((op(L[i]) ^ op(R[i])) == s[i] - '0') {
        int Cx = Cost[x], Cy = Cost[y];
        if ((Cx < Cy && !Cant[x]) || Cant[y])
            Ans += Cx, tag[x] ^= 1, Cost[x] = -Cx;
        else
            Ans += Cy, tag[y] ^= 1, Cost[y] = -Cy;
    }
    Merge(x, y);
    return Ans;
}
int main() {
    scanf("%d%d%s", &n, &m, s + 1);
    for (int i = 1, c; i <= m; ++i) {
        scanf("%d", &c);
        for (int x; c--;)
            scanf("%d", &x), L[x] ? R[x] = i : L[x] = i;
    }
    for (int i = 1; i <= m; ++i)
        Size[i] = Cost[i] = 1;
    for (int i = 1; i <= n; ++i)
        printf("%d\n", Calc(i));
    return 0;
}