并查集 （DSU）

最新推荐文章于 2022-09-25 08:57:22 发布
最新推荐文章于 2022-09-25 08:57:22 发布
阅读量496 收藏
点赞数 1
分类专栏： 查并集 文章标签： 并查集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cosx_/article/details/110139953
版权

2

学习链接

注：

在合并完所有的节点之后
加一句 for(int i = 0; i < n; i++) Find(i);
将所有的节点的根节点查找一遍，这样能保证所有的同根节点的指向都是根节点 ，不然会导致一些节点所存的节点还位于某个分支节点，这时并不指向根节点，在求同根节点的节点数时会导致错误。

路径压缩参考博客
非递归路径压缩

int Find(int x)
{
	int r = x, j, k = x;
	while(r != bcj[r]) r = bcj[r]; // 寻找根节点 
	while(k != r)  
	{
		j = bcj[k];  // 暂存此时k的父节点 
		bcj[k] = r;  //  将k的父节点改为根节点 
		k = j;  //  k移到父节点   直至全改为根节点  
	}
	return r;
}

递归路径压缩

int Findd(int x)
{
	return bcj[x] == x ? x : bcj[x] = Findd(bcj[x]); 
}

合并

void Union(int x,int y)
{
	x = Findd(x);//  x变成x的根节点 
	y = Findd(y);//   y变成y的根节点 
	if(x != y) bcj[x] = y; //  根节点不同  x的根节点改成y 
}

注：记得更新根节点
在合并完所有节点之后
加一句 for(int i = 0; i < n; i++) Find(i);
这样能保证所有的节点都指向根节点，不然还会一些节点指向的分支节点，在求位于同根节点的节点数时会出错。
（虽然在求这个节点的根节点时，通过Find函数的路径压缩，会求出根节点，但是求之前保存的节点并不是根节点，所有要求一下）
eg：poj 1611
ac代码

#include<iostream>
#include<cstdio>
using namespace std;
const int Max = (int)1e5 + 9; 
int t,n,m;
int bcj[Max];
int Find(int x)
{
	int r = x, j, k = x;
	while(r != bcj[r]) r = bcj[r]; // 寻找根节点 
	while(k != r)  
	{
		j = bcj[k];  // 暂存此时k的父节点 
		bcj[k] = r;  //  将k的父节点改为根节点 
		k = j;  //  k移到父节点   直至全改为根节点  
	}
	return r;
}
int Findd(int x)
{
	return bcj[x] == x ? x : bcj[x] = Findd(bcj[x]); 
}
void Union(int x,int y)
{
	x = Findd(x);//  x变成x的根节点 
	y = Findd(y);//   y变成y的根节点 
	
	if(x != y) bcj[x] = y;
}
/*
if(x == 0 && y != 0) bcj[y] = x;
	else if(y == 0 && x != 0) bcj[x] = y;
*/
void work()
{	
	for(int i = 0; i < n; i++) bcj[i] = i;
	int x, y, sum = 0, t;
	while(m--)
	{
		scanf("%d %d", &t, &x);
		for(int i = 1; i < t; i++)
		{
			scanf(" %d", &y); Union(x, y);
		}
	}
	
	for(int i = 0; i < n; i++) Find(i);// 更新根节点
	int p = bcj[0];//  保存一下0号嫌疑人的根节点
	
	for(int i = 0; i < n; i++)
	{
		if(bcj[i] == p) sum++;// 相同就是嫌疑人
		//printf("%d %d\n",i,bcj[i]);
	}
	cout << sum << endl;
}
int main()
{
	
	while(scanf("%d %d", &n, &m), m + n) 
		work();
	return 0;
}

/
/
/
/
/
/

种类并查集

解决本题有两种方案，一种是带权并查集，一种是完全合并(开二倍或三倍数组)
/
/
/
/
/
/

学习博客
学习链接
例题
sdnu 1076
题目：已知有 n 个学生，其中有男生也有女生，给定 m 个关系，每个关系表示两个同学性别是否相同。如 同学A 和同学 B 是同性，或不是同性，判断这些条件中是否存在矛盾。
Input
第一行为两个整数 n(1 <= n <= 1000)， m(1 <= m <= 1000)，每个同学编号为1到n，之后m行，每行三个整数，前两个整数表示两个同学的编号，第三个整数为0或者1，若为0，则表示两个同学为同性，否则为异性。
Output
一行，若存在矛盾，输出YES，否则输出NO

