1.并查集的定义

在计算机科学中,并查集是一种树型的数据结构,用于处理一些不交集(Disjoint Sets)的合并及查询问题。有一个联合-查找算法(union-find algorithm)定义了两个用于此数据结构的操作:

  • Find:确定元素属于哪一个子集。

  • Union:将两个子集合并成同一个集合。

  • MakeSet,用于建立单元素集合。

为了更加精确的定义这些方法,需要定义如何表示集合。一种常用的策略是为每个集合选定一个固定的元素,称为代表,以表示整个集合。接着,Find(x) 返回x所属集合的代表,而Union使用两个集合的代表作为参数。

并查集森林是一种将每一个集合以树表示的数据结构,其中每一个节点保存着到它的父节点的引用

比如上面是两个集合分别记为A和B,集合A有4个元素,集合B有3个元素,每个元素都只对应一个集合,也就是一对一,对于集合的表示,通常都是使用根节点来判断,也就是说,1和5分别表示两个集合

//集合1的元素
1,2,3,4
//集合5的元素
5,6,7

那么

find(1)=1
find(2)=1
find(3)=1
find(4)=1 find(5)=5
find(6)=5
find(7)=5

2.并查集的基本操作

2.1并查集的存储结构

并查集通常用一个数组来表示,

int father[N];

其中father[i]表示元素i的父亲节点,而父亲节点本身也是这个集合内的元素,判断一个元素的集合代表,就是一直遍历元素的父亲节点,一直到father[i]=i,表示元素i的父亲节点是它自己,则遍历结束,用这个元素i来表示这个集合。

2.2并查集的初始化

一开始,每一个元素都是一个独立的集合,那么这个元素本身就可以代表集合,所以需要令father[i]等于i(1<=i<=N)。

for(int i = 1; i<= N;i++){
father[i] = i;
}

2.3查找

查找一个元素所在的集合就是查找树的根节点,可以通过递归或者迭代来实现。

递归查找

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

迭代查找

int find(int x){
while(x != father[x]){
x = father[x];
}
return x;
}

2.4合并

合并操作是对两个不同的集合合并成一个集合,接收两个元素,判断两个元素是否在不同的集合上,然后将其中一个集合的根节点的父亲结点指向另一个集合的根节点即可。

void union(int a, int b){
int faA = find(a);
int fab = find(b);
if(faa != fab){
father[faa] = fab;
}
}

3.并查集的优化

存在一种极端情况,树的逻辑结构是斜二叉树,也就是树退化成了单链表,每次查找的时候时间复杂度都是O(n)。一种优化思路是,把每一个元素的父亲节点直接指向根节点。

int find(int x){
int a = x;
while(x != father[x]){
x = father[x];
}
while(a != father[a]){
int z = a;
a = father[a];
father[z] = x;
}
return x;
}

4.并查集的应用

以下是PAT的三道关于并查集的问题。

1107 Social Clusters

When register on a social network, you are always asked to specify your hobbies in order to find some

potential friends with the same hobbies. A “social cluster” is a set of people who have some of their

hobbies in common. You are supposed to find all the clusters.

Input Specification:

Each input file contains one test case. For each test case, the first line contains a positive integer N

(<=1000), the total number of people in a social network. Hence the people are numbered from 1 to N.

Then N lines follow, each gives the hobby list of a person in the format:

Ki: hi[1] hi[2] … hi[Ki]

where Ki (>0) is the number of hobbies, and hi[j] is the index of the j-th hobby, which is an integer in [1,

1000].

Output Specification:

For each case, print in one line the total number of clusters in the network. Then in the second line, print

the numbers of people in the clusters in non-increasing order. The numbers must be separated by exactly

one space, and there must be no extra space at the end of the line.

Sample Input:

8

3: 2 7 10

1: 4

2: 5 3

1: 4

1: 3

1: 4

4: 6 8 1 5

1: 4

Sample Output:

3

4 3 1

题目大意:有n个人,每个人喜欢k个活动,如果两个人有任意一个活动相同,就称为他们处于同一个社交网络。求这n个人一共形成了多少个社交网络。

需要注意的是如果A和B组成了一个集合,B和C组成了一个集合,那么A和B、C应该是在一个集合中的,尽管A和C并没有相同的活动

