可持久化并查集总结

数据结构——可持久化——可持久化并查集

前面的话

其实看起来很高大上，最后还不是沦为被我这种菜鸡都能学会的东西
嗯，我只是想解释这个并不是很难。。。连我这么弱都。。。
然后还是以模板题为背景将比较好。。。洛谷题目传送门

实现方法

其实可持久化并查集就是要支持回到以前的版本(类比可持久化$数组/线段树$之类的)
那么我都类比了，很显然就是用主席树来维护吧

主席树部分

我们以前学的主席树是不是可以支持让当前维护的数组回到之前的任一版本
那我们的并查集需要维护什么？ 没错，$fa[]$数组
是不是我们知道了每一个版本的$fa[]$数组就相当于知道了这个版本的并查集？
那么问题转化成了用主席树维护一个$fa[]$数组对吧。。。
这个是主席树的板子

并查集部分

对于并查集，它的修改是合并两个独立的并查集
考虑如何合并
很显然不可以路径压缩(其实好像可以，只是我不会，反正这种方法也很优秀)
那么在不路径压缩的情况下怎么保证复杂度呢
嗯，普通的并查集有两种优化，路径压缩和按秩合并对吧
现在路径压缩用不了(我不会)，那就考虑按秩合并(不会可以点一下上面的链接)
它可以把复杂度优化到log级别(因为树高控制了。。。)
那不就比较显然了。。。

总体来一发

• 先建好一棵主席树，权值为$fa[i]=i$
• 对于所有的询问：
  
  1. Update(修改)：查询两点的父亲，如果不在一个并查集，看树高，小的合并向大的(按秩合并)，合并的话就是直接主席树板子修改$fa[]$权值就ok
  2. Query(查询)：这个直接查询，然后可持久化的版本转化就直接套版子做就行了

整体代码

我学的时候为了复习用写了注释
居然 派上用场了 ~(≧▽≦)/~啦啦啦

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<iomanip>
#include<algorithm>
#include<ctime>
#include<queue>
#include<stack>
#include<vector>
#define lst long long
#define ldb long double
#define N 200050
#define lson ljl[now].ls
#define rson ljl[now].rs
using namespace std;
const int Inf=1e9;
int read()
{
    int s=0,m=0;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')m=1;ch=getchar();}
    while(ch>='0'&&ch<='9')s=(s<<3)+(s<<1)+(ch^48),ch=getchar();
    return m?-s:s;
}
int n,Q,tot;
int dep[N*30],fa[N*30];
int Edi[N];//版本编号
struct TREE{int ls,rs;}ljl[N*30];
//主席树部分
void Build(int &now,int le,int ri)
{
    if(!now)now=++tot;
    if(le==ri){fa[now]=le;return;}//并查集初始化
    int mid=(le+ri)>>1;
    Build(lson,le,mid),Build(rson,mid+1,ri);
}
void Update(int &now,int pre,int le,int ri,int loc,int ff)
//当前版本，上一个版本(复制时要用)，左右端点，把loc的爸爸改成ff
{
    now=++tot;//新开log个节点
    if(le==ri)
    {
        dep[now]=dep[pre];
        //因为从前面的版本过来，所以树的深度也要继承
        fa[now]=ff;return;
    }
    lson=ljl[pre].ls,rson=ljl[pre].rs;//把前面的树“复制”过来
    int mid=(le+ri)>>1;
    if(loc<=mid)Update(lson,ljl[pre].ls,le,mid,loc,ff);
    else Update(rson,ljl[pre].rs,mid+1,ri,loc,ff);
}
int Query(int now,int le,int ri,int loc)
{//找到询问的节点记录的fa[]
    if(le==ri)return now;
    int mid=(le+ri)>>1;
    if(loc<=mid)return Query(lson,le,mid,loc);
    else return Query(rson,mid+1,ri,loc);
}
//嗯，属于可持久化并查集的特殊部分了
void add(int now,int le,int ri,int loc)
{//按秩合并的树高改变
    if(le==ri){dep[now]++;return;}
    int mid=(le+ri)>>1;
    if(loc<=mid)add(lson,le,mid,loc);
    else add(rson,mid+1,ri,loc);
}
int Find_fa(int edi,int now)
{
    int ff=Query(edi,1,n,now);//查询在这一版本里now的父亲
    if(now==fa[ff])return ff;
    return Find_fa(edi,fa[ff]);//无路径压缩
}
int main()
{
    n=read(),Q=read();
    Build(Edi[0],1,n);
    for(int i=1;i<=Q;++i)
    {
        int opt=read();
        if(opt==1)
        {
            Edi[i]=Edi[i-1];
            int x=read(),y=read();
            int fx=Find_fa(Edi[i],x),fy=Find_fa(Edi[i],y);
            if(fa[fx]==fa[fy])continue;
            if(dep[fx]>dep[fy])swap(fx,fy);//按秩合并，把x往y合并(dep小的往大的合并)
            Update(Edi[i],Edi[i-1],1,n,fa[fx],fa[fy]);
            if(dep[fx]+1>dep[fy])add(Edi[i],1,n,fa[fy]);
        }
        if(opt==2)
        {
            int kk=read();
            Edi[i]=Edi[kk];
        }
        if(opt==3)
        {
            Edi[i]=Edi[i-1];
            int x=read(),y=read();
            int fx=Find_fa(Edi[i],x),fy=Find_fa(Edi[i],y);
            if(fa[fx]==fa[fy])puts("1");
            else puts("0");
        }
    }
    return 0;
}