BZOJ3673/3674:可持久化并查集

Description

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

Solution

板子题……只不过网上有很多假做法。

具体做法就是整两个可持久化数组（不知道谁起的这么鬼畜的名字……我还是更喜欢叫他可持久化线段树）来记录并查集的$fa$数组和$dep$数组。因为路径压缩会破坏可持久化的结构，所以我们只能记录$dep$数组来按秩合并。

网上很多只搞了一颗可持久化线段树，维护$fa$就可持久化线段树$insert$一条链，维护$dep$就修改历史版本上的点的做法是错的……已经被卡掉了QAQ

Code

 #include<iostream>
 #include<cstdio>
 #define N (200009)
 using namespace std;

 int n,m,lastans,opt,x,y;

 struct Tree
 {
     struct Sgt{int ls,rs,v;}Segt[N*];
     int sgt_num,a[N],Root[N];
     int Build(int l,int r)
     {
         int now=++sgt_num;
         if (l==r) {Segt[now].v=a[l]; return now;}
         int mid=(l+r)>>;
         Segt[now].ls=Build(l,mid);
         Segt[now].rs=Build(mid+,r);
         return now;
     }
     int Update(int pre,int l,int r,int x,int v)
     {
         int now=++sgt_num;
         Segt[now].ls=Segt[pre].ls;
         Segt[now].rs=Segt[pre].rs;
         if (l==r) {Segt[now].v=v; return now;}
         int mid=(l+r)>>;
         if (x<=mid) Segt[now].ls=Update(Segt[now].ls,l,mid,x,v);
         else Segt[now].rs=Update(Segt[now].rs,mid+,r,x,v);
         return now;
     }
     int Query(int now,int l,int r,int x)
     {
         if (l==r) return Segt[now].v;
         int mid=(l+r)>>;
         if (x<=mid) return Query(Segt[now].ls,l,mid,x);
         else return Query(Segt[now].rs,mid+,r,x);
     }
 }CT[];

 int Find(int x,int t)
 {
     int fa=CT[].Query(CT[].Root[t],,n,x);
     return x==fa?x:Find(fa,t);
 }

 int main()
 {
     scanf("%d%d",&n,&m);
     for (int i=; i<=n; ++i)
         CT[].a[i]=i, CT[].a[i]=;
     CT[].Root[]=CT[].Build(,n);
     CT[].Root[]=CT[].Build(,n);
     for (int i=; i<=m; ++i)
     {
         scanf("%d",&opt);
         if (opt==)
         {
             CT[].Root[i]=CT[].Root[i-];
             CT[].Root[i]=CT[].Root[i-];
             scanf("%d%d",&x,&y);
             /*x^=lastans; y^=lastans;*/
             int fx=Find(x,i),fy=Find(y,i);
             if (fx==fy) continue;
             int dfx=CT[].Query(CT[].Root[i],,n,fx);
             int dfy=CT[].Query(CT[].Root[i],,n,fy);
             if (dfx>dfy) swap(fx,fy);
             CT[].Root[i]=CT[].Update(CT[].Root[i],,n,fx,fy);
             if (dfx!=dfy) continue;
             CT[].Root[i]=CT[].Update(CT[].Root[i],,n,fy,dfy+);
         }
         if (opt==)
         {
             scanf("%d",&x); /*x^=lastans;*/
             CT[].Root[i]=CT[].Root[x];
             CT[].Root[i]=CT[].Root[x];
         }
         if (opt==)
         {
             CT[].Root[i]=CT[].Root[i-];
             CT[].Root[i]=CT[].Root[i-];
             scanf("%d%d",&x,&y);
             /*x^=lastans; y^=lastans;*/
             int fx=Find(x,i),fy=Find(y,i);
             if (fx==fy) puts("")/*, lastans=1*/;
             else puts("")/*, lastans=0*/;
         }
     }
 }