介绍
可以查询并查集的历史版本,即几次操作之前的连通状态,有在线与离线两种不同算法.
离线算法
相比于在线算法,时间复杂度与空间复杂度均要优越得多,若要查询第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));
}
}
}