并查集模板

并查集模板

用处

1.合并两个集合
2.查询某个节点的祖宗节点

优化

1.路径压缩，最坏情况 log(n)
2.按照秩合并，最坏log(n)
使用上面的两个优化后，时间复杂度O(alpha(n))

扩展

1.记录集合大小
集合大小绑定在根节点上，在合并的时候更新
2.每个点到父节点的距离
这个属性放在每个点上，例题：食物链（带权并查集(维护相对距离)，扩展域并查集(枚举所有可能性)）
3.链表染色

模板

int father[N];
void init(){
	 for(int i=0;i<n;++i) father[i]=i; 
}

//查询，查找集合的根节点
//递归写法
//带有路径压缩的并查集查找
int findFather(int x){
	return father[x]==x?x:father[x]=findFather(father[x]);
}

//迭代写法
int findFather(int x){
	int a=x;
	//找到根节点
	while(a!=father[a]) a=father[a];
	//路径压缩
	while(x!=father[x]){
		int t=father[x];
		father[x]=a;
		x=t;
	}
	return a;
}



//合并两个连通分量
void union(int u,int v){
	int fu=findFather(u);  //查找u的根节点
	int fv=findFather(v);  //查找v的根节点
	if(fu!=fv) father[fu]=fv; //合并他们
}

例题

AcWing 1250. 格子游戏 ： 并查集的应用之一，并查集判环

#include<iostream>
#include<cstdio>
using namespace std;
const int maxn=42000;
int n,m,p[maxn];

int get(int x,int y){
    return (x-1)*n+y-1;
}

int find(int x){
    return (x==p[x])?x:(p[x]=find(p[x]));
}

int main(void){
    cin>>n>>m;
    for(int i=0;i<n*n;++i) p[i]=i; 
    
    int ans=0;
    for(int i=1;i<=m;++i){
         int x,y;
         char c;
         cin>>x>>y>>c;
         int a=get(x,y),b=0;
         if(c=='R') b=get(x,y+1);
         else b=get(x+1,y);
         int pa=find(a),pb=find(b);
         // cout<<pa<<" "<<pb<<endl;
         if(pa==pb){
             ans=i;
             break;
         }
         p[pa]=pb;
    }
    if(ans) cout<<ans<<endl;
    else cout<<"draw"<<endl;
    return 0;
}

AcWing 1252. 搭配购买
并查集+01背包

#include<iostream>
#include<cstdio>
using namespace std;
const int maxn=10010;
int n,m,w,c[maxn],d[maxn],fa[maxn],f[maxn];

int findfa(int x){
    return (x==fa[x])?x:(fa[x]=findfa(fa[x]));
}

int main(void){
    cin>>n>>m>>w;
    for(int i=1;i<=n;++i){
        cin>>c[i]>>d[i];
    }
    
    for(int i=1;i<=n;++i) fa[i]=i;
    for(int i=1;i<=m;++i){
        int a,b,pa,pb;
        cin>>a>>b;
        pa=findfa(a),pb=findfa(b);
        if(pa!=pb){
            c[pa]+=c[pb];
            d[pa]+=d[pb];
            fa[pb]=pa;
        }
    }
    for(int i=1;i<=n;++i){
        if(i==fa[i]){
            for(int j=w;j>=c[i];--j){
                f[j]=max(f[j],f[j-c[i]]+d[i]);
            }
        }
    }
    cout<<f[w]<<endl;
}

AcWing 238. 银河英雄传说
维护每个点到父节点的距离

#include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
const int maxn=30010;
int fa[maxn],d[maxn],s[maxn],t,n;

int findfa(int x){
    if(x!=fa[x]){
        int tmp=findfa(fa[x]);
        d[x]+=d[fa[x]];
        fa[x]=tmp;
    }
    return fa[x];
}

int main(void){
    cin>>t;
    
    for(int i=1;i<maxn;++i){
        fa[i]=i;
        s[i]=1;
    }
    
    char op[2];
    int a,b;
    for(int i=0;i<t;++i){
        scanf("%s%d%d",op,&a,&b);
        if(op[0]=='M'){
            int pa=findfa(a),pb=findfa(b);
            // 更新每个元素x到fa[x]的距离
            d[pa]=s[pb];
            // 更新集合中的元素个数
            s[pb]+=s[pa];
            fa[pa]=pb;
        }else{
            int pa=findfa(a),pb=findfa(b);
            if(pa==pb){
                printf("%d\n",max(abs(d[a]-d[b])-1,0));
            }else printf("-1\n");
        }
    }
}

AcWing 239. 奇偶游戏
这一题建议看这一篇题解，写的十分详细.
大致就是将 一个区间的累计和的奇偶性 转化为两个前缀和之间的奇偶性，然后这就可以分出两个关系，相同还是相斥，参照 食物链那题的思想，将他们的关系反映在他们之间的相对距离上，具体做法是通过维护他们与父节点之间的距离。
同时这题使用了离散化操作，可以使用无序的离散化。

1.带边权的并查集

#include<iostream>
#include<string>
#include<cmath>
#include<unordered_map>
using namespace std;
const int maxn=10010;
int n,m,num,a,b,fa[maxn],d[maxn];
string str;
unordered_map<int,int> s;

int get(int x){
    if(s.count(x)!=0) return s[x];
    return s[x]=++num;
}

int findfa(int x){
    if(x!=fa[x]){
        int root=findfa(fa[x]);
        d[x]=d[x]^d[fa[x]];
        fa[x]=root;
    }
    return fa[x];
}

int main(void){
    cin>>n>>m;
    for(int i=0;i<maxn;++i) fa[i]=i;
    int res=m;
    for(int i=1;i<=m;++i){
        cin>>a>>b>>str;
        a=get(a-1);
        b=get(b);
        int pa=findfa(a),pb=findfa(b),t=0;
        if(str=="odd"){
            t=1;
        }
        if(pa==pb){
            if((d[a]^d[b]^t)!=0){
                res=i-1;
                break;
            }
        }else{
            d[pa]=d[a]^d[b]^t;
            fa[pa]=pb;
        }
    }
    cout<<res<<endl;
}

2.带扩展域的并查集 枚举
将每一个已知信息转化为多个条件(枚举)，然后合并条件
图片来自：https://www.acwing.com/solution/content/29308/

#include<iostream>
#include<string>
#include<cmath>
#include<unordered_map>
using namespace std;
const int maxn=20020,N=10010;
int n,m,num,a,b,fa[maxn],d[maxn];
string str;
unordered_map<int,int> s;

int get(int x){
    if(s.count(x)!=0) return s[x];
    return s[x]=++num;
}

int findfa(int x){
    if(x!=fa[x]) return fa[x]=findfa(fa[x]);
    return fa[x];
}

int main(void){
    cin>>n>>m;
    for(int i=0;i<maxn;++i) fa[i]=i;
    int res=m;
    for(int i=1;i<=m;++i){
        cin>>a>>b>>str;
        a=get(a-1);
        b=get(b);
        
        if(str=="odd"){
            if(findfa(a)==findfa(b)){
                res=i-1;
                break;
            }
            fa[findfa(a+N)]=findfa(b);
            fa[findfa(a)]=findfa(b+N);
        }else{
            if(findfa(a+N)==findfa(b)){
                res=i-1;
                break;
            }
            fa[findfa(a)]=findfa(b);
            fa[findfa(a+N)]=findfa(b+N);
        }
        
    }
    cout<<res<<endl;
}