这道题是一道很经典的并查集问题,每个人喜欢的活动数目都不一样,根据活动来判断两个人是否属于同一个集合,每个人的编号就是集合的元素,编号从1开始到n,如果是同一个集合,则合并,最后遍历father数组的每一个元素,然后查找每一个元素的根节点,根据根节点来记录每一个集合的人数,最后统计这些集合个数即可。

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
vector<int> father, isRoot;
int cmp1(int a, int b) {
return a > b;
}
int findFather(int x) {
int a = x;
while(x != father[x])
x = father[x];
while(a != father[a]) {
int z = a;
a = father[a];
father[z] = x;
}
return x;
}
void Union(int a, int b) {
int faA = findFather(a);
int faB = findFather(b);
if(faA != faB) father[faA] = faB;
}
int main() {
int n, k, t, cnt = 0;
int course[1001] = {0};
scanf("%d", &n);
father.resize(n + 1);
isRoot.resize(n + 1);
for(int i = 1; i <= n; i++)
father[i] = i;
for(int i = 1; i <= n; i++) {
scanf("%d:", &k);
for(int j = 0; j < k; j++) {
scanf("%d", &t);
if(course[t] == 0)
course[t] = i;
Union(i, findFather(course[t]));
}
}
for(int i = 1; i <= n; i++)
isRoot[findFather(i)]++;
for(int i = 1; i <= n; i++) {
if(isRoot[i] != 0) cnt++;
}
printf("%d\n", cnt);
sort(isRoot.begin(), isRoot.end(), cmp1);
for(int i = 0; i < cnt; i++) {
printf("%d", isRoot[i]);
if(i != cnt - 1) printf(" ");
}
return 0;
}

1114 Family Property

This time, you are supposed to help us collect the data for family-owned property. Given each person's family members, and the estate(房产)info under his/her own name, we need to know the size of each family, and the average area and number of sets of their real estate.

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (≤1000). Then N lines follow, each gives the infomation of a person who owns estate in the format:

