DS进阶：并查集

一、并查集的原理

在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-find
set)。

这样讲可能有点抽象，下面我通过一个故事来帮助大家理解这个并查集的现实意义。

这是一个充满打打杀杀的江湖，每个人都混迹在江湖之中，去追寻自己的理想和抱负，时常会因为信仰不同而聚众斗殴，江湖上常常乱作一团，但是也有时也会因为信仰相同，结成好朋友，共同对抗别人，随着时间的增长，不同的团体规模也在不断扩大，大家也在尝试去依附团体生存。于是就形成了不同的帮派。

帮派的形成本身就是为了能够有自己的盟友去帮助合力对抗外人，这个时候就出现了一个问题，我们如何去分辨自己的盟友呢？？避免打错人呢？？所以为了解决这个问题，每个帮派都需要有一个掌门人，这样在决斗的时候，双方通过自报家门，就能知道是自己人还是敌人了。

接下来我们来通过并查集模拟形成帮派的过程

从上图可以看出，并查集其实是一种树形结构，只不过用的是双亲表示法。

通过以上例子可知，并查集一般可以解决一下问题：
1. 查找元素属于哪个集合
沿着数组表示树形关系以上一直找到根(即：树中中元素为负数的位置)
2. 查看两个元素是否属于同一个集合
沿着数组表示的树形关系往上一直找到树的根，如果根相同表明在同一个集合，否则不在
3. 将两个集合归并成一个集合
将两个集合中的元素合并
将一个集合名称改成另一个集合的名称
4. 集合的个数
遍历数组，数组中元素为负数的个数即为集合的个数。

二、并查集的模拟实现

我们封装并查集，需要有一个vector<int>类型的成员函数。

2.1 并查集的初始化

UnionFindSet(size_t n):_set(n, -1) //初始化成-1  并查集的初始状态
{}

直接调用vector的构造函数。初始化成-1

2.2 寻找某节点的根Findroot

两个高手刚见面，首先就得自报家门，看看自己的老大是不是同一个，这样才能决定是打一架还是吃个饭。因此我们要实现一个Findroot 。

size_t Findroot(size_t x)
{while (_set[x] >= 0)  x = _set[x]; //去找根节点 return x;
}

但是这样真的好吗？？？

我们用递归的方式去修改，不断去修改我们要查找节点的前驱节点，这样在下一次找这个数的时候，必然只需要O（1）的时间复杂度就可以完成了！

int Findroot(int x)     				//查找结点 x的根结点 
{if (_set[x]< 0)  return x;		//递归出口：x的上级为 x本身，即 x为根结点        return _set[x] = Findroot(_set[x]);	//此代码相当于先找到根结点 rootx，然后_set[x]=rootx 
}

2.3 合并两个集合union

我们俩要结盟，在结盟之前，我们要先判断我们俩是不是自己人，所以要先找到我们的老大。如果我们的老大是同一个，那么就没有必要再结盟，但是如果我们俩不是同一个老大，这个时候结盟前就需要有一个老大去当另一个老大的小弟。两个谁也不服谁，所以只能比一下谁人多，最后人少听人多的。

所以我们找到老大后，还需要判断老大手下有多少人，谁人少，就将所有人划分到人多的那一边去。

	bool Union(int x, int y)  //优化思路  大树管小树{int root1 = Findroot(x);int root2 = Findroot(y);if (root1 == root2) return false;//说明两个在一个集合，所以没有必要去合并//此时说明可以合并了if (_set[root1] > _set[root2]) swap(root1, root2);  //_set[root1] 表示root1手下有多少人 手下人少投靠手下人多的_set[root1] += _set[root2];//我把我手下的人包括我自己归属于你_set[root2] = root1;//你成为我的上级。return true;}

其实该方式本质上也是为了尽可能地降低整体节点的深度，方便查找可以更快。

2.4 统计并查集中一共有多少个集合

遍历一遍并查集，数一下有多少个掌门人即可

size_t SetCount()//查找一共有几个集合
{size_t count = 0;for (auto& e : _set)if (e < 0)  ++count;return count;
}

2.5 并查集的整体代码实现

#include<vector>
#include<iostream>
using namespace std;class UnionFindSet //利用的是双亲表示法
{ 
public:UnionFindSet(size_t n):_set(n, -1) //初始化成-1  并查集的初始状态{}size_t Findroot(size_t x) //非压缩版本
{while (_set[x] >= 0)  x = _set[x]; //去找根节点 return x;
}int Findroot(int x)     				//查找结点 x的根结点   压缩版本{if (_set[x]< 0)  return x;		//递归出口：x的上级为 x本身，即 x为根结点        return _set[x] = Findroot(_set[x]);	//此代码相当于先找到根结点 rootx，然后_set[x]=rootx }bool Union(int x, int y)  //优化思路  大树管小树{int root1 = Findroot(x);int root2 = Findroot(y);if (root1 == root2) return false;//说明两个在一个集合，所以没有必要去合并//此时说明可以合并了if (_set[root1] > _set[root2]) swap(root1, root2);  //_set[root1] 表示root1手下有多少人 手下人少投靠手下人多的_set[root1] += _set[root2];//我把我手下的人包括我自己归属于你_set[root2] = root1;//你成为我的上级。return true;}size_t SetCount()//查找一共有几个集合{size_t count = 0;for (auto& e : _set)if (e < 0)  ++count;return count;}private:vector<int> _set;// 并查集
};

