也算是磕磕绊绊,断断续续的学历一段时间并查集了吧,也是时候改写一个blog总结一下啦。
先说一下普通并查集吧。
普通并查集就是单纯的把某些可以连起来的点用一条有向边连起来,表示他们属于“一类”,例如HDU1213,这就是一个并查集的裸题,直接把输入的点合并,之后统计有几个点的祖先是自己就行。
AC代码:
#include<iostream>
#include<cstdio>
using namespace std;
const int maxn=10010;
int f[maxn];
void init(int n)
{
for(int i=1;i<=n;i++) f[i]=i;
}
int Find(int x)
{
if(x==f[x]) return x;
else return f[x]=Find(f[x]);
}
void Merge(int x,int y)
{
int t1=Find(x),t2=Find(y);
if(t1!=t2)
{
f[t1]=t2;
}
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
int n,m;
scanf("%d%d",&n,&m);
init(n);
while(m--)
{
int x,y;
scanf("%d%d",&x,&y);
Merge(x,y);
}
int ans=0;
for(int i=1;i<=n;i++)
{
if(f[i]==i) ans++;
}
printf("%d\n",ans);
}
return 0;
}
还有一个例子就是HDU3635,这个很容易看出是一个并查集的题,但这个涉及到三个操作,一个是查找x的祖先,一个是查找x的祖先所在的位置含有的龙珠的个数,还有一个就是查找x一共转移了几次。第一个就是一个基础的Find操作,第二个直接定义一个sum数组,在Merge的时候把子节点的sum全部给父节点,并将子节点的sum清为0,最后直接查询就行,主要是最后一个,我考虑的是并查集维护的是一个树(或者说森林),Find操作向上查找了多少次,这颗龙珠就被转移了多少次,但这样就必须把路径压缩给去掉,所幸数据范围比较小,就卡过去啦;
AC代码:
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn=10010;
int n,m;
int f[maxn],sum[maxn];
int ans;
void init(int n)
{
for(int i=1;i<=n;i++)
{
f[i]=i,sum[i]=1;
}
}
int Find(int x)
{
if(x==f[x]) return x;
else
{
ans++;
return Find(f[x]);
}
}
void Merge(int x,int y)
{
int t1=Find(x),t2=Find(y);
if(t1!=t2)
{
f[t1]=t2;
sum[t2]+=sum[t1];
sum[t1]=0;
}
}
int main()
{
int T;
scanf("%d",&T);
int cas=1;
while(T--)
{
scanf("%d%d",&n,&m);
init(n);
printf("Case %d:\n",cas++);
while(m--)
{
char C;
cin>>C;
if(C=='T')
{
int x,y;
scanf("%d%d",&x,&y);
Merge(x,y);
}
else
{
int x;
scanf("%d",&x);
ans=0;
int t=Find(x);
printf("%d %d %d\n",t,sum[t],ans);
}
}
}
return 0;
}
当然,一般比赛的时候很少可以看到某个算法的裸题,有些并查集的题要构建出并查集的模型才行。
例POJ1456,看到这题可以想到贪心,但由于数据范围很小,时限很多,直接暴力做不会超时,但这一题其实是可以用并查集来优化的。我们排序完之后遍历时最消耗时间就是去查找从d -> 1哪一个点还没有用,那我们就可以考虑并查集,每次将t-1更新为t的父节点,那们每次Find操作只要得到的t不为0就可以更新答案。
AC代码:
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
#define LL long long
const int maxn=10010;
struct node
{
int id;
LL val;
} a[maxn];
bool cmp(node aa,node bb)
{
return aa.val>bb.val;
}
int f[maxn];
int Find(int x)
{
if(x==f[x]) return x;
else return f[x]=Find(f[x]);
}
void init(int n)
{
for(int i=1; i<=n; i++)
{
f[i]=i;
}
}
int main()
{
int n;
while(~scanf("%d",&n))
{
int pos=0;
for(int i=1; i<=n; i++)
{
scanf("%lld%d",&a[i].val,&a[i].id);
pos=max(pos,a[i].id);
}
init(pos);
sort(a+1,a+n+1,cmp);
LL ans=0;
for(int i=1; i<=n; i++)
{
int t=Find(a[i].id);
if(t)
{
ans+=a[i].val;
f[t]=t-1;
}
}
printf("%lld\n",ans);
}
return 0;
}
而普通并查集在图论里的操作还有很多,比如判断图是否连通,判断图里有没有环。。。这里就不一一赘述。
接下来讲一下并查集的升级版,带权并查集。
就直接更具题目来讲吧
POJ1182,这是一道带权并查集的经典题啦。首先我们用0表示x和y是同类,1表示x吃y,2表示x被y吃。那么根据矢量的运算法则,我们就可以把路劲压缩和Merge操作时的表达式给写出来,这样这题就可以做出来啦。
AC代码:
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int maxn=5e4+7;
int f[maxn],Rank[maxn];
void init(int n)
{
for(int i=1; i<=n; i++)
{
f[i]=i,Rank[i]=0;
}
}
int Find(int x)
{
if(x==f[x]) return x;
else
{
int t=Find(f[x]);
Rank[x]=(Rank[x]+Rank[f[x]])%3;
return f[x]=t;
}
}
void Merge(int x,int y,int val)
{
int t1=Find(x),t2=Find(y);
if(t1!=t2)
{
f[t1]=t2;
Rank[t1]=(-Rank[x]+val+Rank[y]+3)%3;
}
}
int main()
{
int n,k;
scanf("%d%d",&n,&k);
init(n);
int ans=0;
while(k--)
{
int opt,x,y;
scanf("%d%d%d",&opt,&x,&y);
if(x>n||y>n)
{
ans++;
continue;
}
int t1=Find(x),t2=Find(y);
int temp;
if(t1==t2)
{
temp=(Rank[x]-Rank[y]+3)%3;
if(temp!=opt-1)
{
ans++;
}
else
{
Merge(x,y,opt-1);
}
}
else
{
Merge(x,y,opt-1);
}
}
printf("%d\n",ans);
return 0;
}
带权并查集还有区间形的,例如这道题HDU3038,我们每次用(x-1,y]来记录x->y之间的值,还是一样,直接在路径压缩和Merge操作时根据矢量运算法则写出表达式就行。
AC代码:
#include<iostream>
#include<cstdio>
using namespace std;
#define LL long long
const LL maxn=200010;
int f[maxn];
LL Rank[maxn];
void init(int n)
{
for(int i=0; i<=n; i++)
{
f[i]=i,Rank[i]=0;
}
}
int Find(int x)
{
if(x==f[x]) return x;
else
{
int t=Find(f[x]);
Rank[x]=Rank[x]+Rank[f[x]];
return f[x]=t;
}
}
int main()
{
int n,m;
while(~scanf("%d%d",&n,&m))
{
init(n);
LL ans=0;
while(m--)
{
int x,y;
LL val;
scanf("%d%d%lld",&x,&y,&val);
int t1=Find(x-1),t2=Find(y);
if(t1!=t2)
{
if(t1<t2)
{
f[t1]=t2;
Rank[t1]=Rank[y]-Rank[x-1]+val;
}
else
{
f[t2]=t1;
Rank[t2]=Rank[x-1]-Rank[y]-val;
}
}
else
{
if(Rank[x-1]-Rank[y]!=val)
{
ans++;
}
}
}
printf("%lld\n",ans);
}
return 0;
}