BZOJ-3674:可持久化并查集（可持久化数据结构）

 

题目大意：

中文题目，不多解释。

n个集合 m个操作
操作：
1 a b 合并a,b所在集合
2 k 回到第k次操作之后的状态(查询算作操作)
3 a b 询问a,b是否属于同一集合，是则输出1否则输出0
请注意本题采用强制在线,所给的a,b,k均经过加密,加密方法为x = x xor lastans,lastans的初始值为0
0<n,m<=2*10^5
 

解题思路：

今天专门学了一下可持久化并查集，发现其实就是只有底层结点的主席树。

感觉也不用多解释，有主席树基础的话代码应该很好看懂。

但是这里我不知道怎么进行并查集的路径压缩，我采用了判断秩大小的优化，听队友说这个可以把复杂度优化到O（logn），正常的路径压缩是可以优化到O（1）的应该。

具体的实现部分可以看代码

 

Ac代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=2e5+5;
const int INF=1e9+7;
int n,m,cnt,root[maxn];
struct node
{
    int l,r;
    int val,dep;
}t[maxn*40];
void build(int &x,int l,int r)  //初始化
{
    x=++cnt;
    if(l==r)
    {
        t[x].val=l;
        return ;
    }
    int mid=(l+r)>>1;
    build(t[x].l,l,mid);
    build(t[x].r,mid+1,r);
}
void update(int &x,int y,int l,int r,int pos,int val)   //合并并查集
{
    t[++cnt]=t[y],x=cnt;
    if(l==r)
    {
        t[x].val=val;
        return ;
    }
    int mid=(l+r)>>1;
    if(pos<=mid) update(t[x].l,t[y].l,l,mid,pos,val);
    if(pos>mid) update(t[x].r,t[y].r,mid+1,r,pos,val);
}
int query(int x,int l,int r,int pos)    //查询pos结点的值是否为pos
{
    if(l==r) return x;
    int mid=(l+r)>>1;
    if(pos<=mid) return query(t[x].l,l,mid,pos);
    if(pos>mid) return query(t[x].r,mid+1,r,pos);
}
int find(int x,int val) //找寻父结点所在的位置
{
    int p=query(x,1,n,val);
    if(t[p].val==val) return p;
    return find(x,t[p].val);
}
void add(int x,int l,int r,int pos) //秩++
{
    if(l==r)
    {
        t[x].dep++;
        return ;
    }
    int mid=(l+r)>>1;
    if(pos<=mid) add(t[x].l,l,mid,pos);
    if(pos>mid) add(t[x].r,mid+1,r,pos);
}
int main()
{
    int ans=0;
    scanf("%d%d",&n,&m);
    build(root[0],1,n); //以root[0]为初始状态
    for(int i=1;i<=m;i++)
    {
        int flag,a,b;
        scanf("%d",&flag);
        if(flag==1)
        {
            scanf("%d%d",&a,&b);
            a=a^ans,b=b^ans;root[i]=root[i-1];  //将上个结点的值赋过来
            int fx=find(root[i],a),fy=find(root[i],b);  //找到fx fy对应的位置 注意 位置
            if(t[fx].val==t[fy].val) continue;  //相同跳过
            if(t[fx].dep>t[fy].dep) swap(fx,fy);    //根据秩的大小优化合并
            update(root[i],root[i-1],1,n,t[fx].val,t[fy].val);  //合并两个并查集
            if(t[fx].dep==t[fy].dep) add(root[i],1,n,t[fy].val);    //秩++
        }
        else if(flag==2)
        {
            scanf("%d",&a); a=a^ans;
            root[i]=root[a];    //回溯版本
        }
        else 
        {
            scanf("%d%d",&a,&b);
            a=a^ans,b=b^ans;root[i]=root[i-1];
            int fx=find(root[i],a),fy=find(root[i],b);
            if(t[fx].val==t[fy].val) ans=1,printf("1\n");   //判断是否属于同一并查集
            else ans=0,printf("0\n");
        }
    }
    //system("pause");
}