【bzoj3673】可持久化并查集 by zky

Time Limit: 5 Sec Memory Limit: 128 MB

n个集合 m个操作
操作：
1 a b 合并a,b所在集合
2 k 回到第k次操作之后的状态(查询算作操作)
3 a b 询问a,b是否属于同一集合，是则输出1否则输出0

0<n,m<=2*10^4

Input

Output

Sample Input

5 6

1 1 2

3 1 2

2 0

3 1 2

2 1

3 1 2

Sample Output

1

0

1

用可持久化线段树来可持久化数组以达到可持久化并查集的作用，有点像绕口令。。。

要注意的就是并查集的find也要在树上找到那个位置，使用它的位置，所以复杂度应该是两个log的,n logn logn 一次AC

#include<bits/stdc++.h>
#define maxn 20005
#define mae 800005
using namespace std;
int n,m,root[maxn],l[mae],r[mae],cnt,fa[mae],rank[mae],L[mae],R[mae];
void build(int& k,int le,int ri){
    if(!k) k=++cnt;L[k]=le;R[k]=ri;
    if(le==ri){fa[k]=le;rank[k]=0;return;}
    int mid=le+ri>>1;
    build(l[k],le,mid);build(r[k],mid+1,ri);
}
void newly(int &k,int wi,int f,int h){
    k=++cnt;
    L[k]=L[wi];R[k]=R[wi];
    if(L[k]==R[k]){fa[k]=h;return;}
    l[k]=l[wi];r[k]=r[wi];
    int mid=L[k]+R[k]>>1;
    if(f<=mid) newly(l[k],l[wi],f,h);
    else newly(r[k],r[wi],f,h);
}
int find(int k,int x){
    if(L[k]==R[k]) return k;
    int mid=L[k]+R[k]>>1;
    if(x<=mid) return find(l[k],x);
    else return find(r[k],x);
}
int fi(int x,int k){
    k=find(root[x],k);
    if(fa[k]!=L[k]) return fi(x,fa[k]);
    return fa[k];
}
int main(){
    scanf("%d%d",&n,&m);
    build(root[0],1,n);int a,b,c,f,h;
    for(int i=1;i<=m;i++){
        scanf("%d",&a);
        if(a==1){
            scanf("%d%d",&b,&c);
            f=fi(i-1,b);h=fi(i-1,c);
            if(rank[f]<rank[h]) newly(root[i],root[i-1],f,h);
            else{
                if(rank[f]>rank[h]) newly(root[i],root[i-1],h,f);
                else {newly(root[i],root[i-1],f,h);rank[find(root[i],f)]++;}
            }
        }
        if(a==2) scanf("%d",&b),root[i]=root[b];
        if(a==3){
            scanf("%d%d",&b,&c);root[i]=root[i-1];
            f=fi(i,b);h=fi(i,c);
            if(f==h) printf("1
");
            else printf("0
");
        }
    }
    return 0;
}