可持久化并查集

介绍

可以查询并查集的历史版本,即几次操作之前的连通状态,有在线与离线两种不同算法.

离线算法

相比于在线算法,时间复杂度与空间复杂度均要优越得多,若要查询第k次操作之后的状态,则可以视为k节点与此节点相连,否则视为上一节点与此节点相连,则这样将会形成一棵树,记录时用启发式合并,将较小树向较大树合并,而且不进行路径压缩,这样复杂度为O(n*logn),dfs一遍即可.

代码(以洛谷 P3402 【模板】可持久化并查集为例)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<stack>
#define N 100100
#define M 200100
using namespace std;

int n,m,first[M],bb,fa[N],size[N],ans[M];
struct Bn
{
    int to,next;
}bn[M];
struct Node
{
    int cz,a,b;
}node[M];
stack<int>sta;

inline void add(int u,int v)
{
    bb++;
    bn[bb].to=v;
    bn[bb].next=first[u];
    first[u]=bb;
}

int ff(int u)
{
    return u==fa[u]?u:ff(fa[u]);
}

inline void hb(int u,int v)
{
    if(size[u]>size[v]) swap(u,v);
    sta.push(u);
    size[v]+=size[u];
    fa[u]=v;
}

void dfs(int now)
{
    int p,q;
    if(node[now].cz==1) hb(ff(node[now].a),ff(node[now].b));
    else if(node[now].cz==3) ans[now]=(ff(node[now].a)==ff(node[now].b));
    for(p=first[now];p!=-1;p=bn[p].next)
    {
        dfs(bn[p].to);
    }
    if(node[now].cz==1)
    {
        p=sta.top();
        sta.pop();
        size[ff(p)]-=size[p];
        fa[p]=p;
    }
}

int main()
{
    memset(first,-1,sizeof(first));
    int i,j,p,q;
    cin>>n>>m;
    for(i=1;i<=m;i++)
    {
        scanf("%d%d",&node[i].cz,&node[i].a);
        if(node[i].cz==2) add(node[i].a,i);
        else add(i-1,i),scanf("%d",&node[i].b);
    }
    for(i=1;i<=n;i++) fa[i]=i,size[i]=1;
    dfs(0);
    for(i=1;i<=m;i++)
    {
        if(node[i].cz==3) printf("%d\n",ans[i]);
    }
}

在线算法

利用主席树来实现记录每个点的父节点,每次合并同样不进行路径压缩并用启发式合并,这样只需要修改一个节点的父节点,因此复杂度为log,但查询时,因为查询一个节点的父节点的复杂度为logn,要查询k次,因此总复杂度为O(n*logn^2)

代码(以洛谷 P3402 【模板】可持久化并查集为例)

#include<iostream>
#include<cstdio>
#define mid ((l+r)>>1)
#define N 100100
#define M 200100
using namespace std;

int n,m,tt,root[M];
struct Node
{
    int fa,left_son,right_son,size;
}node[M*50];

int build(int now,int l,int r)
{
    if(l==r)
    {
        node[now].fa=l;
        node[now].size=1;
        return l;
    }
    node[now].left_son=++tt;
    build(tt,l,mid);
    node[now].right_son=++tt;
    build(tt,mid+1,r);
}

int as(int now,int l,int r,int u)
{
    if(l==r) return node[now].fa;
    return u>mid?as(node[now].right_son,mid+1,r,u):as(node[now].left_son,l,mid,u);
}

int ask(int u,int v)
{
    int p;
    for(p=as(root[u],1,n,v);p!=v;v=p,p=as(root[u],1,n,v));
    return p;
}

int gs(int now,int l,int r,int u)
{
    if(l==r) return node[now].size;
    return u>mid?gs(node[now].right_son,mid+1,r,u):gs(node[now].left_son,l,mid,u);
}

int chf(int now,int l,int r,int u,int v)
{
    if(l==r)
    {
        node[now].fa=v;
        return node[now].size;
    }
    if(u>mid)
    {
        node[++tt]=node[node[now].right_son];
        node[now].right_son=tt;
        chf(tt,mid+1,r,u,v);
    }
    else
    {
        node[++tt]=node[node[now].left_son];
        node[now].left_son=tt;
        chf(tt,l,mid,u,v);
    }
}

void ads(int now,int l,int r,int u,int v)
{
    if(l==r)
    {
        node[now].size+=v;
        return;
    }
    u>mid?ads(node[now].right_son,mid+1,r,u,v):ads(node[now].left_son,l,mid,u,v);
}

int main()
{
    int i,j,o,p,q;
    cin>>n>>m;
    build(0,1,n);
    for(i=1;i<=m;i++)
    {
        scanf("%d",&o);
        if(o==2)
        {
            scanf("%d",&p);
            root[i]=root[p];
        }
        else if(o==3)
        {
            root[i]=root[i-1];
            scanf("%d%d",&p,&q);
            printf("%d\n",ask(i,p)==ask(i,q));
        }
        else
        {
            scanf("%d%d",&p,&q);
            root[i]=++tt;
            node[tt]=node[root[i-1]];
            p=ask(i,p),q=ask(i,q);
            if(gs(root[i],1,n,p)>gs(root[i],1,n,q)) swap(p,q);
            ads(root[i],1,n,q,chf(root[i],1,n,p,q));
        }
    }
}