5 5
1 2 1
2 3 1
3 4 1
4 5 1
5 1 0

NO

#include<bits/stdc++.h>
using namespace std;
int n, m, bcj[2009];
int x, y ,z;
bool f=0;
int find(int x)
{
	return bcj[x] == x ? x : bcj[x] = find(bcj[x]);
}
void Union(int x, int y)
{
	x = find(x);
	y = find(y);
	if(x != y) bcj[y]=x;
}
void work()
{
	f=0;
	for(int i = 1; i <= n*2; ++i) bcj[i] = i;
	while(m--)
	{
		cin >> x >> y >> z;
		if(x<=0||x>n||y<=0||y>n) f=1;
		if(z==1)
		{
			if(find(x)==find(y)||find(x+n)==find(y+n)) f=1;
			// [1,n], [n+1,2n]
			//  两个并查集建立关系就是敌对
			Union(x,y+n);//   x 是 y 的敌人
			Union(x+n,y);//   y 是 x 的敌人
		}
		else 
		{
			if(find(x)==find(y+n)||find(x+n)==find(y)) f=1;	
			//  同一个并查集建立关系就是朋友
			Union(x,y);
			Union(x+n,y+n);
		}
	}
	if(f) cout << "YES\n";
	else cout << "NO\n";
}
int main()
{
	cin >> n >> m；
	 work();
	return 0;
}

P1525 [NOIP2010 提高组] 关押罪犯

两倍的数组相当于两个监狱，A和B
每次进行这个合并
merge(x, y+n); // 敌人的敌人是朋友
merge(x+n, y);
并没有一定把某个人放到确定监狱，它是用来维护对立关系
数据：
4 6
1 4 2534
2 3 3512
1 2 28351
1 3 6618
2 4 1805
3 4 12884

排完序：
1 2 28351
3 4 12884
1 3 6618
2 3 3512
1 4 2534
2 4 1805

先维护1，2是对立，然后是3，4，但是他们具体在哪个监狱是不确定的，只是保证对立关系，维护敌人的敌人是朋友
然后加入1，3，因为一直在维护敌人的敌人是朋友这个关系，1和2，3是敌人，所以2，3合并在一起了；3和1，4是敌人，所以1，4合并在一起了

然后是2，3，无法调和输出最小矛盾

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
using namespace std;
const int MAXN = 2e5 + 7;
struct node
{
	int x, y, c;
}a[MAXN];
int pre[MAXN];
int n, m;
void init()
{
	for(int i = 1; i <= 2 * n; i++)  // 记得并查集初始化两倍大小
		pre[i] = i;
}

bool cmp(node a, node b)
{
	return a.c > b.c;
}


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

void merge(int a, int b)
{
	int x = find(a);
	int y = find(b);
	if(x != y)
	{
		pre[y] = x;
	}
	return ;
}

int main()
{
	cin >> n >> m;
	init();
	for(int i = 1; i <= m; i++)
		scanf("%d%d%d",&a[i].x, &a[i].y, &a[i].c);
	sort(a+1, a+1+m, cmp);
	int flag = 0;
	for(int i = 1; i <= m; i++)
	{
		int x = a[i].x;
		int y = a[i].y;
		int c = a[i].c;
		if(find(x) == find(y)) // 两个罪犯在一个并查集之中 不可调和
		{
			cout << c << endl;
			return 0;
		}
		merge(x, y+n); // 敌人的敌人是朋友
		merge(x+n, y);
	}
	cout << 0 << endl;  // 特判
	return 0;
}

食物链

用一个三倍大小的并查集进行维护，用i+n表示i的捕食对象，而i+2n表示i的天敌。

#include<bits/stdc++.h>
using namespace std;
const int N = 50009;
int bcj[N*3];
// [1,n] [n+1-2n] [2n+1,3n]
// x+n吃x，x+2n吃x+n，x吃x+2n