三、并查集的相关OJ题

并查集的主要作用是求连通分支数（如果一个图中所有点都存在可达关系（直接或间接相连），则此图的连通分支数为1；如果此图有两大子图各自全部可达，则此图的连通分支数为2……）

3.1 省份数量

. - 力扣（LeetCode）

这边重点使用并查集的思想解决问题

我们会发现这道题的本质其实是，如果两个城市相连就要将他丢进集合里，最后看看并查集里面有几个集合就代表有几个省份。

我们直接用我们之前实现过的并查集来解决问题！！

解法1：手撕并查集

class UnionFindSet //利用的是双亲表示法
{ 
public:UnionFindSet(size_t n):_set(n, -1) //初始化成-1  并查集的初始状态{}int Findroot(int x)     				//查找结点 x的根结点   优化
{if (_set[x]< 0)  return x;		//递归出口：x的上级为 x本身，即 x为根结点        return _set[x] = Findroot(_set[x]);	//此代码相当于先找到根结点 rootx，然后_set[x]=rootx 
}bool Union(int x, int y){int root1 = Findroot(x);int root2 = Findroot(y);if (root1 == root2) return false;//说明两个在一个集合，所以没有必要去合并//此时说明可以合并了if (_set[root1] > _set[root2]) swap(root1, root2);  //_set[root1] 表示root1手下有多少人 手下人少投靠手下人多的_set[root1] += _set[root2];//我把我手下的人包括我自己归属于你_set[root2] = root1;//你成为我的上级。return true;}size_t SetCount()//查找一共有几个集合{size_t count = 0;for (auto& e : _set)if (e < 0)  ++count;return count;}private:vector<int> _set;// 并查集
};class Solution {
public:int findCircleNum(vector<vector<int>>& isConnected) {UnionFindSet set(isConnected.size());//创建一个并查集for(int i=0;i<isConnected.size();++i)for(int j=0;j<isConnected[0].size();++j)if(isConnected[i][j] == 1) //丢到集合里set.Union(i,j);return set.SetCount();//返回集合的个数} 
};

如果并查集是库里面的，这样做真的很方便，但是实际上我们要使用的话都得自己封装，如果这仅仅是一道OJ题，显然是没有必要的，因为复用性并不高。所以我们按照并查集的逻辑去解题，但是不要真的去实现

解法2：不手撕并查集，但是按照并查集的逻辑去解决问题。

这边针对这一道题，我们可以直接使用lambda表达式去简化我们的代码

class Solution {
public:int findCircleNum(vector<vector<int>>& isConnected) {vector<int> ufs(isConnected.size(),-1);auto Findroot=[&ufs](int x){while(ufs[x]>=0) x=ufs[x];return x;            };for(int i=0;i<isConnected.size();++i)for(int j=0;j<isConnected[0].size();++j)if(isConnected[i][j] == 1) //丢到集合里{int root1 = Findroot(i);int root2 = Findroot(j);if(root1 != root2){if (ufs[root1] > ufs[root2]) swap(root1, root2); ufs[root1] += ufs[root2];ufs[root2] = root1;}}size_t count = 0;for (auto& e :ufs)if (e < 0)  ++count;return count;} 
};

3.2 等式方程的可满足性

. - 力扣（LeetCode）

解决思路就是第一遍我们先将所有相等的值加到一个集合里，然后第二遍去判断不相等的值是否在一个集合里，如果是的话就是错误的。

class Solution {
public:bool equationsPossible(vector<string>& equations) {vector<int> ufs(26,-1); auto Findroot=[&ufs](int x){while(ufs[x]>=0) x=ufs[x];return x;            };for(auto&s:equations){if(s[1]=='=')//必然是相等的{int root1=Findroot(s[0]-'a');int root2=Findroot(s[3]-'a');if(root1!=root2){if(ufs[root1]>ufs[root2]) swap(root1,root2);//进行合并ufs[root1]+=ufs[root2];//吞并另一个老大的人ufs[root2]=root1;//服从指挥}}}//第二遍 看看是否不是一个集合的for(auto&s:equations){if(s[1]=='!')//必然是相等的{int root1=Findroot(s[0]-'a');int root2=Findroot(s[3]-'a');if(root1==root2)  return false;}}return true;}
};