洛谷1197并查集拆集合

链接：https://www.luogu.org/problemnew/show/P1197

题意：一张图，拆开若干次点，问每次拆开后连通分量的个数。

思路：刚开始想着并查集这么拆集合，后来发现拆集合不好拆，【正难则反】，我们可以反过来思考，拆点变成加点。

开始把不在破坏序列的点的边连上。处理集合数量。

然后再安装拆点的逆顺序加点，用并查集维护加点的影响

#include <bits/stdc++.h>

using namespace std;
const int maxn = 1e6 + 7;
const int maxm = 1e6 + 7;

int n, m, first[maxn], sign, pre[maxn];

int hit[maxn];
bool broke[maxn];

struct Edge {
    int to, w, next;
} edge[maxm];

void init() {
    for(int i = 0; i < n; i ++ ) {
        first[i] = -1;
    }
    sign = 0;
}

void add_edge(int u, int v, int w) {
    edge[sign].to = v;
    edge[sign].w = w;
    edge[sign].next = first[u];
    first[u] = sign ++;
}

void init_disjoint_set() {
    for(int i = 0; i < n; i ++ ) {
        pre[i] = i;
    }
}

int findx(int x) {
    return pre[x] == x ? x : pre[x] = findx(pre[x]);
}

void join(int x, int y) {
    int fx = findx(x), fy = findx(y);
    if(fx != fy) {
        pre[fx] = fy;
    }
}

bool same(int x, int y) {
    return findx(x) == findx(y);
}

int main()
{
    while(~scanf("%d %d", &n, &m)) {
        init();
        init_disjoint_set();
        for(int i = 1; i <= m; i ++ ) {
            int u, v;
            scanf("%d %d", &u, &v);
            add_edge(u, v, 1);
            add_edge(v, u, 1);
        }
        int num;
        memset(hit, 0, sizeof(hit));
        memset(broke, 0, sizeof(broke));
        scanf("%d", &num);
        for(int i = 1; i <= num; i ++ ) {
            scanf("%d", &hit[i]);
            broke[ hit[i] ] = 1;
        }
        int tot = n - num;
        for(int i = 0; i < n; i ++ ) {
            if(broke[i]) {
                continue;
            }
            for(int j = first[i]; ~j; j = edge[j].next) {
                int to = edge[j].to;
                if(broke[to]) {
                    continue;
                }
                if(!same(to, i)) {
                    join(to, i);
                    tot --;
                }
            }
        }
        stack<int>s;
        s.push(tot);
        for(int i = num; i >= 1; i -- ) {
            int x = hit[i];
            int cnt = 0;
            for(int j = first[x]; ~j; j = edge[j].next) {
                int to = edge[j].to;
                if(broke[to]) {
                    continue;
                }
                if(!same(x, to)) {
                    join(x, to);
                    cnt ++;
                }
            }
            tot = tot - (cnt - 1);
            broke[x] = 0;
            s.push(tot);
        }
        while(!s.empty()) {
            printf("%d
", s.top());
            s.pop();
        }
    }

    return 0;
}