「数据结构」并查集详解和案例

最新推荐文章于 2023-08-21 01:23:11 发布

暗夜无风

最新推荐文章于 2023-08-21 01:23:11 发布

阅读量374

点赞数 4

分类专栏：数据结构文章标签：数据结构算法并查集

本文链接：https://blog.csdn.net/aruewds/article/details/118661758

版权

数据结构专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、并查集的定义

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

Find：确定元素属于哪一个子集。它可以被用来确定两个元素是否属于同一子集。
Union：将两个子集合并成同一个集合。

并查集在算法题中，用于解决不相交集合的合并问题，比如在一个家庭中，有自己、父亲、母亲、孩子，而母亲又有其母亲、父亲等，它们之间的关系是很交错复杂的，普通的数据结构如链表、哈希表无法表达它们之间的关系，这时候就需要一种特殊的数据结构来表示，它就是并查集。

二、并查集的故事

并查集有一个经典的故事，可以很好地理解并查集的概念。因为来源甚多，不知其第一作者，顾引用这篇博客的内容。

故事如下：

话说江湖上散落着各式各样的大侠，有上千个之多。他们没有什么正当职业，整天背着剑在外面走来走去，碰到和自己不是一路人的，就免不了要打一架。但大侠们有一个优点就是讲义气，绝对不打自己的朋友。而且他们信奉“朋友的朋友就是我的朋友”，只要是能通过朋友关系串联起来的，不管拐了多少个弯，都认为是自己人。这样一来，江湖上就形成了一个一个的群落，通过两两之间的朋友关系串联起来。而不在同一个群落的人，无论如何都无法通过朋友关系连起来，于是就可以放心往死了打。但是两个原本互不相识的人，如何判断是否属于一个朋友圈呢？
我们可以在每个朋友圈内推举出一个比较有名望的人，作为该圈子的代表人物，这样，每个圈子就可以这样命名“齐达内朋友之队”“罗纳尔多朋友之队”……两人只要互相对一下自己的队长是不是同一个人，就可以确定敌友关系了。
但是还有问题啊，大侠们只知道自己直接的朋友是谁，很多人压根就不认识队长，要判断自己的队长是谁，只能漫无目的的通过朋友的朋友关系问下去：“你是不是队长？你是不是队长？”这样一来，队长面子上挂不住了，而且效率太低，还有可能陷入无限循环中。于是队长下令，重新组队。队内所有人实行分等级制度，形成树状结构，我队长就是根节点，下面分别是二级队员、三级队员。每个人只要记住自己的上级是谁就行了。遇到判断敌友的时候，只要一层层向上问，直到最高层，就可以在短时间内确定队长是谁了。由于我们关心的只是两个人之间是否连通，至于他们是如何连通的，以及每个圈子内部的结构是怎样的，甚至队长是谁，并不重要。所以我们可以放任队长随意重新组队，只要不搞错敌友关系就好了。于是，门派产生了。
在这里插入图片描述
假设现在武林中的形势如图所示。虚竹小和尚与周芷若MM是我非常喜欢的两个人物，他们的终极boss分别是玄慈方丈和灭绝师太，那明显就是两个阵营了。我不希望他们互相打架，就对他俩说：“你们两位拉拉勾，做好朋友吧。”他们看在我的面子上，同意了。这一同意可非同小可，整个少林和峨眉派的人就不能打架了。这么重大的变化，可如何实现呀，要改动多少地方？其实非常简单，我对玄慈方丈说：“大师，麻烦你把你的上级改为灭绝师太吧。这样一来，两派原先的所有人员的终极boss都是师太，那还打个球啊！反正我们关心的只是连通性，门派内部的结构不要紧的。”玄慈一听肯定火大了：“我靠，凭什么是我变成她手下呀，怎么不反过来？我抗议！”抗议无效，上天安排的，最大。反正谁加入谁效果是一样的，我就随手指定了一个。

对于并查集还有两种优化：路径压缩和按秩合并
路径压缩大致就是如下：

