并查集基础:
并查集被很多OIer认为是最简洁而优雅的数据结构之一,主要用于解决一些元素分组的问题。它管理一系列不相交的集合,并支持两种操作:
- 合并(Union):把两个不相交的集合合并为一个集合。
- 查询(Find):查询两个元素是否在同一个集合中。
并查集的引入
并查集的重要思想在于,用集合中的一个元素代表集合。我曾看过一个有趣的比喻,把集合比喻成帮派,而代表元素则是帮主。接下来我们利用这个比喻,看看并查集是如何运作的。
最开始,所有大侠各自为战。他们各自的帮主自然就是自己。(对于只有一个元素的集合,代表元素自然是唯一的那个元素)
现在1号和3号比武,假设1号赢了(这里具体谁赢暂时不重要),那么3号就认1号作帮主(合并1号和3号所在的集合,1号为代表元素)。
现在2号想和3号比武(合并3号和2号所在的集合),但3号表示,别跟我打,让我帮主来收拾你(合并代表元素)。不妨设这次又是1号赢了,那么2号也认1号做帮主。
现在我们假设4、5、6号也进行了一番帮派合并,江湖局势变成下面这样:
现在假设2号想与6号比,跟刚刚说的一样,喊帮主1号和4号出来打一架(帮主真辛苦啊)。1号胜利后,4号认1号为帮主,当然他的手下也都是跟着投降了。
好了,比喻结束了。如果你有一点图论基础,相信你已经觉察到,这是一个树状的结构,要寻找集合的代表元素,只需要一层一层往上访问父节点(图中箭头所指的圆),直达树的根节点(图中橙色的圆)即可。根节点的父节点是它自己。我们可以直接把它画成一棵树:
(好像有点像个火柴人?)
用这种方法,我们可以写出最简单版本的并查集代码。
初始化
int fa[MAXN];
inline void init(int n)
{
for (int i = 1; i <= n; ++i)
fa[i] = i;
}
假如有编号为1, 2, 3, ..., n的n个元素,我们用一个数组fa[]来存储每个元素的父节点(因为每个元素有且只有一个父节点,所以这是可行的)。一开始,我们先将它们的父节点设为自己。
查询
int find(int x)
{
if(fa[x] == x)
return x;
else
return find(fa[x]);
}
我们用递归的写法实现对代表元素的查询:一层一层访问父节点,直至根节点(根节点的标志就是父节点是本身)。要判断两个元素是否属于同一个集合,只需要看它们的根节点是否相同即可。
合并
inline void merge(int i, int j)
{
fa[find(i)] = find(j);
}
合并操作也是很简单的,先找到两个集合的代表元素,然后将前者的父节点设为后者即可。当然也可以将后者的父节点设为前者,这里暂时不重要。本文末尾会给出一个更合理的比较方法。
路径压缩
最简单的并查集效率是比较低的。例如,来看下面这个场景:
现在我们要merge(2,3),于是从2找到1,fa[1]=3,于是变成了这样:
然后我们又找来一个元素4,并需要执行merge(2,4):
从2找到1,再找到3,然后fa[3]=4,于是变成了这样:
大家应该有感觉了,这样可能会形成一条长长的链,随着链越来越长,我们想要从底部找到根节点会变得越来越难。
怎么解决呢?我们可以使用路径压缩的方法。既然我们只关心一个元素对应的根节点,那我们希望每个元素到根节点的路径尽可能短,最好只需要一步,像这样:
其实这说来也很好实现。只要我们在查询的过程中,把沿途的每个节点的父节点都设为根节点即可。下一次再查询时,我们就可以省很多事。这用递归的写法很容易实现:
合并(路径压缩)
int find(int x)
{
if(x == fa[x])
return x;
else{
fa[x] = find(fa[x]); //父节点设为根节点
return fa[x]; //返回父节点
}
}
以上代码常常简写为一行:
int find(int x)
{
return x == fa[x] ? x : (fa[x] = find(fa[x]));
}
注意赋值运算符=的优先级没有三元运算符?:高,这里要加括号。
路径压缩优化后,并查集的时间复杂度已经比较低了,绝大多数不相交集合的合并查询问题都能够解决。然而,对于某些时间卡得很紧的题目,我们还可以进一步优化。
547.岛屿数量
class UnionSet{
public:
vector<int> parent;
int count;
UnionSet(int size){
parent.resize(size);
for(int i=0;i<size;i++){
parent[i]=i;
}
count=size;
}
int find(int index){
if(index==parent[index]){
return index;
}
else{
int res=find(parent[index]);
parent[index]=res;
return res;
}
}
void Union(int index1,int index2){
int parent1=find(index1);
cout<<parent1<<" "<<endl;
int parent2=find(index2);
cout<<parent2<<" "<<endl;
if(parent1==parent2)return;
else{
parent[parent2]=parent1;
count--;
}
return ;
}
};
class Solution {
public:
int findCircleNum(vector<vector<int>>& isConnected) {
int size=isConnected.size();
UnionSet unionSet(size);
for(int i=0;i<isConnected.size()-1;i++){
for(int j=i+1;j<isConnected[0].size();j++){
cout<<i<<" "<<j<<endl;
if(isConnected[i][j]==1){
unionSet.Union(i,j);
}
}
}
return unionSet.count;
}
};
347.岛屿数量
class UnionSet{
public:
vector<int> parent;
int count=0;//并查集中有多少个连通子图
UnionSet(int size){
parent.resize(size);
for(int i=0;i<size;i++){
parent[i]=i;
}
}
int find(int index){
if(index==parent[index]){
return index;
}
else{
int res=find(parent[index]);
parent[index]=res;
return res;
}
}
void Union(int index1,int index2){
int parent1=find(index1);
int parent2=find(index2);
if(parent1==parent2)return;
else{
parent[parent2]=parent1;
cout<<index1<<" "<<index2<<endl;
count--;
}
return ;
}
};
class Solution {
public:
int numIslands(vector<vector<char>>& grid) {
int size=grid.size()*grid[0].size();
UnionSet unionSet(size);
cout<<grid.size()<<endl;
cout<<grid[0].size()<<endl;
for(int i=0;i<grid.size();i++){
for(int j=0;j<grid[0].size();j++){
if(grid[i][j]=='1'){
unionSet.count++;
if(i+1<grid.size()&&grid[i+1][j]=='1'){
unionSet.Union(i*grid[0].size()+j,(i+1)*grid[0].size()+j);
}
if(j+1<grid[0].size()&&grid[i][j+1]=='1'){
unionSet.Union(i*grid[0].size()+j,i*grid[0].size()+j+1);
}
}
}
}
return unionSet.count;
}
};
684.冗余连接
多了一个函数判断是否处于同一个并查集,就是用isConnected的函数
class UnionSet{
public:
vector<int> parent;
int count=0;//并查集中有多少个连通子图
UnionSet(int size){
parent.resize(size);
for(int i=0;i<size;i++){
parent[i]=i;
}
}
int find(int index){
if(index==parent[index]){
return index;
}
else{
int res=find(parent[index]);
parent[index]=res;
return res;
}
}
void Union(int index1,int index2){
int parent1=find(index1);
int parent2=find(index2);
if(parent1==parent2)return;
else{
parent[parent2]=parent1;
cout<<index1<<" "<<index2<<endl;
count--;
}
return ;
}
bool isConnected(int index1,int index2){
int parent1=find(index1);
int parent2=find(index2);
if(parent1==parent2)return true;
else return false;
}
};
class Solution {
public:
vector<int> findRedundantConnection(vector<vector<int>>& edges) {
int size=edges.size();
UnionSet unionSet(size);
vector<int> res;
for(int i=0;i<size;i++){
int index1=edges[i][0]-1;//由于这里下标从1开始,所以需要-1
int index2=edges[i][1]-1;
if(unionSet.isConnected(index1,index2)){
res.clear();
res.push_back(index1+1);
res.push_back(index2+1);
}
else{
unionSet.Union(index1,index2);
}
}
return res;
}
};
1319.联通网络的操作次数
计算有多少个实际有用的线条即可
class UnionSet{
public:
vector<int> parent;
int count=0;//并查集中有多少个连通子图
UnionSet(int size){
parent.resize(size);
for(int i=0;i<size;i++){
parent[i]=i;
}
}
int find(int index){
if(index==parent[index]){
return index;
}
else{
int res=find(parent[index]);
parent[index]=res;
return res;
}
}
void Union(int index1,int index2){
int parent1=find(index1);
int parent2=find(index2);
if(parent1==parent2)return;
else{
parent[parent2]=parent1;
cout<<index1<<" "<<index2<<endl;
count--;
}
return ;
}
bool isConnected(int index1,int index2){
int parent1=find(index1);
int parent2=find(index2);
if(parent1==parent2)return true;
else return false;
}
};
class Solution {
public:
int makeConnected(int n, vector<vector<int>>& connections) {
UnionSet unionSet(n);
if(connections.size()<n-1)return -1;
int usefulCount=0;
for(int i=0;i<connections.size();i++){
int index1=connections[i][0];
int index2=connections[i][1];
if(unionSet.isConnected(index1,index2)){
}
else{
unionSet.Union(index1,index2);
usefulCount++;
}
}
return n-1-usefulCount;
}
};
990.等式方程的可满足性
990. 等式方程的可满足性https://leetcode.cn/problems/satisfiability-of-equality-equations/
方法一:并查集
我们可以将每一个变量看作图中的一个节点,把相等的关系 == 看作是连接两个节点的边,那么由于表示相等关系的等式方程具有传递性,即如果 a==b 和 b==c 成立,则 a==c 也成立。也就是说,所有相等的变量属于同一个连通分量。因此,我们可以使用并查集来维护这种连通分量的关系。
首先遍历所有的等式,构造并查集。同一个等式中的两个变量属于同一个连通分量,因此将两个变量进行合并。
合并的时候使用递归的方式去查询,找到我这个并查集的代表人物。另外加一行代码可以实现路径压缩。
然后遍历所有的不等式。同一个不等式中的两个变量不能属于同一个连通分量,因此对两个变量分别查找其所在的连通分量,如果两个变量在同一个连通分量中,则产生矛盾,返回 false。
如果遍历完所有的不等式没有发现矛盾,则返回 true。
具体实现方面,使用一个数组 parent 存储每个变量的连通分量信息,其中的每个元素表示当前变量所在的连通分量的父节点信息,如果父节点是自身,说明该变量为所在的连通分量的根节点。一开始所有变量的父节点都是它们自身。对于合并操作,我们将第一个变量的根节点的父节点指向第二个变量的根节点;对于查找操作,我们沿着当前变量的父节点一路向上查找,直到找到根节点。
我们不能在一次循环中同时遍历完等式和不等式
应该先遍历等式,然后得到所有相等关系,再来从头遍历不等式,判断是否不等。
class UnionSet{
public:
vector<int> parent;
int count=0;//并查集中有多少个连通子图
UnionSet(int size){
parent.resize(size);
for(int i=0;i<size;i++){
parent[i]=i;
}
}
int find(int index){
if(index==parent[index]){
return index;
}
else{
int res=find(parent[index]);
parent[index]=res;
return res;
}
}
void Union(int index1,int index2){
int parent1=find(index1);
int parent2=find(index2);
if(parent1==parent2)return;
else{
parent[parent2]=parent1;
count--;
}
return ;
}
bool isConnected(int index1,int index2){
int parent1=find(index1);
int parent2=find(index2);
if(parent1==parent2)return true;
else return false;
}
};
class Solution {
public:
bool equationsPossible(vector<string>& equations) {
UnionSet unionSet(26);
for(int i=0;i<equations.size();i++){
int index1=equations[i][0]-'a';
int index2=equations[i][3]-'a';
if(equations[i][1]=='='){
unionSet.Union(index1,index2);
}
}
for(int i=0;i<equations.size();i++){
int index1=equations[i][0]-'a';
int index2=equations[i][3]-'a';
if(equations[i][1]=='!'){
if(unionSet.isConnected(index1,index2)==true){
return false;//判断结果违背,直接返回false
}
}
}
return true;
}
};