并查集总结

已于 2022-07-20 11:35:40 修改
阅读量481 收藏 6
点赞数
文章标签： c++
于 2021-09-01 17:07:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55788328/article/details/120040648
版权
这篇博客详细介绍了并查集的几种实现方式，包括普通并查集、路径压缩、带权并查集以及可持久化并查集。通过实例展示了如何在不同场景下运用并查集解决连通性问题，如区间和问题、敌人的敌人是朋友的关系维护等。此外，还提到了如何利用并查集判断一个图是否是一棵树。
摘要由CSDN通过智能技术生成

普通并查集  链接

#include<bits/stdc++.h>
using namespace std;
int pre[50000+5];
int t=1;
int find(int x){
	while(x!=pre[x]){
		x=pre[x];
	}
	return x;
}

void solve(int n,int m){
	for(int i=1;i<=n;i++){
		pre[i]=i;
	}
	while(m--){
		int a,b;
		cin>>a>>b;
		int x=find(a),y=find(b);
		if(x==y){
			continue;
		}
		else{
			pre[y]=x;
			n--;
		}
	}
	cout<<"Case "<<t<<": "<<n<<endl;
}
int main(){
	int n,m;
	while(cin>>n>>m){
	if(n==0&&m==0) return 0;
	else{
		solve(n,m);
		t++;
	}	
	}
}


普通的路径压缩

int find(int x){
	if(x!=pre[x]){
		pre[x]=find(pre[x]);
	}
	return pre[x];
}

带权并查集 

带权值的路径压缩

val[x]指的是x->rootx的距离

int find(int x){
	if(x!=pre[x]){
		int t=pre[x];
		pre[x]=find(pre[x]);
		val[x]+=val[t];
	}
	return pre[x];
}

合并

 

现在是已知x所在的并查集根节点为px，y所在的并查集根节点为py，如果有了x、y之间的关系，要将px并到py上，如果不考虑权值直接修改parent就行了，但是现在是带权并查集，必须得求出px与py这条边的权值是多少，很显然x到py两条路径的权值之和应该相同，就不难得出上面代码所表达的更新式。但是需要注意并不是每个问题都是这样更新的，有时候可能会做取模之类的操作 

给出区间和[1,4]为20，[3,4]为15，再给出[1,2]为30，显然这个[1,2]的值就有问题，它应该为20-15=5。 这个题目需要分析什么时候会产生矛盾，不妨就具体看看上面的这个矛盾的例子

在这里这个图是画不了的，因为使用的都是闭区间，闭区间会加上端点的值，这就提醒我们这个题在处理的时候应该将闭区间的某一端变成开区间，比如将[1,4]变成(0,4]，将[3,4]变成(2,4]，将[1,2]变成(0,2]

链接

#include <stdio.h>
#include <algorithm>
#include <string.h>
using namespace std;
const int N =200010;
int father[N];
int sum[N];  ///记录当前结点到根结点的距离

