BZOJ3673 可持久化并查集（洛谷P3402、BZOJ3674）

版权声明：蒟蒻Blog随意转载 https://blog.csdn.net/a1799342217/article/details/82466222

主席树 并查集

洛谷P3402
BZOJ3673
BZOJ3674

可持久化并查集其实就是并查集+可持久化数组。可持久化数组用主席树实现，把主席树的叶子节点当做数组即可。路径压缩的并查集复杂度是不对的（可以连一条很长的链再回去），因此只能用按秩合并（按最大深度的启发式合并）。

代码：

#include<cctype>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 100005
#define F inline
using namespace std;
struct tree{ int l,r,ls,rs,fa,dep; }t[N<<5];
int n,m,k,nd,num,rt[N<<1];
F char readc(){
    static char buf[100000],*l=buf,*r=buf;
    if (l==r) r=(l=buf)+fread(buf,1,100000,stdin);
    return l==r?EOF:*l++;
}
F int _read(){
    int x=0; char ch=readc();
    while (!isdigit(ch)) ch=readc();
    while (isdigit(ch)) x=(x<<3)+(x<<1)+(ch^48),ch=readc();
    return x;
}
void build(int &x,int l,int r){
    t[x=++nd].l=l,t[x].r=r; int mid=l+r>>1;
    if (l==r) return void(t[x].fa=l);
    build(t[x].ls,l,mid),build(t[x].rs,mid+1,r);
}
F void mrg(int lst,int &x,int p,int fa){
    t[x=++nd]=t[lst]; int mid=t[x].l+t[x].r>>1;
    if (t[x].l==t[x].r) return void(t[x].fa=fa);
    if (p<=mid) mrg(t[lst].ls,t[x].ls,p,fa);
    else mrg(t[lst].rs,t[x].rs,p,fa);
}
F void mdfy(int x,int p){
    if (t[x].l==t[x].r) return void(t[x].dep++);
    mdfy(t[x].l+t[x].r>>1>=p?t[x].ls:t[x].rs,p);
}
F int srch(int x,int p){
    if (t[x].l==t[x].r) return x;
    return srch(t[x].l+t[x].r>>1>=p?t[x].ls:t[x].rs,p);
}
int findfa(int rt,int x){
    int now=srch(rt,x);
    if (t[now].fa==x) return now;
    return findfa(rt,t[now].fa);
}
int main(){
    n=_read(),m=_read(),build(rt[0],1,n);
    for (int i=1;i<=m;i++){
        int f=_read(),x=_read(),y,fx,fy;
        if (f==2){ rt[i]=rt[x]; continue; }
        y=_read(),rt[i]=rt[i-1];
        x=findfa(rt[i],x),y=findfa(rt[i],y);
        if (f==3){ puts(t[x].fa==t[y].fa?"1":"0"); continue; }
        if (t[x].fa==t[y].fa) continue;
        if (t[x].dep>t[y].dep) swap(x,y);
        mrg(rt[i-1],rt[i],t[x].fa,t[y].fa);
        if (t[x].dep==t[y].dep) mdfy(rt[i],t[y].fa);
    }
    return 0;
}