ID` `Father` `Mother` k Child1⋯Childk Mestate Area

where ID is a unique 4-digit identification number for each person; Father and Mother are the ID's of this person's parents (if a parent has passed away, -1 will be given instead); k (0≤k≤5) is the number of children of this person; Child**i's are the ID's of his/her children; Mestate is the total number of sets of the real estate under his/her name; and Area is the total area of his/her estate.

Output Specification:

For each case, first print in a line the number of families (all the people that are related directly or indirectly are considered in the same family). Then output the family info in the format:

ID M AVGsets AVGarea

where ID is the smallest ID in the family; M is the total number of family members; AVGsets is the average number of sets of their real estate; and AVGarea is the average area. The average numbers must be accurate up to 3 decimal places. The families must be given in descending order of their average areas, and in ascending order of the ID's if there is a tie.

Sample Input:

10
6666 5551 5552 1 7777 1 100
1234 5678 9012 1 0002 2 300
8888 -1 -1 0 1 1000
2468 0001 0004 1 2222 1 500
7777 6666 -1 0 2 300
3721 -1 -1 1 2333 2 150
9012 -1 -1 3 1236 1235 1234 1 100
1235 5678 9012 0 1 50
2222 1236 2468 2 6661 6662 1 300
2333 -1 3721 3 6661 6662 6663 1 100

Sample Output:

3
8888 1 1.000 1000.000
0001 15 0.600 100.000
5551 4 0.750 100.000
#include <cstdio>
#include <algorithm>
using namespace std;
struct DATA {
int id, fid, mid, num, area;
int cid[10];
} data[1005];
struct node {
int id, people;
double num, area;
bool flag = false;
} ans[10000];
int father[10000];
bool visit[10000];
int find(int x) {
while(x != father[x])
x = father[x];
return x;
}
void Union(int a, int b) {
int faA = find(a);
int faB = find(b);
if(faA > faB)
father[faA] = faB;
else if(faA < faB)
father[faB] = faA;
}
int cmp1(node a, node b) {
if(a.area != b.area)
return a.area > b.area;
else
return a.id < b.id;
}
int main() {
int n, k, cnt = 0;
scanf("%d", &n);
for(int i = 0; i < 10000; i++)
father[i] = i;
for(int i = 0; i < n; i++) {
scanf("%d %d %d %d", &data[i].id, &data[i].fid, &data[i].mid, &k);
visit[data[i].id] = true;
if(data[i].fid != -1) {
visit[data[i].fid] = true;
Union(data[i].fid, data[i].id);
}
if(data[i].mid != -1) {
visit[data[i].mid] = true;
Union(data[i].mid, data[i].id);
}
for(int j = 0; j < k; j++) {
scanf("%d", &data[i].cid[j]);
visit[data[i].cid[j]] = true;
Union(data[i].cid[j], data[i].id);
}
scanf("%d %d", &data[i].num, &data[i].area);
}
for(int i = 0; i < n; i++) {
int id = find(data[i].id);
ans[id].id = id;
ans[id].num += data[i].num;
ans[id].area += data[i].area;
ans[id].flag = true;
}
for(int i = 0; i < 10000; i++) {
if(visit[i])
ans[find(i)].people++;
if(ans[i].flag)
cnt++;
}
for(int i = 0; i < 10000; i++) {
if(ans[i].flag) {
ans[i].num = (double)(ans[i].num * 1.0 / ans[i].people);
ans[i].area = (double)(ans[i].area * 1.0 / ans[i].people);
}
}
sort(ans, ans + 10000, cmp1);
printf("%d\n", cnt);
for(int i = 0; i < cnt; i++)
printf("%04d %d %.3f %.3f\n", ans[i].id, ans[i].people, ans[i].num,
ans[i].area);
return 0;
}

1118 Birds in Forest

Some scientists took pictures of thousands of birds in a forest. Assume that all the birds appear in the same picture belong to the same tree. You are supposed to help the scientists to count the maximum number of trees in the forest, and for any pair of birds, tell if they are on the same tree.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive number N (≤10

^4 ) which is the number of pictures. Then N lines follow, each describes a picture in the format:

K B1 B2 ... BK

where K is the number of birds in this picture, and Bi 's are the indices of birds. It is guaranteed that the birds in all the pictures are numbered continuously from 1 to some number that is no more than 10^4

After the pictures there is a positive number Q (≤10^4 ) which is the number of queries. Then Q lines follow, each contains the indices of two birds.

Output Specification:

For each test case, first output in a line the maximum possible number of trees and the number of birds. Then for each query, print in a line Yes if the two birds belong to the same tree, or No if not.

Sample Input:

4

3 10 1 2

2 3 4

4 1 5 7 8

3 9 6 4

2

10 5

3 7

Sample Output:

2 10

Yes

No

#include <iostream>
using namespace std;
int n, m, k;
const int maxn = 10010;
int fa[maxn] = {0}, cnt[maxn] = {0};
int findFather(int x) {
int a = x;
while(x != fa[x])
x = fa[x];
while(a != fa[a]) {
int z = a;
a = fa[a];
fa[z] = x;
}
return x;
}
void Union(int a, int b) {
int faA = findFather(a);
int faB = findFather(b);
if(faA != faB) fa[faA] = faB;
}
bool exist[maxn];
int main() {
scanf("%d", &n);
for(int i = 1; i <= maxn; i++)
fa[i] = i;
int id, temp;
for(int i = 0; i < n; i++) {
scanf("%d%d", &k, &id);
exist[id] = true;
for(int j = 0; j < k-1; j++) {
scanf("%d", &temp);
Union(id, temp);
exist[temp] = true;
}
}
for(int i = 1; i <= maxn; i++) {
if(exist[i] == true) {
int root = findFather(i);
cnt[root]++;
}
}
int numTrees = 0, numBirds = 0;
for(int i = 1; i <= maxn; i++) {
if(exist[i] == true && cnt[i] != 0) {
numTrees++;
numBirds += cnt[i];
}
}
printf("%d %d\n", numTrees, numBirds);
scanf("%d", &m);
int ida, idb;
for(int i = 0; i < m; i++) {
scanf("%d%d", &ida, &idb);
printf("%s\n", (findFather(ida) == findFather(idb)) ? "Yes" : "No");
}
return 0;
}

【algo&ds】【pat】5.并查集及其应用的更多相关文章

  1. PAT甲级 并查集 相关题_C++题解

    并查集 PAT (Advanced Level) Practice 并查集 相关题 <算法笔记> 重点摘要 1034 Head of a Gang (30) 1107 Social Clu ...

  2. PAT A1107——并查集

     Social Clusters When register on a social network, you are always asked to specify your hobbies in ...

  3. PAT A 1118. Birds in Forest (25)【并查集】

    并查集合并 #include<iostream> using namespace std; const int MAX = 10010; int father[MAX],root[MAX] ...

  4. PAT A1107 Social Clusters (30 分)——并查集

    When register on a social network, you are always asked to specify your hobbies in order to find som ...

  5. PAT A1118 Birds in Forest (25 分)——并查集

    Some scientists took pictures of thousands of birds in a forest. Assume that all the birds appear in ...

  6. PAT L2-013 红色警报(并查集求连通子图)

    战争中保持各个城市间的连通性非常重要.本题要求你编写一个报警程序,当失去一个城市导致国家被分裂为多个无法连通的区域时,就发出红色警报.注意:若该国本来就不完全连通,是分裂的k个区域,而失去一个城市并不 ...

  7. PAT甲题题解-1021. Deepest Root (25)-dfs+并查集

    dfs求最大层数并查集求连通个数 #include <iostream> #include <cstdio> #include <algorithm> #inclu ...

  8. PAT甲题题解-1034. Head of a Gang (30)-并查集

    给出n和k接下来n行,每行给出a,b,c,表示a和b之间的关系度,表明他们属于同一个帮派一个帮派由>2个人组成,且总关系度必须大于k.帮派的头目为帮派里关系度最高的人.(注意,这里关系度是看帮派 ...

  9. PAT甲题题解-1107. Social Clusters (30)-PAT甲级真题(并查集)

    题意:有n个人,每个人有k个爱好,如果两个人有某个爱好相同,他们就处于同一个集合.问总共有多少个集合,以及每个集合有多少人,并按从大到小输出. 很明显,采用并查集.vis[k]标记爱好k第一次出现的人 ...

随机推荐

  1. Spring Boot (二) 整合 Redis

    前言 本文将会基于 springboot 2.1.8.RELEASE 简单整合 Redis ,适合新手小白入门 Spring Boot 整合 Redis 入门 1.pom.xml 中引入 redis ...

  2. 支持100+业务线、累计发布17万次|宜信容器云的A点与B点(分享实录)

    宜信公司从2018年初开始建设容器云,至今,容器云的常用基本功能已经趋于完善,主要包括服务管理.应用商店.Nginx配置.存储管理.CI/CD.权限管理等,支持100+业务线.3500+的容器运行.伴 ...

  3. 重新精读《Java 编程思想》系列之向上转型与向下转型

    前言 今天重读了一下向上转型与向下转型,有些新的体会,了解了向上转型的好处,及如何向下转型.在此分享给大家. 向上转型 向上转型是用来表现新类和基类之间的关系.在传统中,由导出类转型成基类,在继承图中 ...

  4. 酷狗音乐API接口大全(40+个)

    歌单分类部分 获取精选专区所有分类 http://mobilecdnbj.kugou.com/api/v3/tag/list?pid=0&apiver=2&plat=0 获取热门推荐分 ...

  5. GHOST CMS -上下文概述 Context Overview

    Context Overview上下文概述 Each page in a Ghost theme belongs to a context, which determines which templa ...

  6. 小公举-linux的计算器

    1.一个方便的linux计算器,精巧而强大bc 2..进行简单的四则运算 3.连续的四则运算 4.大数运算 5.求次幂和余数 6.如果要执行小数计算呢,需要设置scale=number ,number ...

  7. 数据库学习笔记day03

    创建两个表,一个名为emp,一个名为dept,并且插入数据 create table emp(empno number(4,0),ename varchar2(10),job varchar2(9), ...

  8. Android 音视频技术之录音获取实时音量

    一.实时音量相关基础知识 说到获取音量,大家首先想到的应该就是分贝(dB),分贝是一个相对单位(是一个比值,是一个数值,是一个纯计数方法). 在音频领域dB度量的是声音的强度,其计算的公式如下: 在上 ...

  9. Android 开发凉了吗!

    昨天我拿了本<安卓开发大全>的书,把它放进了冰箱,你猜怎么样? 它凉了. 记得2013年的时候,安卓崛起,一夜之间遍地谈论安卓这个奇怪的机器人. 安卓受宠的原因,主要围绕着: 1 应用商城 ...

  10. ReactNative: 使用对话框组件AlertIOS组件

    一.简介 在使用一款App的时候,经常会用到对话框进行信息的友好提示,一般简单要求性不高的时候我们可以使用web提供的alert实现即可.但是,对于需要交互性和美观性的对话框,alert就明显无法满足 ...