int n, k;
int d, x, y;
int ans;
int Find(int x)//  递归写法在sdnuoj会超时
{
	int r = x, j, k = x;
	while(bcj[r] != r) r = bcj[r];
	while(k != r)
	{
		j = bcj[k];
		bcj[k] = r;
		k = j;
	}
	return r;
}
void Union(int x, int y)
{
	x = Find(x);
	y = Find(y);
	if(x != y) bcj[y] = x;
}
int main()
{
	cin >> n >> k;
	for(int i = 1;i <= n*3; ++i) bcj[i] = i;
	
	while(k--)
	{
		scanf("%d %d %d", &d,&x,&y);
		if (x > n || y > n || x < 1 || y < 1) { ans++;continue; }
		if(d == 1)
		{
			if(Find(x) == Find(y+n) || Find(x) == Find(y+2*n)) 
			{
				ans++;continue;
			}
			Union(x, y);
			Union(x+n,y+n);
			Union(x+2*n,y+2*n);
		}
		else 
		{
			if(Find(x) == Find(y) || Find(x) == Find(y+2*n))
			{
				ans++;continue;
			}
			Union(x,y+n);
			Union(x+n,y+2*n);
			Union(x+2*n,y);
		}
	}
	cout << ans << endl;
	return 0;
}

sdnu oj 1016
矩形合并

#include<bits/stdc++.h>
using namespace std;
int bcj[109];
struct jx
{
	int x1,x2,y1,y2;
}a[109];
bool check(jx a, jx b)// 这个check是灵魂   画图模拟一下
{
// a的左下角的坐标大于b的右上角  保证开始有重叠
// 然后限定  a的右上角大于b的左下角
	if(a.x1 < b.x2 && a.y1 < b.y2 && a.x2 > b.x1 && a.y2 > b.y1)
		return 1;
	return 0;
}
int Find(int x)
{
	return x == bcj[x] ? x : bcj[x] = Find(bcj[x]);
}
Union(int x, int y)
{
	bcj[Find(x)] = bcj[Find(y)];
}
int main()
{
	int n;
	int sum = 0;
	cin >> n;
	for(int i = 1; i <= n; ++i)
		bcj[i] = i;
	for(int i = 1; i <= n; ++i)
		scanf("%d %d %d %d", &a[i].x1,&a[i].y1,&a[i].x2,&a[i].y2);
	for(int i = 1; i <= n; ++i)
	{
		for(int j = i + 1; j <= n; ++j)
		{
			if(check(a[i],a[j]))
				Union(i, j);
		}
	}
	int ans = 0;
	for(int i = 1; i <= n; ++i)
		if(bcj[i] == i) ans++;
	cout << ans << endl;
	return 0;
}

牛客水题~
至于贴一下这个题的原因嘛。。。
就是老师这个点是迷惑性的

#include<bits/stdc++.h>
using namespace std;
int m, n;
int bcj[60];
int Find(int x)
{
	return x == bcj[x] ? x : bcj[x] = Find(bcj[x]);
}
void Union(int x,int y)
{
	x = Find(x);
	y = Find(y);
	if(x != y)
		bcj[y] = x;
}
int main()
{
	while(~scanf("%d", &n))
	{
		for(int i = 1; i <= 55; ++i) bcj[i] = i;
		cin >> m;
		int x, y;
		for(int j = 1; j <= m; ++j)
		{
			cin >> x >> y;
			if(x != n) Union(x, y);// 老师有学生的手机号没用，不合并
		}
		/*for(int i = 1; i <= n; ++i)
			Find(i);
		for(int i = 1; i <= n; ++i)
			cout << bcj[i] << " "; cout << endl;*/
		if(Find(1) == Find(n))
			cout << "Yes\n";
		else cout << "No\n";
	}
	return 0;
}

