1 简介
UnionFind就是常说的并、查集算法，主要用来解决图论中的“动态连通性”的问题，也就是图中的“连通分量”问题。
连通分量的讲解在《算法导论3rd-P686》中，介绍主要如下：
如果一个无向图中每个顶点从所有其他顶点都是可达的，则称该图是连通的。图的连通分量是顶点在“从...可达”关系下的等价类。
2 描述
常用有根树来表示集合(树中的每个节点包含一个成员)，若干颗树组成一个森林，也就是说一个森林是包含多个集合的。可以将图划分为连通分量，每个连通分量就是一个集合，也就是一棵树。所以图的动态连通性就可以用该图相应连通分量构成的森林来描述，而森林可以用数组来实现，具体如下。
2.1 UnionFind 定义
怎么用森林来表示连通性呢？我们设定树的每个节点有一个指针指向其父节点，如果是根节点的话，这个指针指向自己。集合用有根数来表示，那相连通的两颗树就有相同的根节点，即：相连通的集合有相同的根节点。具体代码如下：
class UF
{
private:
// 连通分量个数
int count;
// 存储一棵树
int* parent;
// 记录树的“重量”
int* size;
public:
UF(int n)
{
count = n;
parent = new int[n];
size = new int[n];
for (int i = 0; i < n; i++)
{
parent[i] = i;
size[i] = 1;
}
}
~UF()
{
delete[] parent;
delete[] size;
}
void Union(int p, int q);
bool Connected(int p, int q);
int Find(int x);
};2.2 UnionFind并集
如果某两个节点被连通，则让其中的（任意）一个节点的根节点接到另一个节点的根节点上：
void UF::Union(int p, int q)
{
int rootP = Find(p);
int rootQ = Find(q);
if (rootP == rootQ)
return;
// 小树接到大树下面，较平衡
if (size[rootP] > size[rootQ])
{
parent[rootQ] = rootP;
size[rootP] += size[rootQ];
}
else
{
parent[rootP] = rootQ;
size[rootQ] += size[rootP];
}
count--;
}这里的并集操作使用了一个size来保存每棵树的结点数，这样可以将小树合并到大树上。
2.3 UnionFind连通性判断
相连通的两个集合，也就是在同一个连通分量的两个节点，它们一定具有相同的根节点：
bool UF::Connected(int p, int q)
{
int rootP = Find(p);
int rootQ = Find(q);
return rootP == rootQ;
}2.4 UnionFind的查找操作
这个查找操作使用了路径压缩(《算法导论3rd-P329》)，在调用Find的时候顺便把树给缩短了。
int UF::Find(int x)
{
while (parent[x] != x)
{
// 进行路径压缩
parent[x] = parent[parent[x]];
x = parent[x];
}
return x;
}2.5 UnionFind整合后的代码
算法的关键点有 3 个：
1、用parent数组记录每个节点的父节点，相当于指向父节点的指针，所以parent数组内实际存储着一个森林（若干棵多叉树）。
2、用size数组记录着每棵树的重量，目的是让union后树依然拥有平衡性，而不会退化成链表，影响操作效率。
3、在find函数中进行路径压缩，保证任意树的高度保持在常数，使得union和connectedAPI 时间复杂度为 O(1)。
class UF
{
public:
UF(int n)
{
count = n;
parent = new int[n];
size = new int[n];
for (int i = 0; i < n; i++)
{
parent[i] = i;
size[i] = 1;
}
}
~UF()
{
delete[] parent;
delete[] size;
}
void Union(int p, int q)
{
int rootP = Find(p);
int rootQ = Find(q);
if (rootP == rootQ)
return;
// 小树接到大树下面，较平衡
if (size[rootP] > size[rootQ])
{
parent[rootQ] = rootP;
size[rootP] += size[rootQ];
}
else
{
parent[rootP] = rootQ;
size[rootQ] += size[rootP];
}
count--;
}
bool Connected(int p, int q)
{
int rootP = Find(p);
int rootQ = Find(q);
return rootP == rootQ;
}
int Find(int x)
{
while (parent[x] != x)
{
// 进行路径压缩
parent[x] = parent[parent[x]];
x = parent[x];
}
return x;
}
private:
// 连通分量个数
int count;
// 存储一棵树
int* parent;
// 记录树的“重量”
int* size;
};
int main()
{
UF u(10);
u.Union(0, 1);
bool b = u.Connected(0, 1);
b = u.Connected(0, 2);
u.Union(0, 2);
b = u.Connected(0, 2);
return 0;
}3 力扣相关题目
3.1 被围绕的区域
class Solution {
public:
/* 方法一
先用 for 循环遍历棋盘的四边，用 DFS 算法把那些与边界相连的O换成一个特殊字符，比如#；
然后再遍历整个棋盘，把剩下的O换成X，把#恢复成O。这样就能完成题目的要求，时间复杂度 O(MN)。
*/
// void solve(vector<vector<char>>& board) {
// int n = board.size(), m = board[0].size();
// vector<vector<bool>> visited(n, vector<bool>(m,false));
// for (int c=0;c<m;++c)
// {
// dfs(board, visited, 0, c);
// dfs(board, visited, n-1, c);
// }
// for (int r=1;r<n-1;++r)
// {
// dfs(board, visited, r, 0);
// dfs(board, visited, r, m-1);
// }
// for (int r=0;r<n;++r)
// {
// for (int c=0;c<m;++c)
// {
// if (board[r][c] == 'O')
// board[r][c] = 'X';
// else if (board[r][c] == '#')
// board[r][c] = 'O';
// }
// }
// }
// void dfs(vector<vector<char>>& board, vector<vector<bool>>& visited, int r, int c)
// {
// if (r < 0 || r >= board.size() || c < 0 || c >= board[0].size())
// return;
// if (visited[r][c])
// return;
// visited[r][c] = true;
// if (board[r][c] == 'O')
// {
// board[r][c] = '#';
// dfs(board, visited, r-1, c);
// dfs(board, visited, r+1, c);
// dfs(board, visited, r, c-1);
// dfs(board, visited, r, c+1);
// }
// visited[r][c] = false;
// }
//方法二：使用UnionFind
class UF
{
public:
UF(int n)
{
count = n;
parent = new int[n];
size = new int[n];
for (int i = 0; i < n; i++)
{
parent[i] = i;
size[i] = 1;
}
}
~UF()
{
delete[] parent;
delete[] size;
}
void Union(int p, int q)
{
int rootP = Find(p);
int rootQ = Find(q);
if (rootP == rootQ)
return;
// 小树接到大树下面，较平衡
if (size[rootP] > size[rootQ])
{
parent[rootQ] = rootP;
size[rootP] += size[rootQ];
}
else
{
parent[rootP] = rootQ;
size[rootQ] += size[rootP];
}
count--;
}
bool Connected(int p, int q)
{
int rootP = Find(p);
int rootQ = Find(q);
return rootP == rootQ;
}
int Find(int x)
{
while (parent[x] != x)
{
// 进行路径压缩
parent[x] = parent[parent[x]];
x = parent[x];
}
return x;
}
private:
// 连通分量个数
int count;
// 存储一棵树
int* parent;
// 记录树的“重量”
int* size;
};
void solve(vector<vector<char>>& board) {
int m = board.size(), n = board[0].size();
// 给 dummy 留一个额外位置
UF uf(m * n + 1);
int dummy = m * n;
// 将首列和末列的 O 与 dummy 连通
for (int i = 0; i < m; i++)
{
if (board[i][0] == 'O')
uf.Union(i * n, dummy);
if (board[i][n - 1] == 'O')
uf.Union(i * n + n - 1, dummy);
}
// 将首行和末行的 O 与 dummy 连通
for (int j = 0; j < n; j++)
{
if (board[0][j] == 'O')
uf.Union(j, dummy);
if (board[m - 1][j] == 'O')
uf.Union(n * (m - 1) + j, dummy);
}
// 方向数组 d 是上下左右搜索的常用手法
int d[4][2] = {{1,0}, {0,1}, {0,-1}, {-1,0}};
for (int i = 1; i < m - 1; ++i)
{
for (int j = 1; j < n - 1; ++j)
{
if (board[i][j] == 'O')
{
// 将此 O 与上下左右的 O 连通
for (int k = 0; k < 4; ++k)
{
int x = i + d[k][0];
int y = j + d[k][1];
if (board[x][y] == 'O')
uf.Union(x * n + y, i * n + j);
}
}
}
}
// 所有不和 dummy 连通的 O，都要被替换
for (int i = 1; i < m - 1; ++i)
for (int j = 1; j < n - 1; ++j)
if (!uf.Connected(dummy, i * n + j))
board[i][j] = 'X';
}
};3.2 算式的有效性
给你一个数组equations，装着若干字符串表示的算式。每个算式equations[i]长度都是 4，而且只有这两种情况：a==b或者a!=b，
其中a,b可以是任意小写字母。你写一个算法，如果equations中所有算式都不会互相冲突，返回 true，否则返回 false。
比如说，输入["a==b","b!=c","c==a"]，算法返回 false，因为这三个算式不可能同时正确。
再比如，输入["c==c","b==d","x!=z"]，算法返回 true，因为这三个算式并不会造成逻辑冲突。
class Solution
{
public:
bool equationsPossible(vector<string>& equations) {
// 26 个英文字母
UF uf(26);
// 先让相等的字母形成连通分量
for (string& eq : equations)
{
if (eq[1] == '=')
{
char x = eq[0];
char y = eq[3];
uf.Union(x - 'a', y - 'a');
}
}
// 检查不等关系是否打破相等关系的连通性
for (string& eq : equations)
{
if (eq[1] == '!')
{
char x = eq[0];
char y = eq[3];
// 如果相等关系成立，就是逻辑冲突
if (uf.Connected(x - 'a', y - 'a'))
return false;
}
}
return true;
}
};3.3 以图判树
给定从 0 到 n-1 标号的 n 个结点，和一个无向边列表（每条边以结点对来表示），请编写一个函数用来判断这些边是否能够形成一个合法有效的树结构。
示例 1：
输入: n = 5, 边列表 edges = [[0,1], [0,2], [0,3], [1,4]]
输出: true
示例 2:
输入: n = 5, 边列表 edges = [[0,1], [1,2], [2,3], [1,3], [1,4]]
输出: false
注意：你可以假定边列表 edges 中不会出现重复的边。由于所有的边是无向边，边 [0,1] 和边 [1,0] 是相同的，因此不会同时出现在边列表 edges 中。
3.3.1 问题解析
「树」和「图」的根本区别：树不会包含环，图可以包含环。
图的连通分量可以用树来进行表示(开头已讲过了)，也就是说一棵树可以理解为某一个图的连通分量。
如果要在一棵树中增加一条边使得这棵树成为一个有环图，那应该如何操作？如果在现有的树中，连接两个之前没有连接过的节点(会增加一条边)，则会形成环；如果额外增加一个节点，然后将该节点与原树中的某一个节点相连，也会增加一条边，但这种情况不会形成一个有还图。也就是说：
对于添加的这条边，如果该边的两个节点本来就在同一连通分量(也就是同一颗树)里，那么添加这条边会产生环；反之，如果该边的两个节点不在同一连通分量里，则添加这条边不会产生环。用这个思路写成代码具体如下：
3.3.2 代码实现
class UF
{
public:
UF(int n)
{
count = n;
parent = new int[n];
size = new int[n];
for (int i = 0; i < n; i++)
{
parent[i] = i;
size[i] = 1;
}
}
~UF()
{
delete[] parent;
delete[] size;
}
void Union(int p, int q)
{
int rootP = Find(p);
int rootQ = Find(q);
if (rootP == rootQ)
return;
// 小树接到大树下面，较平衡
if (size[rootP] > size[rootQ])
{
parent[rootQ] = rootP;
size[rootP] += size[rootQ];
}
else
{
parent[rootP] = rootQ;
size[rootQ] += size[rootP];
}
count--;
}
bool Connected(int p, int q)
{
int rootP = Find(p);
int rootQ = Find(q);
return rootP == rootQ;
}
int Find(int x)
{
while (parent[x] != x)
{
// 进行路径压缩
parent[x] = parent[parent[x]];
x = parent[x];
}
return x;
}
int Count()
{
return count;
}
private:
// 连通分量个数
int count;
// 存储一棵树
int* parent;
// 记录树的“重量”
int* size;
};
class Solution {
public:
bool validTree(int n, vector<vector<int>>& edges) {
// 初始化 0...n-1 共 n 个节点
UF uf(n);
// 遍历所有边，将组成边的两个节点进行连接
for (auto& edge : edges)
{
int u = edge[0];
int v = edge[1];
// 若两个节点已经在同一连通分量中，会产生环
if (uf.Connected(u, v))
{
return false;
}
// 这条边不会产生环，可以是树的一部分
uf.Union(u, v);
}
// 要保证最后只形成了一棵树，即只有一个连通分量
return uf.Count() == 1;
}
};3.4 省份的数量
class UF
{
public:
UF(int n)
{
count = n;
parent = new int[n];
size = new int[n];
for (int i = 0; i < n; i++)
{
parent[i] = i;
size[i] = 1;
}
}
~UF()
{
delete[] parent;
delete[] size;
}
void Union(int p, int q)
{
int rootP = Find(p);
int rootQ = Find(q);
if (rootP == rootQ)
return;
// 小树接到大树下面，较平衡
if (size[rootP] > size[rootQ])
{
parent[rootQ] = rootP;
size[rootP] += size[rootQ];
}
else
{
parent[rootP] = rootQ;
size[rootQ] += size[rootP];
}
count--;
}
bool Connected(int p, int q)
{
int rootP = Find(p);
int rootQ = Find(q);
return rootP == rootQ;
}
int Find(int x)
{
while (parent[x] != x)
{
// 进行路径压缩
parent[x] = parent[parent[x]];
x = parent[x];
}
return x;
}
int Count()
{
return count;
}
private:
// 连通分量个数
int count;
// 存储一棵树
int* parent;
// 记录树的“重量”
int* size;
};
class Solution {
public:
// 其实就是求解图的连通分量的个数，使用union-find
int findCircleNum(vector<vector<int>>& isConnected) {
int n = isConnected.size();
UF uf(n);
for (int i=0;i<n;++i)
{
for (int j=0;j<n;++j)
{
if (isConnected[i][j])
uf.Union(i,j);
}
}
return uf.Count();
}
};3.5 多余的边
class UF
{
public:
UF(int n)
{
count = n;
parent = new int[n];
size = new int[n];
for (int i = 0; i < n; i++)
{
parent[i] = i;
size[i] = 1;
}
}
~UF()
{
delete[] parent;
delete[] size;
}
void Union(int p, int q)
{
int rootP = Find(p);
int rootQ = Find(q);
if (rootP == rootQ)
return;
// 小树接到大树下面，较平衡
if (size[rootP] > size[rootQ])
{
parent[rootQ] = rootP;
size[rootP] += size[rootQ];
}
else
{
parent[rootP] = rootQ;
size[rootQ] += size[rootP];
}
count--;
}
bool Connected(int p, int q)
{
int rootP = Find(p);
int rootQ = Find(q);
return rootP == rootQ;
}
int Find(int x)
{
while (parent[x] != x)
{
// 进行路径压缩
parent[x] = parent[parent[x]];
x = parent[x];
}
return x;
}
int Count()
{
return count;
}
private:
// 连通分量个数
int count;
// 存储一棵树
int* parent;
// 记录树的“重量”
int* size;
};
class Solution {
public:
// 使用 union-find 判断图中是否有环
vector<int> findRedundantConnection(vector<vector<int>>& edges) {
int lastU, lastV;
UF uf(edges.size());//注意这里的索引从0开始
for (auto& edge:edges)
{
int u = edge[0]-1, v = edge[1]-1;
if (uf.Connected(u,v))
{
lastU = edge[0];
lastV = edge[1];
continue;
}
uf.Union(u,v);
}
return vector<int>({lastU,lastV});
}
};3.6 相似字符串组
class UF
{
public:
UF(int n)
{
count = n;
parent = new int[n];
size = new int[n];
for (int i = 0; i < n; i++)
{
parent[i] = i;
size[i] = 1;
}
}
~UF()
{
delete[] parent;
delete[] size;
}
void Union(int p, int q)
{
int rootP = Find(p);
int rootQ = Find(q);
if (rootP == rootQ)
return;
// 小树接到大树下面，较平衡
if (size[rootP] > size[rootQ])
{
parent[rootQ] = rootP;
size[rootP] += size[rootQ];
}
else
{
parent[rootP] = rootQ;
size[rootQ] += size[rootP];
}
count--;
}
bool Connected(int p, int q)
{
int rootP = Find(p);
int rootQ = Find(q);
return rootP == rootQ;
}
int Find(int x)
{
while (parent[x] != x)
{
// 进行路径压缩
parent[x] = parent[parent[x]];
x = parent[x];
}
return x;
}
int Count()
{
return count;
}
private:
// 连通分量个数
int count;
// 存储一棵树
int* parent;
// 记录树的“重量”
int* size;
};
class Solution {
public:
int numSimilarGroups(vector<string>& strs) {
int n = strs.size();
UF uf(n);
for (int i=0;i<n;++i)
{
for (int j=i+1;j<n;++j)
{
if (uf.Connected(i,j))
continue;
if (differ(strs[i], strs[j]) <= 2)
uf.Union(i,j);
}
}
return uf.Count();
}
int differ(const string& word1, const string& word2) {
int n = word1.length(), count = 0;
for (int i = 0; i < n; i++)
{
if (word1[i] != word2[i])
++count;
}
return count;
}
};3.7
3.8
3.9
3.10
3.11
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
