带撤销并查集 & 可持久化并查集

带撤销并查集支持从某个元素从原来的集合中撤出来，然后加入到一个另外一个集合中，或者删除该元素

用一个映射来表示元素和并查集中序号的关系，代码中用\(to[x]\) 表示x号元素在并查集中的 id

删除 x 号元素时，需要将 \(to[x]\) 的集合大小减去1，然后令 \(to[x]=-1\) 标记 x 删除即可

如果要重新加入一个元素，那么给x分配一个新的 id，\(to[x] = newid\)

例题1：https://www.cometoj.com/contest/33/problem/E?problem_id=1459

#include <bits/stdc++.h>
using namespace std;
const int N = 4000010;
int fa[N],to[N],sz[N],cnt,a[N],b[N],tot;
int n,m,k,x,y;
int ok[N];
int find(int x){
    return x == fa[x]?x:fa[x] = find(fa[x]);
}
void merge(int x,int y){
    int a = find(to[x]);
    int b = find(to[y]);
    if(a==b) return;
    fa[b] = a;
    sz[a] += sz[b]; sz[b] = 0;
}
// 将x从原集合删除，加入到 y 所属的集合
void update(int x,int y){
    sz[find(to[x])]--;
    to[x] = ++cnt;//给x分配新的 id
    sz[cnt] = 1;
    fa[cnt] = cnt;
    merge(x,y);
}
int main(){
    scanf("%d%d",&n,&m);cnt = n;
    for(int i=1;i<=n;i++)fa[i] = i,to[i] = i,sz[i] = 1;
    for(int i=1;i<=m;i++){
        scanf("%d%d",&k,&x);if(k!=3)scanf("%d",&y);
        if(k == 5){
            a[++tot] = x;
            b[tot] = y;continue;
        }
        if(k == 1)merge(x,y);
        if(k == 2)update(x,y);
        if(k == 4){
            if(find(to[x]) == find(to[y]))printf("Yes\n");
            else printf("No\n");
        }

        if(k == 3)printf("%d\n",sz[find(to[x])]-1);
    }

    for(int i=1;i<=tot;i++){
        if(find(to[a[i]]) == find(to[b[i]])) ok[find(to[a[i]])] = 1;
    }
    int res = -1;
    for(int i=1;i<=n;i++)
        if(!ok[find(to[i])])res = max(res,sz[find(to[i])]);
    cout<<res<<endl;
    return 0;
}

例题2：https://nanti.jisuanke.com/t/42576

[2019南昌区域赛A]

不要求在线的可持久化操作，可以离线处理询问，按照正常的时间顺序维护并查集，由于需要回溯，所以不能使用路径压缩

复杂度 \(O(m\log n)\)

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
#define dbg(x...) do { cout << "\033[32;1m" << #x <<" -> "; err(x); } while (0)
void err() { cout << "\033[39;0m" << endl; }
template<class T, class... Ts> void err(const T& arg,const Ts&... args) { cout << arg << " "; err(args...); }
const int N = 1000000 + 50;
struct Node{
    int op, x, y;
}o[N];
vector<int> g[N];
int n, m;
int fa[N*2], dep[N*2], sz[N*2], to[N], tot;
int res[N];
int find(int x){
    if(x == fa[x]) return x;
    return find(fa[x]);
}
/*
1 k a b merge(a, b)
2 k a  del(a)
3 k a b merge(a,b)
4 k a b find(a) == find(b)
5 k a  sz[a]
*/
void dfs(int u){
    for(auto id : g[u]){
        int op = o[id].op, x = o[id].x, y = o[id].y;
        if(op == 1){
            if(to[x] == -1 || to[y] == -1){
                dfs(id);
                continue;
            }
            int rx = find(to[x]), ry = find(to[y]);
            if(rx == ry){ dfs(id); continue;}
            else if(dep[rx] == dep[ry]){
                fa[ry] = rx; sz[rx] += sz[ry]; dep[rx] ++;
                dfs(id);
                fa[ry] = ry; sz[rx] -= sz[ry]; dep[rx] --;
            } else {
                if(dep[rx] < dep[ry]) swap(rx, ry);
                fa[ry] = rx; sz[rx] += sz[ry];
                dfs(id);
                fa[ry] = ry; sz[rx] -= sz[ry];
            }
        } else if(op == 2){
            if(to[x] == -1) { dfs(id); continue; }
            int rx = find(to[x]);
            int t = to[x];
            to[x] = -1;
            sz[rx] --;
            dfs(id);
            to[x] = t;
            sz[rx] ++;
        } else if(op == 3){
            if(to[x] == - 1 || to[y] == -1) {dfs(id); continue; }
            int t = to[x];
            int rx = find(to[x]), ry = find(to[y]);
            sz[rx]--;
            to[x] = ++tot;
            sz[to[x]] = 1;
            fa[to[x]] = ry;
            sz[ry] ++;
            dfs(id);
            sz[ry] --;
            sz[rx] ++;
            to[x] = t;
        } else {
            if(op == 4){
                if(to[x] == -1 || to[y] == -1){
                    res[id] = 0;
                } else {
                    res[id] = find(to[x]) == find(to[y]);
                }
            } else if(op == 5){
                if(to[x] == -1) res[id] = 0;
                else {
                    res[id] = sz[find(to[x])];
                }
            }
            dfs(id);
        }
    }
}
int main(){
    scanf("%d%d", &n, &m);
    for(int i=1;i<=m;i++){
        int op, k, x, y = 0;scanf("%d%d%d", &op, &k, &x);
        g[k].push_back(i);
        if(op != 2 && op != 5) scanf("%d", &y);
        o[i] = {op, x, y};
    }
    for(int i=1;i<=n;i++) to[i] = i, fa[i] = i, sz[i] = 1;
    tot = n;
    dfs(0);
    for(int i=1;i<=m;i++){
        if(o[i].op == 4) puts(res[i] ? "Yes" : "No");
        else if(o[i].op == 5){
            printf("%d\n", res[i]);
        }
    }
    return 0;
}