/*
4 3
2 3
1 4
4 1

4 3
2 3
4 1
1 4
*/
__Rain
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
并查集(DSU)
8rfuz的博客
10-26 6506
并查集的英文是Disjoint Set Union， 因此又称（DSU） 算法导论里的 不相交集合的数据结构  章节指的就是这个。 并查集有两种优化策略： 1.按秩合并 Union by Rank 2.路径压缩 Path Compression 使用与不使用这些策略的时间复杂度分析如下： 在实际应用中，人类现有甚至未来的数据几乎不
并查集是什么
m0_65159801的博客
08-07 145
并查集，在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素在哪个集合中。这一类问题近几年来反复出现在信息学的国际国内赛题中。其特点是看似并不复杂，但数据量极大，若用正常的数据结构来描述的话，往往在空间上过大，计算机无法承受；即使在空间上勉强通过，运行的时间复杂度也极高，根本就不可能在比赛规定的运行时间（1～3秒）内计算出试题需要的结果，只能用并查集来描述。...
并查集(Disjoint Set Union,DSU)
weixin_30730053的博客
03-25 193
定义： 并查集是一种用来管理元素分组情况的数据结构。 作用： 查询元素a和元素b是否属于同一组 合并元素a和元素b所在的组 优化方法： 1.路径压缩 2.添加高度属性 拓展延伸： 分组并查集 带权并查集 代码如下： //带有路径压缩的并查集 //一句话并查集(常用) int dsu(int x){ return x==par[x]?x:(par[x]=ds...
并查集（DSU）
Cap07博客
04-16 370
#include<iostream> using namespace std; int find_root(int x, int parent[]) { //找x的祖先根节点 int x_root = x; while (parent[x_root] != -1) { x_root = parent[x_root]; } return x_root; } int union_root(int x, int y, int parent[]) { //联合x和y的根节点 int .
经典算法：并查集（DSU）结构简介
codename_cys的博客
09-26 4550
Python笔记：并查集（DSU）结构简介 1. 并查集是什么 2. 并查集原理 3. 并查集代码实现 1. 一般代码实现 2. 优化的DSU结构 1. 调整树形结构 2. 每次查找后更新节点信息 4. Leetcode例题分析 1. Leetcode 547. Friend Circles 2. Leetcode 721. Accounts Merge 3. Leetcode 128. Longest Consecutive Sequence 4. Leetcode 1579. Rem..
并查集主要操作及主要操作.docx
03-08
并查集（Disjoint-Set Union，简称DSU）是一种用于处理集合合并和查询问题的数据结构。它主要支持两种操作：查找（Find）和合并（Union）。并查集通常被用于解决一些图论、网络连接和集合类的算法问题。 ### 主要...
[ONTAK2015] Bajtocja 题解.pdf
01-16
1. **并查集（Disjoint Set Union, DSU）**： - 在这个题目中，我们需要判断在每次操作后，有多少个点对在所有图中都是联通的。并查集是一种数据结构，用于管理一组离散的元素，并快速判断它们是否属于同一集合。在...
啊哈算法哈磊第七章使用并查集实现犯罪团队搜索-Java实现
06-17
本资源源自《啊哈算法》第七章节的精彩内容，专注于利用并查集（Disjoint Set Union, DSU）数据结构解决实际问题，具体展示了如何通过Java实现来高效搜索犯罪团队成员。哈磊老师以其生动的讲解风格，首先深入介绍了...
啊哈算法哈磊第八章使用并查集与快速排序实现图的最小树生成-Java实现
最新发布
06-18
本资源源自《啊哈算法》第七章节的精彩内容，专注于利用并查集（Disjoint Set Union, DSU）数据结构解决实际问题，具体展示了如何通过Java实现来高效搜索犯罪团队成员。哈磊老师以其生动的讲解风格，首先深入介绍了...
dsu_osu
02-20
它常用于解决并查集问题，例如在图论中的连通性判断、最小生成树等。OSU可能在此项目中扮演了一个教学或者研究的角色，提供了相关的课程、代码示例或者研究论文。 【标签】"Jupyter Notebook"表明这个项目使用了...
模拟试题 树（点分治/DSU）
DancingZ的博客
09-21 271
Description 给出一棵树，求出最小的k，满足在树中存在路径P，使得k≥S且k≤E。（k为路径上的边的权值和） Input 第一行给出N,S,E。N代表树的点数，S,E如题目描述一致。 下面N-1行给出这棵树的相邻两个节点的边及其权值W。 Output 输出共一行一个整数，表示答案。若无解输出-1。 Sample Input 5 10 40 2 4 80 2 3 57 1 2...
dsu之一
思考使人沉静
07-12 2471
摆在桌上的文章有只有11页长，是关于所谓动态地软件更新。摘要关键字1引论2相关工作3结构3.1仓库管理器3.2映像管理器和内存管理器3.3引导装入器4模块化与依赖分析5动态代码更新5.1对函数的引用5.2活动的函数5.3调用栈上的函数5.4变量的更新6结论和当前状态引用从3开始，我认为有启发的思想就是对功能的抽象，他们根据不同阶段的功能抽象了6个-er——ELFextractor,  RepositoryManager, MemoryManager, Linker, Image Manager, Bootl
树上启发式合并，静态链分治（DSU）
qq_42852687的博客
04-06 785
树上启发式合并，静态链分治（DSU）一，讲解二，使用T1题目友好链接题解codeT2题目友好链接题解codeT3题目友好链接题解codeT4题目友好链接题解codeT5题目友好链接题解code 一，讲解 https://www.acwing.com/solution/content/59241/ 遍历每一个节点 递归解决所有的轻儿子，同时消除递归产生的影响 递归重儿子，不消除递归的影响 统计所有轻儿子对答案的影响 更新该节点的答案 删除所有轻儿子对答案的影响 二，使用 T1 题目 一片森林，每次询问一
dsu题集
weixin_30692143的博客
07-12 124
【带权并查集】CodeForces - 982DShark 题目大意： 题意有点难理解，就是给你一个长为n的数组,你可以任意选定一个数字k，使得大于等于k的数变成0，其他数变成1,然后要满足每个1的块其中1的数量相同，并且你要保证为1的块尽可能多，问你满足条件的最小的k为多少。 解题分析： 因为该序列所有元素都不相同，所以最小的k值一定是其中某个元素的值+1，然后就是将序列元素的值...
dsu之二
思考使人沉静
07-12 959
<br />继续考虑动态更新。想想看能不能用代码插装（code instrumentation）的办法解决？看到了很多实现，有John Panzer的99年（！）在C/C++ Users Journal发表的Automatic Code Instrumentation。里面用到了vc编译器的一个特性，打开-Gh开关后可以插入一个_penter函数，然后通过_penter可以做出自己的_pexit，这样就可以在进入和退出函数时插入代码。因为代码插装通常都用在性能分析中，所以可以加上计时的代码。动态更新不用这么
【C++】【并查集】并查集实现、模板；并查集基于size、rank的优化；
多丰富下自己呀
06-29 465
目录一、引入并查集1、连接问题与路径问题：2、接口二、基础并查集1、 Quickfind模式：1.1、实现2、Quickunion模式：2.1、实现3、Quickunion模式优化：3.1、 Quickunion优化size：3.2、优化size实现3.3、 Quickunion优化rank：3.4、优化rank实现参考 一、引入并查集 ○ 解决连接问题（网络中节点的连接问题）（两个社交网络中的人能不能根据好友互相认识）。 ○ 数学中的集合类的实现。 ○ 并查集的高效是因为只回答了连接问题，没有回答路径问题
【图论】二分图的应用(染色法判断二分图，最大匹配，最小点覆盖，最大独立集，最小路径点覆盖，最小路径重复点覆盖)
a碟的博客
08-21 867
目录概念什么是二分图?二分图的判定匹配问题名词概念匈牙利算法染色法判断二分图-关押罪犯最大匹配-棋盘覆盖最小点覆盖-机器任务最大独立集-骑士放置最小路径重复点覆盖-捉迷藏 概念 什么是二分图? 顾名思义就是能分成两个部分的图 二分图是一个图，它的顶点可以分为两个独立的集合UUU和VVV，这样每一条边(u，v)(一个点在UUU，一个点在VVV)要么从uuu到vvv连接一个顶点，要么从vvv到uuu连接一个顶点。换句话说，对于每一条边(u，v)，要么uuu属于UUU，要么vvv属于VVV，或者uuu属于VVV，
动规(24)-并查集基础题——关押罪犯
热门推荐
abraham的博客
09-25 1万+
如果两名怨气值为c 的罪犯被关押在同一监狱，他们俩之间会发生摩擦，并造成影响力为c 的冲突事件。公务繁忙的Z 市长只会去看列表中的第一个事件的影响力，如果影响很坏，他就会考虑撤换警察局长。他准备将罪犯们在两座监狱内重新分配，以求产生的冲突事件影响力都较小，从而保住自己的乌纱帽。接下来的M 行每行为三个正整数aj，bj，cj，表示aj 号和bj 号罪犯之间存在仇恨，其怨气值为cj。罪犯之间的怨气值如下面左图所示，右图所示为罪犯的分配方法，市长看到的冲突事件。对于70%的数据有N≤2000，M≤50000。
带权并查集的基本操作
mxYlulu的博客
06-30 283
参考博客 带权并查集就是一系列能够维护结点到根节点权值的特殊并查集。 常用于区间可合并的求和和判断。甚至差值也可以判断。十分巧妙。 在查询操作上，维护权值，路径压缩到根节点的过程，将中间的路径长度也加到该点上。 int find(int x) { if (x != f[x]) { int t = f[x]; f[x] = find(f[x]); sum[x] += sum[t]; ...
dsu loader 安装失败
05-31
为了帮助你解决 dsu loader 安装失败的问题，我需要了解更多的信息。请回答以下问题： 1. 你使用的是哪个操作系统？ 2. 你是从哪里下载的 dsu ...回答这些问题可以帮助我更好地了解你的问题，并提供更准确的解决方案。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值