建立门派的过程是两个人两个人地连接起来的，谁当谁的手下完全随机。最后的树状结构会变成什么胎唇样，我也完全无法预计，一字长蛇阵也有可能。这样查找的效率就会比较低下。最理想的情况就是所有人的直接上级都是掌门，一共就两级结构，只要找一次就找到掌门了。哪怕不能完全做到，也最好尽量接近。这样就产生了路径压缩算法。设想这样一个场景：两个互不相识的大侠碰面了，想知道能不能揍。于是赶紧打电话问自己的上级：“你是不是掌门？” 上级说：“我不是呀，我的上级是谁谁谁，你问问他看看。” 一路问下去，原来两人的最终boss都是东厂曹公公。 “哎呀呀，原来是记己人，西礼西礼，在下三营六组白面葫芦娃!” “幸会幸会，在下九营十八组仙子狗尾巴花！” 两人高高兴兴地手拉手喝酒去了。 “等等等等，两位同学请留步，还有事情没完成呢！”我叫住他俩。 “哦，对了，还要做路径压缩。”两人醒悟。白面葫芦娃打电话给他的上级六组长：“组长啊，我查过了，其习偶们的掌门是曹公公。不如偶们一起及接拜在曹公公手下吧，省得级别太低，以后查找掌门麻环。” “唔，有道理。” 白面葫芦娃接着打电话给刚才拜访过的三营长……仙子狗尾巴花也做了同样的事情。这样，查询中所有涉及到的人物都聚集在曹公公的直接领导下。每次查询都做了优化处理，所以整个门派树的层数都会维持在比较低的水平上。

按秩合并如下：

玄慈一听肯定火大了：“我靠，凭什么是我变成她手下呀，怎么不反过来？我抗议！”我一听这不行啊，万一他要一发火把我顺便削了可不好完，于是我就想了个比较公平的合并方法。和他说：“要不这样吧，你们俩比一比谁手下的人层数少，层数少的那个就变成层数多的那个的下级，你看怎样呀？”玄慈听了觉着还行，就按照我说的做了。

三、并查集代码模板

并查集主要是通过一个数组set[]来实现查找和合并操作，可以说是十分简单又非常巧妙。

初始化

初始化set数组，每个元素所属集合定义为自身，用复数 -1表示，同时表示这个集合个数为abs(set[x])也就是1。

//初始化set数组，每个元素所属的集合为自身，用-1表示
void set_init(int* set, int n)
{
	for (int i = 0; i < n; i++)
    {
        set[i] = -1;
    }
}

查找

并查集查找元素，不断往上级查找，直到最上一级，也就是值为负数那级，就是最大BOSS。

//查找
int set_find(int* set, int x)
{
    while (set[x] > 0)//说明还不是所属集合的BOSS
    {
        x = set[x];
    }
    return x;
}

路径压缩优化查找

按照之前的查找方式，可能导致一系列元素互相所指，形成一条很长的链，这样查找的效率就降低了。

而路径压缩算法，则只需要在查询的过程中，把沿途的每个元素都指向代表元素就可以了，所以经过路径压缩后，每次查找时都将集合内元素指向BOSS，以后查找就方便了。

int set_find(int* set, int x)
{
    if (set[x] < 0)//小于0即为-1，说明是所属集合的boss
    {
        return x;
    }
    else
    {
        return set[x] = set_find(set, set[x]);//修改沿途元素
    }
}
/*
//精简版路径压缩
int Set_Find(int* set, int x)
{
    return set[x] < 0 ? x : set[x] = set_find(set, set[x]);
}
*/

合并

并查集的合并操作，就是将两个不同集合的连接成一个元素，那么需要我们将某个集合的BOSS连到另一个集合就可以了。

//合并
void set_union(int* set, int x, int y)
{
    x = set_find(set, x);
    y = set_find(set, y);
    set[y] = x;//y的上司改为x，从而x和y联合在一起
}

按秩合并

在上面的合并函数代码中，我们总是把后一个集合合并到前一个集合，也正是这种方法使得之前我们合并出一条很长的链。

所以采用按秩合并的方式，将规模小的集合合并到规模大的集合。而集合的规模，则可通过set数组中存放的值的绝对值知道。

//按秩合并
void Set_Union(int* set, int x, int y)
{
    x = set_find(set, x);
    y = set_find(set, y);
    if (x == y) return;     //两个元素已经在一个集合了，无需合并了

    if (set[x] > set[y])    //注意，这里比较的是负数
    {
        set[y] += set[x];   //改变y的规模
        set[x] = y;         //x合并到y
    }
    else
    {
        set[x] += y;
        set[y] = x;
    }
}

完整代码

//初始化set数组，每个元素所属的集合为自身，用-1表示
void set_init(int* set, int n)
{
	for (int i = 0; i < n; i++)
    {
        set[i] = -1;
    }
}

