查并集Disjoint Set（不相交的集合）

最新推荐文章于 2022-07-20 08:00:00 发布
最新推荐文章于 2022-07-20 08:00:00 发布
阅读量843 收藏 2
点赞数
分类专栏： 学习随更 题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52723996/article/details/113530865
版权

目录

学习篇+板子

常见两种操作：
1、合并两个集合
2、查找某个元素属于哪个集合

实现方法一（常用）： 每个集合用一棵“有根树”表示
1、定义数组Set[1,n];
2、Set[ i ] = i ;则 i 表示本集合，并使集合对应树的根
3、Set[ i ] = j ;若 j 不等于 i ，则 j 是 i 的父节点

举个例子：

Set(i)1232134334
i12345678910

在这里插入图片描述

具体操作：
1、查：最坏情况O（n）

findx(x){
    while(x!=Set[x])x=Set[x];//找父节点“找领导”
    return x;
}

2、并：O（1）

mergeset(a,b){//a,b都是根节点（他俩是各自的领导）
	Set[a]=b;//表示把a的领导换成了b；
}

避免最坏的情况：（一般不需要）
方法：将深度小的树合并到深度大的树上（深度是要另外用数组计数的）
效果：任意顺序合并后，包含k个节点的树的最大高度不超过 lg（k）；
1、查：

findx(x){
    while(x!=Set[x])x=Set[x];//找父节点“找领导”
    return x;
}

2、并：

mergeset(a,b){//a,b都是根节点（他俩是各自的领导）
	if(h[a]==h[b]){
		h[a]++;
		Set[b]=a;
	}
	else if(h[a] <h[b])Set[a]=b;
	else Set[b]=a;
}

实现方法二（不常用）：
1、用编号最小的元素标记所在集合；
2、定义一个数组Set[1,n],其中Set[i]表示元素i所在的集合；

举个例子：

Set(i)1214261622
i12345678910

则不相交集合：
{1，3，7}，{4}，{2，5，9，10}，{6，8}
课件每个不相交集合的第一个元素所对应的Set(0)就为该集合中所有元素所对应的值

具体操作：
1、查：O（1）

findx(x){return Set[x];}

2、合并：O（n）

mergeset(a,b){
    i=min(a,b);
    j=max(a,b);
    for(k=1;k<=n;k++){
       if(Set[k]==j)Set[k]=i;
    }
}

并集的简单应用
1、最小生成树

水题集

hdu 1232：求至少还需要建多少条路使城市互通

hdu 1233

题意：给出互通的两个城市的编号，使全省任意两个城市互通，最少还需要建设多少条道路。
典型的查并集问题

#include <bits/stdc++.h>
#define ll long long

using namespace std;
int s[1010];

int findx(int x){
    int r=x;
    while(s[r]!=r)r=s[r];
    return r;
}

void mergeset(int a,int b){
    int x=findx(a);
    int y=findx(b);
    if(x!=y)s[y]=x;//初次尝试查并集：注意这个地方一定是根节点换，第一次写成s[b]=a，错误
}

int main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int n,m;
    while(scanf("%d",&n),n){
        for(int i=1;i<=n;i++)s[i]=i;
        for(scanf("%d",&m);m>0;m--){
            int a,b;scanf("%d%d",&a,&b);
            mergeset(a,b);
        }
        int ans=-1;
        for(int i=1;i<=n;i++){
            if(s[i]==i)ans++;
        }
        printf("%d\n",ans);
    }
    return 0;
}

hdu 1233：最小生成树

HDU 1233
典型的最小生成树-[查并集的简单应用]

题中的：得到的统计表中列出了任意两村庄间的距离
说明了给的数据一定能形成最小生成树

#include <bits/stdc++.h>
#define ll long long

using namespace std;

//最小生成树问题
int s[110];

struct node {int a, b, d;}c[5000];
bool cmp(node x,node y){return x.d<y.d;}

int findx(int x){//查并集中的查
    while(x!=s[x])x=s[x];
    return x;
}