int _find(int x){
    if(x!=father[x]){
        int t = father[x];
        father[x] = _find(father[x]);
        sum[x]+=sum[t];
    }
    return father[x];
}
int main()
{
    int n,m;
    while(scanf("%d%d",&n,&m)!=EOF){
        for(int i=0;i<=n;i++){
            father[i] = i;
            sum[i] = 0;
        }
        int ans = 0;
        while(m--){
            int a,b,v;
            scanf("%d%d%d",&a,&b,&v);
            a--;
            int roota = _find(a);
            int rootb = _find(b);
            if(roota==rootb){
                if(sum[a]-sum[b]!=v) ans++;  // a和b的root都是c， v+sum[b]=sum[a]
            }
            else{
                father[roota] = rootb;
                sum[roota] = -sum[a]+sum[b]+v; //sum[x]指的是 x->root[x]的距离
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

种类并查集  链接

一般的并查集，维护的是具有连通性、传递性的关系，例如亲戚的亲戚是亲戚。但是，有时候，我们要维护另一种关系：敌人的敌人是朋友。种类并查集就是为了解决这个问题而诞生的。

#include<bits/stdc++.h>
using namespace std;
const int maxn=50000+5;
int pre[maxn*3+5];
int find(int x){
	if(x!=pre[x]){
		pre[x]=find(pre[x]);
	}
	return pre[x];
}
void unite(int x,int y){
	x=find(x);
	y=find(y);
	pre[x]=y;
}
int main(){
	int n,k;
	cin>>n>>k;
	for(int i=1;i<=3*n;i++){
		pre[i]=i;
	}
	int ans=0;
	while(k--){
		int check,x,y;
		cin>>check>>x>>y;
		if(x<0||y<0||x>n||y>n){
			ans++;
			continue;
		}
		else if(check==2&&x==y){
			ans++;
			continue;
		}
		else{
			if(check==1){
				if(find(x)==find(y+n)||find(x)==find(y+2*n)){ //ͬʱÊÇA£¬Í¬Ê±ÊÇB£¬Í¬Ê±ÊÇC Çé¿öÊÇÒ»ÑùµÄÖ»ÒªÓÐÆäÖÐÒ»ÖÖ²»³ÉÁ¢È«²¿²»³ÉÁ¢ËùÒÔÔÚÕâÀïÖ»ÒªÅжÏxÊÇAµÄʱºò³É²»³ÉÁ¢¼´¿É 
					ans++;
					continue;
				}
				else{
					unite(x,y);
					unite(x+n,y+n);
					unite(x+2*n,y+2*n);
				}
			}
			else{
				if(find(x)==find(y)||find(x)==find(y+2*n)){
					ans++;
					continue;
				}
				else{
					unite(x,y+n);
					unite(x+n,y+2*n);
					unite(x+2*n,y);
				}
			}
		}
	}
	cout<<ans<<endl;
}

 可持久化并查集

https://www.bilibili.com/video/BV1r4411A7b8?p=2&spm_id_from=pageDriver

开两个数组rootfa和rootdep分别代表当前节点管理的(l,r)和(l==r)时其对应的深度

需要注意的是可持久化并查集并不能使用路径压缩，假设a-b-c-d,如果改变了d，那么需要加入3个新版本的root节点，这样会mle。

所以使用启发式合并:

如果深度不同则将深度小的节点的根节的父亲改为深度大的节点的根节点,当前版本对应的深度等于上个版本深度

modify(1,n,rootfa[ver-1],rootfa[ver],x,y);
rootdep[ver]=rootdep[ver-1];

如果深度相同，则将x节点的根节的父亲改为y节点的根节点，然后将y节点的深度加1 

modify(1,n,rootfa[ver-1],rootfa[ver],x,y) 

modify(1,n,rootdep[ver-1],rootdep[ver],y,depy+1);

https://www.luogu.com.cn/problem/P3402 板子题

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+5;
struct node{
	int l,r,val;
}hjt[maxn*40*2];
int n,m;
int cnt,rootfa[maxn],rootdep[maxn],tot;
void build(int l,int r,int&now){
	now=++cnt;
	if(l==r){
		hjt[now].val=++tot;    //tot代表的是对应的父亲
		return;
	}
	int m=(l+r)>>1;
	build(l,m,hjt[now].l);
	build(m+1,r,hjt[now].r);
}
void modify(int l,int r,int ver,int&now,int pos,int num){
	now=++cnt;
	hjt[now]=hjt[ver];
	if(l==r){
		hjt[now].val=num;
		return;
	}
	int m=(l+r)>>1;
	if(m>=pos){
		modify(l,m,hjt[ver].l,hjt[now].l,pos,num);
	}
	else{
		modify(m+1,r,hjt[ver].r,hjt[now].r,pos,num);
	} 
}
int query(int l,int r,int now,int pos){
	if(l==r){
		return hjt[now].val;
	}
	int m=(l+r)>>1;
	if(m>=pos){
		return query(l,m,hjt[now].l,pos);
	}
	else{
		return query(m+1,r,hjt[now].r,pos);
	}
}
int find(int ver,int x){
	int fx=query(1,n,rootfa[ver],x);
	if(fx==x){
		return x;
	}
	else{
		return find(ver,fx);
	}
}
void merge(int ver,int x,int y){
	x=find(ver-1,x),y=find(ver-1,y);
	if(x==y){
		rootfa[ver]=rootfa[ver-1];
		rootdep[ver]=rootdep[ver-1];
	}
	else{
		int depx=query(1,n,rootdep[ver-1],x);
		int depy=query(1,n,rootdep[ver-1],y);
		if(depx<depy){
			modify(1,n,rootfa[ver-1],rootfa[ver],x,y);
			rootdep[ver]=rootdep[ver-1];
		}
		else if(depx>depy){
			modify(1,n,rootfa[ver-1],rootfa[ver],y,x);
			rootdep[ver]=rootdep[ver-1];
		}
		else{
			modify(1,n,rootfa[ver-1],rootfa[ver],x,y);
			modify(1,n,rootdep[ver-1],rootdep[ver],y,depy+1);
		}
	}
}
int main(){
	cin>>n>>m;
	build(1,n,rootfa[0]);
	for(int ver=1;ver<=m;ver++){
		int opt;
		cin>>opt;
		if(opt==1){
			int x,y;
			cin>>x>>y;
			merge(ver,x,y);
		}
		else if(opt==2){
			int k;
			cin>>k;
			rootfa[ver]=rootfa[k];  //对应的是rootfa[k]作为根节点
			rootdep[ver]=rootdep[k];
		}
		else{
			int x,y;
			cin>>x>>y;
			rootfa[ver]=rootfa[ver-1];
			rootdep[ver]=rootdep[ver-1];
			int fx=find(ver,x);
			int fy=find(ver,y);
			if(fx==fy){
				cout<<"1"<<"\n";
			}
			else{
				cout<<"0"<<"\n";
			}
		}
	}
}

技巧删除边操作：首先，查询的操作很明显带有自反对称和传递性，易想到用并查集来解决，但是并查集只有添加边和查询两种操作，故需要一些技巧，就是读入并记录所有的操作，从最后一条操作开始处理，一开始的图是给定的图删去后来需要销毁的边后的图，记录答案，当读到销毁操作时再把需销毁的边加上去，这样就可以回避销毁操作（倒着来事实上把销毁操作变成了加边的操作）。   ZOJ-3261

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <set>
#include <iostream>
using namespace std;
typedef pair<int,int>pii;
int const N = 10000 + 10;
int n,m,x,y,Q;
int p[N],fa[N],sum[N],num[N],ans[5*N];
pii c[2*N];
struct Query
{
	string s;
	int a,b;
}q[5*N];
set<pii>st;
void Init(){
	st.clear();
	for(int i=0;i<=n-1;i++)	fa[i] = i,num[i] = i;
	for(int i=0;i<=n-1;i++){   //每个星星的能量
		scanf("%d",&p[i]);
		sum[i] = p[i];
	}
	scanf("%d",&m);
	for(int i=0;i<m;i++){ //相连的星星
		scanf("%d%d",&x,&y);
		st.insert(make_pair(min(x,y),max(x,y)));   //这里一定要注意统一！！
	}
	scanf("%d",&Q);
	for(int i=0;i<Q;i++){  //询问
		cin>>q[i].s;
		if(q[i].s[0] == 'q')	cin>>q[i].a;
		else{
			scanf("%d%d",&q[i].a,&q[i].b);
			st.erase(make_pair(min(q[i].a,q[i].b),max(q[i].a,q[i].b)));
		}
	}
}
int find(int x){
	return x == fa[x] ? x : (fa[x] = find(fa[x]));
}
void Union(int x,int y){
	int fx = find(x),	fy = find(y);
	if(fx != fy){
		fa[fx] = fy;
		if(sum[fy] < sum[fx]){
			sum[fy] = sum[fx];
			num[fy] = num[fx];
		}else if(sum[fy] == sum[fx]){
			if(num[fx] < num[fy])
				num[fy] = num[fx];
		}
	}
}
int main(){
	bool first = true;
	while(~scanf("%d",&n)){
		if(first)	first = false;
		else printf("\n");
		Init();
		for(set<pii>::iterator it=st.begin();it!=st.end();it++)
			Union(it->first,it->second);
		for(int i=Q-1;i>=0;i--){
			if(q[i].s[0] == 'q'){
				int u = find(q[i].a);
				if(sum[u] <= p[q[i].a])	ans[i] = -1;
				else	ans[i] = num[u];
			}else{
				Union(q[i].a,q[i].b);
			}
		}
		for(int i=0;i<Q;i++)
			if(q[i].s[0] == 'q')	printf("%d\n",ans[i]);
	}
	return 0;
}

利用并查集判断是否是一棵树:思路是每次合并两个点，如果之前已经合并过了那么说明构成了环，不是一棵树。完成之后检查集合的个数是否为1(即图是否连通或者树的根节点是否是一个如果根节点>1那么也不是一棵树)      POJ-1308

#include<iostream>
#include<set>
using namespace std;
const int maxn=105;
int pre[maxn];
set<int>s;
void init(){
	for(int i=0;i<105;i++){
		pre[i]=i;
	}
}
int find(int x){
	if(x!=pre[x]){
		pre[x]=find(pre[x]);
	}
	return pre[x];
}
void unite(int x,int y){
	x=find(x);
	y=find(y);
	if(x==y) return;
	else pre[x]=y;
}
int main(){
	int x,y;int t=0;
	while(cin>>x>>y){
		t++;
		if(x==0&&y==0){
			cout<<"Case "<<t<<" is a tree."<<endl;
			continue;
		}
		else if(x==-1&&y==-1) break;
		init();
		bool check=1;
		if(x==y) check=0;
		else unite(x,y);
		s.insert(x);
		s.insert(y);
		while(cin>>x>>y){
			if(x==0&&y==0){
				break;
			}
			if(find(x)==find(y)) check=0;
			unite(x,y);
			s.insert(x);
			s.insert(y);
		}
		set<int>::iterator it;
		set<int>st;
		for(it=s.begin();it!=s.end();it++){
			int now=*it;
			now=find(now);
			st.insert(now);
			if(st.size()>1){
				check=0;
				break;
			}
		}
		if(check){
			cout<<"Case "<<t<<" is a tree."<<endl;
		}
		else{
			cout<<"Case "<<t<<" is not a tree."<<endl;
		}
	}
}

b1ue1ue1ue
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
并查集学习感悟
weixin_45925852的博客
07-12 339
这几天练习了并查集，之前其实学过这个东西，但了解的不深，这几天又加深了印象，以前听人说并查集是二叉树的基础，但我还没学过二叉树，还不清楚。 并查集实际上就是一种从底层往上找源头的算法，就比如你顺着黄河的任何一个入海口往上走都会能走到青藏高原上黄河的发源地，但你从发源地却不一定能走到一个特定的入海口，所以我们把发源地叫做父类，入海口叫做子类。并查集的算法就是由子类找父类。 并查集有几个代码模块1：初始化。 2：查找父类。 3：让两个不关联的并查集关联起来。4：压缩路径，使子类全部...
带权并查集学习的一些心得体会
Nero的博客
09-22 217
这两天学习了一些新型的并查集，比如带权并查集，种类并查集等。 众所周知，并查集就是记录了元素和元素之间的关系，主要是归属关系，可以把一部分元素分类到其所属的集合中，而带权并查集，维护的就不只是关系了，还有元素和元素之间的权值差。如果将一个并查集类比成一张图，那么所谓带权，就是指边权或者点权。 这是一个简略的带权并查集，1就是这个集合的头，带圈的数字就是元素，其他数字就是对应的权值，将其转化为点权...
种类并查集学习心得
BlessingXRY的博客
01-29 1198
修正信息备注： 1.【2018-01-29】创作博文基础 2.【2018-01-29】增加样例2.2 一、基本性质 1.在基于并查集的基础上增加记录数组_rank，表示i与其同集合根节点的关系 二、例题讲解 2.1【食物链 POJ - 1182】——vjudge题目链接 题意： 动物王国中有三类动物A,B,C，这三类动物的食物链构成了有趣的环形。A吃B， B吃C，C吃A。 现有N
并查集总结--逐步分析，并查集没有那么难
weixin_40403059的博客
09-12 457
并查集总结并查集一、动态连通性二、实现思路三、优化代码四、路径压缩五、总结一下六、并查集的应用写在最后 并查集 关于并查集看到一个有意思的解释，可以很好的帮助理解并查集。并查集详解（超级简单有趣~~就学会了）。 还有一篇文章对并查集有很详细的解释，写的清楚明白，Union-Find算法详解。 根据这两篇文章的内容，写写自己的理解。 一、动态连通性 先解释下什么叫做动态连通性。 动态连通性就是把原来相互独立的节点，通过某一种【等价关系】将两个节点连接起来。这里的【等价关系】就被成为“连通”。一般等价关系都具有
并查集知识点总结和学习心得分享
weixin_45590210的博客
05-02 428
先介绍一下并查集的基本功能 基础的并查集主要有两种. 第一种是普通的并查集,主要用来处理无权的相对关系,比如说A和B是一类人,B和C是一类人,那么A和C也是一类人. 第二种是带权的并查集.种类并查集也是其中的一种.具体下面会介绍. 1.无权并查集 先引入一个问题.会给N个关系.A B代表A和B是一类东西.且具有传递性. 然后给Q个询问.问A B 是否是同一类东西.如果要O(1)的询问,我们可以建立...
c语言数据结构之并查集 总结
08-27
并查集（Union-Find Set）是一种用于管理分组的数据结构，它具备两个操作：(1) 查询元素a和元素b是否为同一组 (2) 将元素a和b合并为同一组。并查集的实现使用树形结构，使用树形结构来表示以后，每一组都对应一棵树...
C++实现并查集
08-18
C++ 实现并查集 C++ 实现并查集是一种常用的数据结构，它可以高效地管理和操作集合。并查集（Union-Find）是一种数据结构，它可以用来解决连接问题和路径压缩问题。 UnionFind 类的实现 在给定的代码中，我们...
c++初级并查集知识点总结
08-25
并查集是一种高效的数据结构，主要用于处理集合合并与查询的问题，尤其在解决不相交集合的连接和查询问题中有着广泛的应用。在C++中，实现并查集可以通过定义一个数组`f`来存储每个元素的父节点，以此构建一个树形...
ACM学习：并查集学习总结
qq_62906846的博客
05-08 561
本周学习了并查集和拓扑排序的一些知识，因此主要在这方面看了些资料。也看了一些题，对做题思路和需要找寻的关键因素有了印象。因为上课时有的知识点没听懂，因此主要工作就偏向于理清概念和总结规律了。 一.并查集的自我理解 并查集，其实就是一个可以储存图的数，它的功能就是“并”，“查”，“集”。即： 并：合并两个结点（集合），使其父结点同一。 查：搜索当前结点的祖宗结点，常用于两节点合并前的条件判断 集：建立一个新集合。 它储存图有邻接矩阵，邻接表两种方法，其中邻接矩阵适用于边数较多的图（如网图之类的
并查集运用
yan
04-27 407
来点心得体会吧！ intFind(int x) {        return x==fa[x]?x:fa[x]=Find(fa[x]); } voidmerger(int a,int b) {        int r1 = Find(a);        int r2 = Find(b);   /*if(r1!=r2) {      Fa[r1]=r2; } */  
并查集的运用
breeze_blows的博客
05-01 263
1.简单运用例题：L2-010 排座位2.与set的综合运用例题：L2-024 部落3.与结构体数组排序综合运用例题：L2-007 家庭房产
并查集的删除
red_red_red的博客
11-14 298
The police office in Tadu City decides to say ends to the chaos, as launch actions to root up the TWO gangs in the city, Gang Dragon and Gang Snake. However, the police first needs to identify which g...
hdu 2473 并查集的删除关系
努力奋斗才能梦想成真
08-19 553
View Code #include#includestring.h>int n,m;int p[1101000];int id[1101000];int vis[1100010];void init(){    int i;    memset(vis,0,sizeof(vis));    for(i=0;i    {        p[i]=i;        id[i]=i;    
51nod_2607 摧毁数组(并查集)
sigh_的博客
03-24 1266
摧毁数组 Problem Description 有一个由n个非负整数组成的数列 a1,a2,a3…an。现在将要一个一个摧毁这个数列中的数。同时，有一个由 1 到 n 组成的序列来告诉你每个数被摧毁的时间顺序。 每当一个元素被摧毁时，你需要找到这个当前数列中的未被摧毁的数组成的和最大的连续子序列，另外，如果当前剩余的序列是空的的话，最大和就是0。 第一个样例： 1.第三个数被删除了，现在的数列是...
并查集（Destroying Array，cf 722C）
xl2015190026的博客
10-02 440
并查集，以前只会用来做模板题以及实现最小生成树。所以做题时从来没有考虑过用并查集优化什么的。通过这次比赛，学到了。 #include #define maxn 100010 using namespace std; typedef long long ll; ll n; ll a[maxn]; ll d[maxn]; ll f[maxn]; ll v[maxn]; ll s[maxn]
并查集的删除操作
LiRewriter的博客
01-13 2653
有一类删除叫做惰性删除，其特点是，这个点仍然在集合中但不去统计它。 对于并查集，一般来说想要实现删除是有些困难的，不过如果用一些黑科技就会非常简洁。 首先先引入按秩合并并查集的概念。用路径压缩的并查集，复杂度虽然是O(nα(n))O(n \alpha (n))，但是会破坏原本的结构，这是比较令人不爽的。 但是朴素的并查集在最坏的情况下查询会被卡成O(n)O(n)，这是无法接受的慢。所以我们需
CF 772C Destroy Array 并查集
oldFlag
10-11 799
题意是说，给你一串长为n的数列，然后给你1-n的某一种排列，按照这个排列里面的数去销毁数列中相应位置的数，销毁某个位置的数之后，这个数列就被分为了几个不相连的几段，问销毁这个位置的数后，这些段里面，和最大为多少。一开始觉得，这不是一个线段树吗？..销毁个位置单点更新上去...然后根就是答案..啥的..然后再想想，问题来了，线段树节点存什么呢？存区间和？存区间和的最大值？？？这就不好办了，反正不好搞
c++并查集（详细总结）
YSJ367635984的博客
02-01 6293
老话重谈，先看定义 并查集是一种树型的数据结构，用于处理一些不相交集合（disjoint sets）的合并及查询问题。常常在使用中以森林来表示。 首先得明白一些概念： 什么是树，什么是森林（由树组成的叫森林hh），什么是集合 这些问题是其他范畴的知识，就不过多累赘了，不了解的同学建议提前了解先。 下面我们切入重点 1、并查集 首先，我个人认为并查集在逻辑上是一个森林，该森林内由一棵或多棵数组成，如下举个例子 这三棵树可以组成一个森林，而这个森林可以叫并查集，每棵树可以称为并查集分量，这是逻辑上的理解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值