//精简版路径压缩
int set_find(int* set, int x)
{
    return set[x] < 0 ? x : set[x] = set_find(set, set[x]);
}

//按秩合并
void set_union(int* set, int x, int y)
{
    x = set_find(set, x);
    y = set_find(set, y);
    if (x == y) return;     //两个元素已经在一个集合了，无需合并了

    if (set[x] > set[y])    //注意，这里比较的是负数
    {
        set[y] += set[x];   //改变y的规模
        set[x] = y;         //x合并到y
    }
    else
    {
        set[x] += y;
        set[y] = x;
    }
}

另一个种并查集算法

另一种算法，加入rank[]数组用于记录树的深度，树的秩，根据秩的大小决定按秩合并。

void set_init(int *set, int *rank, int n) 
{
    for (int i = 0; i < n; i++) 
    {
        set[i] = i;//自身
        rank[i] = 1;//深度为1
    }
}

int set_find(int *set, int x) 
{
    return x == set[x] ? x : set_find(set, set[x]);
}

void set_union(int *set, int *rank, int x, int y) 
{
    x = set_find(set, x);
    y = set_find(set, y);

    if (rank[x] <= rank[y])//秩小合并到秩大 
    {
        set[x] = y;
        if (rank[x] == rank[y] && x != y) rank[y]++;//相等情况
    }
    else 
    {
        set[y] = x;
    }
}

四、一道例题

题目来源：pat 1114 Family Property (25 分)

题目：

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; Childi’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:

or 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 <iostream>
using namespace std;
#include <string>
#include <vector>
#include <algorithm>

#define N 10000
int set[N];
float houseNum[N];
float houseSum[N];

void set_init()
{
    for (int i = 0; i < N; i++)
    {
        set[i] = 10000;
        houseNum[i] = 0;
        houseSum[i] = 0;
    }
}

int set_find(int x)
{
    return set[x] < 0 ? x : set[x] = set_find(set[x]);
}

void set_union(int x, int y)
{
    x = set_find(x);
    y = set_find(y);
    if (x == y) return;


    if (x < y)
    {
        set[x] += set[y];
        set[y] = x; 
        houseNum[x] += houseNum[y];
        houseSum[x] += houseSum[y];
    }
    else
    {
        set[y] += set[x];
        set[x] = y;
        houseNum[y] += houseNum[x];
        houseSum[y] += houseSum[x];
    }
    

}


int main()
{
    //freopen("input.txt","r",stdin); //提交时把这行注释掉就行
    set_init();
    int n;
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        int ps, fl, ml;
        cin >> ps >> fl >> ml;
        if (set[ps] == 10000)//说明是空集合
        {
            set[ps] = -1;
        }
        
        if (fl != -1)
        {
            if (set[fl] == 10000)//说明是空集合
            {
                set[fl] = -1;
            }
            set_union(ps, fl);
        }
        if (ml != -1)
        {
            if (set[ml] == 10000)//说明是空集合
            {
                set[ml] = -1;
            }
            set_union(ps, ml);
        }

        int m;
        cin >> m;
        for (int j = 0; j < m; j++)
        {
            int num;
            cin >> num;
            if (set[num] == 10000)
            {
                set[num] = -1;
            }
            set_union(ps, num);
        }
        int k;
        cin >> k;
        houseNum[set_find(ps)] += k;
        int num;
        cin >> num;
        houseSum[set_find(ps)] += num;
        
    }

    vector<int> ans;
    for (int i = N - 1; i >= 0; i--)
    {
        if (set[i] != 10000)
        {
            if (find(ans.begin(), ans.end(), set_find(i)) == ans.end())
                ans.push_back(set_find(i));
        }
    }
    
    sort(ans.begin(), ans.end(), [&](int op1, int op2){
        if (houseSum[op1] / (-set[op1]) < houseSum[op2] / (-set[op2]))
        {
            return false;
        }
        else if (houseSum[op1] / (-set[op1]) == houseSum[op2] / (-set[op2]))
        {
            return op1 < op2;
        }
        else
        {
            return true;
        }
    });
    
    cout << ans.size() << endl;
    for (int i = 0; i < ans.size(); i++)
    {
        printf("%04d %d %.3f %.3f\n",ans[i], -set[ans[i]], houseNum[ans[i]] / (-set[ans[i]]), houseSum[ans[i]] / (-set[ans[i]]));
    }
    return 0;
}