【BZOJ3674】可持久化并查集加强版

可持久化并查集我觉得就是可持久化数组的一种应用。可持久化数组，顾名思义，就是有历史版本的数组，那么如果我们暴力修改储存的话，修改O(n)查询O(1),空间O(n*m)，这样肯定不可行，那么我们发现主席树有这样的功能，他可以快速复制，修改O(log)，查询O(log)，空间(m*log)，是一个可行的方案。然后我们可持久化f数组维护fa，每次按照深度启发式合并，不进行路径压缩，这样能保证时间复杂度位单次O(log^2)，空间复杂度为O(2*n+m*log)。我不知道为什么不路径压缩，路径压缩是完全可以的，但是他的时间复杂度和空间复杂度似乎都不如不路径压缩看，而且似乎并不好打。

#include <cstdio>
using namespace std;
inline void read(int &sum){
  register char ch=getchar();
  for(sum=;ch<''||ch>'';ch=getchar());
  for(;ch>=''&&ch<='';sum=(sum<<)+(sum<<)+ch-'',ch=getchar());
}
const int N=;
struct Segment_Tree{
  Segment_Tree *ch[];int f,deep;
  void* operator new(size_t);
}*root[N],*null,*C,*mempool;
int n,m;
void* Segment_Tree :: operator new(size_t){
  if(C==mempool)C=new Segment_Tree[(<<)+],mempool=C+(<<)+;
  return C++;
}
inline void build(Segment_Tree *&p,int l,int r){
  p=new Segment_Tree,p->deep=p->f=;
  if(l==r){
    p->f=l,p->deep=,p->ch[]=p->ch[]=null;
    return;
  }
  build(p->ch[],l,(l+r)>>);
  build(p->ch[],((l+r)>>)+,r);
}
inline void insert(Segment_Tree *&p,Segment_Tree *last,int pos,int key,int l,int r){
  p=new Segment_Tree,*p=*last;
  if(l==r){
    p->f=key;return;
  }
  if(pos<=((l+r)>>))insert(p->ch[],last->ch[],pos,key,l,((l+r)>>));
  else insert(p->ch[],last->ch[],pos,key,((l+r)>>)+,r);
}
inline void update(Segment_Tree *p,int pos){
  register int l=,r=n;
  while(l!=r){
    if(pos<=((l+r)>>)){
      p=p->ch[],r=((l+r)>>);
    }else{
      p=p->ch[],l=((l+r)>>)+;
    }
  }
  p->deep++;
}
inline int deep(Segment_Tree *p,int pos){
  register int l=,r=n;
  while(l!=r){
    if(pos<=((l+r)>>)){
      p=p->ch[],r=((l+r)>>);
    }else{
      p=p->ch[],l=((l+r)>>)+;
    }
  }
  return p->deep;
}
inline int F(Segment_Tree *p,int pos){
  register int l=,r=n;
  while(l!=r){
    if(pos<=((l+r)>>)){
      p=p->ch[],r=((l+r)>>);
    }else{
      p=p->ch[],l=((l+r)>>)+;
    }
  }
  return p->f;
}
inline int find_root(Segment_Tree *p,int x){
  int fa=F(p,x);
  return fa==x?x:find_root(p,fa);
}
inline void Init(){
  null=new Segment_Tree,null->ch[]=null->ch[]=null,null->f=,null->deep=;
  read(n),read(m);
  build(root[],,n);
}
inline void Work(){
  register int ans=,opt,a,b,x,y,d1,d2;
  for(register int i=;i<=m;i++){
    read(opt);
    switch(opt){
      case :read(a),a^=ans,read(b),b^=ans;
            x=find_root(root[i-],a),y=find_root(root[i-],b);
            if(x==y){
              root[i]=root[i-];
              break;
            }
            d1=deep(root[i-],x),d2=deep(root[i-],y);
            if(d1>d2)x^=y^=x^=y;insert(root[i],root[i-],x,y,,n);
            if(d1==d2)update(root[i],y);
            break;
      case :read(a),a^=ans;
            root[i]=root[a];break;
      case :read(a),read(b),a^=ans,b^=ans;
            root[i]=root[i-];
            x=find_root(root[i],a),y=find_root(root[i],b);
            if(x==y)puts(""),ans=;
            else puts(""),ans=;
            break;
    }
  }
}
int main(){
  Init();
  Work();
  return ;
}