int main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int n;
    while(scanf("%d",&n),n){
        int m=n*(n-1)/2;
        for(int i=1;i<=m;i++)scanf("%d%d%d",&c[i].a,&c[i].b,&c[i].d);
        sort(c+1,c+1+m,cmp);//排序；将边的权值从小到大排序；
        for(int i=1;i<=n;i++)s[i]=i;//查并集一定的步骤：“根的初始化”
        
        int ans=0,g=0;
        for(int i=1;i<=m;i++){
            if(findx(c[i].a) !=findx(c[i].b) ){//只有根节点不同才能进行；否则就不是树就成环了
                ans+=c[i].d;
                s[ findx(c[i].a) ]=findx(c[i].b);//合并
                g++;if(g==n-1)break;//这一步可有可无；这一步剪枝；因为是树所以就是n-1条边；
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

此链接：别人的题解，加了个ran数组 记录深度 优化查并集，但是这给题n<100没必要加，可以学习一下别人记录深度的做法

hdu 1863：最小生成树及其能否构成的判断

HDU 1863

题中的：统计表中列出了有可能建设公路的若干条道路的成本
说明了不一定能形成最小生成树（即不能畅通输出 “？”），且 m<= sum(1+2+```+n-1)=n*n/2=5000;
不能生成最小数的判断有两个方法：

法一：
遍历每个根节点出现不同则不能生成：有两种实现方式

方式①：

#include <bits/stdc++.h>
#define ll long long

using namespace std;

//最小生成树问题
int s[110];

struct node {int a, b, d;}c[5010];
bool cmp(node x,node y){return x.d<y.d;}

int findx(int x){
    while(x!=s[x])x=s[x];
    return x;
}

int main(){
    int n,m;
    while(scanf("%d%d",&n,&m)){
        if(n==0)break;
        //if(n<m-1){printf("?\n");continue;}第一次写加了这句话直接就tle了？？？
        for(int i=1;i<=n;i++)scanf("%d%d%d",&c[i].a,&c[i].b,&c[i].d);

        for(int i=1;i<=m;i++)s[i]=i;
        sort(c+1,c+1+n,cmp);
        int ans=0,g=0,cnt=0;
        for(int i=1;i<=n;i++){
            if(findx(c[i].a) !=findx(c[i].b) ){
                ans+=c[i].d;
                s[ findx(c[i].a)]=findx(c[i].b);
                g++;if(g==m-1)break;
            }
        }
        bool f=0;
        for(int i=2;i<=m;i++){
            if(findx(1)!=findx(i)){f=1;break;}//判断根节点是否都相同
        }
        if(f)printf("?\n");
        else printf("%d\n",ans);
    }
    return 0;
}

方式②：

#include <bits/stdc++.h>
#define ll long long

using namespace std;

//最小生成树问题
int s[110];

struct node {int a, b, d;}c[5010];
bool cmp(node x,node y){return x.d<y.d;}

int findx(int x){
    while(x!=s[x])x=s[x];
    return x;
}

int main(){
    int n,m;
    while(scanf("%d%d",&n,&m),n){
        for(int i=1;i<=n;i++)scanf("%d%d%d",&c[i].a,&c[i].b,&c[i].d);

        for(int i=1;i<=m;i++)s[i]=i;
        sort(c+1,c+1+n,cmp);
        int ans=0,g=0,cnt=0;
        for(int i=1;i<=n;i++){
            if(findx(c[i].a) !=findx(c[i].b) ){
                ans+=c[i].d;
                s[ findx(c[i].a)]=findx(c[i].b);
                g++;if(g==m-1)break;
            }
        }
        for(int i=1;i<=m;i++){
            if(s[i]==i)cnt++;//cnt计数有多少个根节点
        }
        if(cnt==1)printf("%d\n",ans);
        else printf("?\n");
    }
    return 0;
}

法二：搜完那些数据以后，能构成的边小于m-1

#include <bits/stdc++.h>
#define ll long long

using namespace std;

//最小生成树问题
int s[110];

struct node {int a, b, d;}c[5010];
bool cmp(node x,node y){return x.d<y.d;}

int findx(int x){
	while(x!=s[x])x=s[x];
	return x;
}

int main(){
	int n,m;
	while(scanf("%d%d",&n,&m)){
		if(n==0)break;

		for(int i=1;i<=n;i++)scanf("%d%d%d",&c[i].a,&c[i].b,&c[i].d);

		for(int i=1;i<=m;i++)s[i]=i;
		sort(c+1,c+1+n,cmp);
		int ans=0,g=0,cnt=0;
		for(int i=1;i<=n;i++){
			if(findx(c[i].a) !=findx(c[i].b) ){
				ans+=c[i].d;
				s[ findx(c[i].a)]=findx(c[i].b);
				g++;if(g==m-1)break;
			}
		}
		if(g<m-1)printf("?\n");
		else printf("%d\n",ans);
	}
	return 0;
}

wa了好多次

hdu 1272：小希的迷宫

HDU 1272

题意：构成一个“联通的图”且不能有环

wa了好多发的原因：
1、我以为这个题仅仅只是没有环，直接找两点的根是否相同就行，但是！！！没注意到是构成一个图，也就是说，还得判断根有几个
2、输入是0 0的时要输出yes
3、输出的yes和no的大小写，最后几发被这个贡献了他竟然不是PE。

#include <bits/stdc++.h>
using namespace std;

int s[100010],v[100010];

int findx(int x){
    while(x!=s[x])x=s[x];
    return x;
}

int main(){
    int a,b;
    while(scanf("%d%d",&a,&b)){
        if(a==-1&&b==-1)break;
        if(a==0&&b==0){printf("Yes\n");continue;}
        
        for(int i=1;i<=100000;i++){s[i]=i;v[i]=0;}
        
        v[a]=1;v[b]=1;s[a]=b;
        int x,y,cnt=0,g=0;bool f=0;
        while(scanf("%d%d",&x,&y)){
            if(x==0&&y==0)break;
            v[x]=1;v[y]=1;
            if(findx(x)==findx(y))f=1;//判断是否形成环
            s[findx(x)]=findx(y);
        }
        if(f)printf("No\n");
        else {//判断形成多少个图
            for(int i=1;i<=100000;i++){
                if(v[i] && s[i]==i)g++;
            }
            if(g==1)printf("Yes\n");
            else printf("No\n");
        }
    }
    return 0;
}
MAT786
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
不相交集合（并查集）
jiaomingliang的专栏
11-20 3693
不相交集合（两集合中没有相交元素），因为只能 进行合并和查找所求元素所在的集合，因此被称为并查集，至于怎么标志哪一个集合，可以使用集合的头结点（使用链表表示并查集），若果返回的元素一样则表示为同一个集合。如果使用森林表示，则用根节点代表这一个集合。只连接两个根节点即可。   这一般应用 在无向图的连通分量和一些图的算法中。 下面说明两种实现方式：    1.  不相交森林（数组实现） 森林
不相交集合的合并
人总是要有梦想的QAQ的博客
04-02 330
#include <iostream> using namespace std; int parent[1000], a[1000]; void unionArray(int i, int j) { int x = parent[i] + parent[j]; if(parent[i] > parent[j]) { // i的节点少 pare...
8. O(1)时间求两个不相交集合的并集
weixin_30391339的博客
12-27 396
《算法导论》10.2-6 动态集合操作Union以两个不相交集合S1和S2作为输入，并返回集合S = S1∪S2。该操作通常会破坏集合S1和S2。试说明如何选用一种合适的表类数据结构，来支持O(1)时间的Union操作。 O(1)时间能干嘛？不能移动元素，只能改改指针，所以采用链表最合适，这道题采用单链表就够了。 我在之前定义的SingleLinkedList类型里面声明一个frien...
不相交集（并查集）
beichengll的博客
08-09 2758
1、不相交集是一种解决等价问题的有效数据结构，这种数据结构实现起来非常简单，每个例程只要几行代码，而且可以使用一个简单的数组实现。实现也非常快，每种操作只需要常数平均时间。2、等价关系 等价关系必须满足下面三个性质： (1):自反性，对于集合S中的任意元素a，a R a;(R为定义的关系，比如R为<=， >=等等) (2);对称性,a R b当且仅当b R a (3):传递性，若a R
用于不相交集合的数据结构——查并集
InkGenius
01-21 2118
不相交集合数据结构的概念和操作：     不相交集合数据结构（disjoing-set data structure)保持一组不相交的动态集合S={S1，S2，S3，……Sk}。每个集合通过一个代表来识别，代表即集合中的某个成员。 不相交集合数据结构支持如下操作： 1 . MAKE_SET(x)： 建立一个新的集合，其唯一成员就是x，所以其代表也就是自己。因为各集合是不相交的，故要求x没有在
python 集合 并集、交集 Series list set 转换的实例
09-20
转换到set之后，我们就可以利用集合的并集（union）和交集（intersection）方法来操作集合。并集方法返回两个集合中所有不同的元素，而交集方法返回同时存在于两个集合中的元素。以下是一个使用并集和交集方法的实例...
使用Pyhton集合set()实现成果查漏的例子
09-18
在Python编程中，集合（Set）是一种无序且不重复元素序列的数据结构，它提供了多种操作，如并集、交集、差集等，这些特性使其在数据处理中有着广泛的应用，特别是在查找缺失元素或者进行数据去重时。本文将通过一个...
查并集的概述1.txt
最新发布
04-12
并查集 并查集（Disjoint Set）是一种树型的数据结构，主要用于处理一些不相交集合（disjoint sets）的合并及查询问题。并查集的设计思路是在开始时，每个元素构成一个单元素的集合，然后按照一定顺序将属于同一组的...
C++求两个集合的并集
10-09
首先，我们要知道集合的并集是指包含两个集合所有元素的新集合，不考虑重复元素。在C++中，我们可以使用多种方法来实现这个操作，例如使用STL（Standard Template Library）中的容器，如set或unordered_set，或者...
Python语言基础：set集合运用.pptx
05-03
Python中的set集合是一种非常实用的数据结构，它包含了不重复的元素且无特定顺序。set集合在数据处理中常用于去重、成员关系测试以及集合运算等场景。下面将详细讲解set集合的创建、添加元素、移除元素、计算元素个...
数据结构与算法——并查集(不相交集合)
热门推荐
bigsai
08-28 1万+
文章目录认识并查集 认识并查集 对于并查集(不相交集合)，很多人会感到很陌生，没听过或者不是特别了解。实际上并查集是一种挺高效的数据结构。实现简单，只是所有元素统一遵从一个规律所以让办事情的效率高效起来。 对于定于，百科上这么定义的： 并查集，在一些有N个元素的集合应用问题中，我们通常是在开始时让每个元素构成一个单元素的集合，然后按一定顺序将属于同一组的元素所在的集合合并，其间要反复查找一个元素...
不相交（任意两个集合之间没有交集）集，并查集（合并，查询集合）
hueru的博客
07-28 5100
union(x,y)是指 将包含x和y的动态集合（比如说Sx和Sy）合并为一个新的集合（即这两个集合的并集），而不是简单的把两个元素合并成一个集合，而是把两个元素所在的集合合并成一个新集合。 合并两个不相交集合操作很简单： 利用FIND-SET找到其中两个集合的祖先，将一个集合的祖先指向另一个集合的祖先即可。 ...
不相交集及应用
spch2008的专栏
07-21 5454
法国法
并查集（Disjoint-set）详解（附图片例子）
踩风火轮的乌龟
11-02 1331
并查集基本思路 学习任何一个数据结构之前，都应该先定义其有哪些操作。并查集也是一种数据结构，因此，俺准备定义一下它有哪些操作。（P.S. 俺假设看这篇文章的童鞋至少高中毕业，都知道数学中的集合是个什么概念，嘿嘿） 1、初始化（initialize）操作：把集合中的每个元素看作是一个子集合 2、合并（Union）操作：把2个子集合，合并成一个集合 3、查找（Find）操作：判断2个元素是否在...
不相交集合
yejing's utopia
10-31 1124
在某些应用中，要将n个不同的元素分成一组不相交的集合，不xia
并查集——用于不相交集合的数据结构
小一的专栏
04-08 3366
并查集 并查集保持一组不相交的动态集合S={S1, S2, ..., SK}.每个集合通过一个代表来表示，代表即集合中的某个成员。 并查集的精髓（即它的三种操作）： 集合中的每一个元素是由一个对象表示的，设x表示一个对象 MAKE-SET（x） 建立一个新的集合，其唯一成员（因而其代表）就是x。因为各个集合是不相交的，故要求x没有在其他集合中出现过。 初始化后每一个元素的父亲节
不相交集类 (并查集)
小米子的成长日记
07-20 482
不相交集类是的一种有效的数据结构，其实现简单，可以使用一个简单的数组，而且每种操作只需要常数时间。本章描述了等价关系、动态等价性问题、并查集基本数据结构、按大小求并和按高度求并算法以及路径压缩，附带实现代码...
不相交集合的学习笔记
崔洪振367
11-13 646
1、一个元素a属于S的等价类是S的一个子集，它包含所有与a有（等价）关系的元素。 2、不相交集：N个集合的类，每个集合含有一个元素，所有集合间的关系均为false（除自反关系外），每个集合都有一个不同的元素，从而得到Si∩Sj=Φ，为不相交集。 3、不相交集的两种操作： 1）find（），返回包含给定元素的集合的名字。 2）添加关系：添加关系a˜b 首先判断a和b是否在同一个等价类中，用
java中set集合取并集
06-07
Java中的Set集合可以使用addAll()方法来取两个集合的并集，示例代码如下： ```java Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3)); Set<Integer> set2 = new HashSet<>(Arrays.asList(3, 4, 5)); Set<Integer> set3 = new HashSet<>(set1); set3.addAll(set2); System.out.println(set3); // 输出 [1, 2, 3, 4, 5] ``` 上面的代码中，我们先将set1复制一份，然后使用addAll()方法将set2的元素添加进去，这样就得到了set1和set2的并集set3。 需要注意的是，Set集合会去除重复的元素，因此结果中不会出现重复元素。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值