可持久化并查集支持查询任一历史版本的信息。并查集信息用数组 \(fa\) 表示，合并集合时，基本操作有两种，一个是路径压缩（可能会修改很多个fa），一个是按秩合并（启发式合并思路，小的集合向大的合并，只会修改一次fa），由于要保存历史信息，按照可持久化的一贯思路，每一次操作都会新开 logn 的空间，所以这里要用按秩合并。

注意按秩合并的find函数写法也有所不同，不能修改fa

此时问题就是维护每个版本的fa数组

模版题：https://www.luogu.com.cn/problem/P3402

const int N = 200000 + 5;
int n, m;
struct TreeNode{
    int l, r;
}t[N*30];
int root[N], tot;
int fa[N*30], dep[N*30];
void build(int &p, int l, int r){
    p = ++tot;
    if(l == r){fa[p] = l;return;}
    int mid = l + r >> 1;
    build(t[p].l, l, mid);
    build(t[p].r, mid+1, r);
}
// 修改p版本的pos位置的fa值
void change(int last, int &p, int l, int r, int pos, int val){
    p = ++tot;
    t[p] = t[last];
    if(l == r){
        fa[p] = val;
        dep[p] = dep[last];
        return;
    }
    int mid = l + r >> 1;
    if(pos <= mid)
        change(t[last].l, t[p].l, l, mid, pos, val);
    else
        change(t[last].r, t[p].r, mid+1, r, pos, val);
}
int getIndex(int p, int l, int r,int pos){
    if(l == r) return p;
    int mid = l + r >> 1;
    if(pos <= mid) return getIndex(t[p].l, l, mid, pos);
    else return getIndex(t[p].r, mid+1, r, pos);
}
int find(int p, int x){
    int index = getIndex(p, 1, n, x);
    if(fa[index] == x) return index; // 返回祖先节点下标
    return find(p, fa[index]);
}
void merge(int last, int &p, int x, int y){
    int fx = find(p, x), fy = find(p, y);
    if(fa[fx] == fa[fy]) return;
    // x-> y合并，需要满足 dep[x]<dep[y]
    if(dep[fx] > dep[fy]) swap(fx, fy);
    change(last, p, 1, n, fa[fx], fa[fy]);
    if(dep[fx] == dep[fy]){
        dep[getIndex(p, 1, n, fa[fy])]++;
    }
}
int main(){
    scanf("%d%d", &n, &m);
    build(root[0], 1, n);
    for(int i=1;i<=m;i++){
        root[i] = root[i-1];
        int op, x, y;scanf("%d%d", &op, &x);
        if(op == 1){
            scanf("%d", &y);
            merge(root[i], root[i], x, y);
        }
        else if(op == 2) root[i] = root[x];
        else {
            scanf("%d", &y);
            int fx = find(root[i], x), fy = find(root[i], y);
            if(fa[fx] == fa[fy]) puts("1");
            else puts("0");
        }
    }
    return 0;
}

例题：https://www.luogu.com.cn/problem/P4768

先跑一次最短路，然后按照边权从大到小用带权并查集维护集合到源点的最短距离。保留所有版本的信息，然后对于每次查询找到对应版本号回答问题即可

复杂度：\(O(n\log m + (m+q) \log^2n)\)