洛谷P3402 【模板】可持久化并查集 [主席树，并查集]

　　题目传送门

可持久化并查集

n个集合 m个操作

操作：

• 1 a b 合并a,b所在集合

• 2 k 回到第k次操作之后的状态(查询算作操作)

• 3 a b 询问a,b是否属于同一集合，是则输出1否则输出0

输入输出格式

输入格式：

输出格式：

输入输出样例

输入样例#1：

5 6
1 1 2
3 1 2
2 0
3 1 2
2 1
3 1 2

输出样例#1：

1
0
1

说明

$1 \le n \le 10^5, 1 \le m \le 2 \times 10^5$

By zky 出题人大神犇

---

　　分析：

　　解锁并查集的新姿势——可持久化并查集。

　　其实大部分的可持久化数据结构都是可以由主席树和可持久化平衡树实现的，所以只要能把主席树理解透彻了，其他的也差不多就不难理解了。本体的关键在于用主席树维护并查集的$fa[]$数组，同时还要注意不能路径压缩，否则会挂的很惨。另外，为了保证时间复杂度，还需要采用按秩合并，$rk[]$数组同样用主席树维护。

　　Code：

　　

//It is made by HolseLee on 8th Aug 2018
//Luogu.org P3402
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<iomanip>
#include<algorithm>
#pragma GCC optimize(2)
using namespace std;
 
const int N=1e5+;
int n,m,tot,fa[N*],rk[N*],root[N*];
struct Seg{
    int ls,rs;
};
struct President{
    Seg t[N*];
 
    inline void build(int &rt,int l,int r)
    {
        rt=++tot;
        if(l==r){
            fa[rt]=l;return;
        }
        int mid=(l+r)>>;
        build(t[rt].ls,l,mid);
        build(t[rt].rs,mid+,r);
    }
 
    inline void update(int &rt,int las,int l,int r,int pos,int f)
    {
        rt=++tot;t[rt].ls=t[las].ls,t[rt].rs=t[las].rs;
        if(l==r){
            fa[rt]=f;rk[rt]=rk[las];
            return;
        }
        int mid=(l+r)>>;
        if(pos<=mid)update(t[rt].ls,t[las].ls,l,mid,pos,f);
        else update(t[rt].rs,t[las].rs,mid+,r,pos,f);
    }
 
    inline int quary(int rt,int l,int r,int pos)
    {
        if(l==r)return rt;
        int mid=(l+r)>>;
        if(pos<=mid)return quary(t[rt].ls,l,mid,pos);
        else return quary(t[rt].rs,mid+,r,pos);
    }
 
    inline int find(int i,int x)
    {
        int f=quary(root[i],,n,x);
        if(x==fa[f])return f;
        return find(i,fa[f]);
    }
 
    inline void pushup(int rt,int l,int r,int pos)
    {
        if(l==r){
            rk[rt]++;
            return;
        }
        int mid=(l+r)>>;
        if(pos<=mid)pushup(t[rt].ls,l,mid,pos);
        else pushup(t[rt].rs,mid+,r,pos);
    }
}T;
 
inline int read()
{
    char ch=getchar();int num=;bool flag=false;
    while(ch<''||ch>''){if(ch=='-')flag=true;ch=getchar();}
    while(ch>=''&&ch<=''){num=num*+ch-'';ch=getchar();}
    return flag?-num:num;
}
 
int main()
{
    n=read();m=read();
    T.build(root[],,n);
    int op,x,y;
    for(int i=;i<=m;++i){
        op=read();
        switch (op){
            case : root[i]=root[i-];
            x=read(),y=read();x=T.find(i,x),y=T.find(i,y);
            if(fa[x]==fa[y])continue;
            if(rk[x]>rk[y])swap(x,y);
            T.update(root[i],root[i-],,n,fa[x],fa[y]);
            if(rk[x]==rk[y])T.pushup(root[i],,n,fa[y]);
                break;
 
            case :
            x=read();root[i]=root[x];
                break;
 
            case : root[i]=root[i-];
            x=read(),y=read();x=T.find(i,x),y=T.find(i,y);
            if(fa[x]==fa[y])printf("1\n");else printf("0\n");
                break;
        }
    }
    return ;
}