1.并查集的定义
并查集是一个多棵树的集合(森林)。
并查集由多个集合构成,每一个集合就是一颗树。
并:合并多个集合。查:判断两个值是否再一个集合中。
每棵树存在数组中,使用双亲表示法。数组每个元素的父节点。如果没有父节点数组保存-1。根节点位置的数组值就算这颗树节点的个数。
eg:
2.并查集的应用
返回省份数量本质是返回并查集中集合的数量
由上图分析可知,我们只需要看二维矩阵的一半即可。因为矩阵一定是对称的。
0号城市和1号城市相邻[0][1]=1,1号城市和0号一定也相邻[1][0]=1
针对这种情况思路如下图:
C++代码如下间并查集练习
3.C++模拟实现并查集数据结构
#pragma once
#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;
class UnionFindSet {
private:
vector<int>ufs;
public:
UnionFindSet(size_t size) {
ufs.resize(size,-1);//初始化并查集
}
//x1和x2所在的两个集合合并
void Unoin(int x, int y) {
assert(x < ufs.size() && y < ufs.size());
//找到两个集合的根节点
int root1 = FindRoot(x);
int root2 = FindRoot(y);
//本身在一个集合中,不需要合并
if (root1 != root2) {
ufs[root1] += ufs[root2];
ufs[root2] = root1;
}
}
//找到某个集合的根节点
int FindRoot(int x) {
assert(x < ufs.size());
int ret = 0;
while (x >= 0) {
ret = x;
x = ufs[x];
}
return ret;
}
size_t Size() {//返回并查集中集合的个数
int ret = 0;
for (int i = 0; i < ufs.size(); i++) {
if (ufs[i] < 0) {
ret++;
}
}
return ret;
}
};
C++代码如下间并查集练习
剑指 Offer II 116. 省份数量题的C++代码如下:
#include<assert.h>
class UnionFindSet {
private:
vector<int>ufs;
public:
UnionFindSet(size_t size) {
ufs.resize(size,-1);//初始化并查集
}
//x1和x2所在的两个集合合并
void Unoin(int x, int y) {
assert(x < ufs.size() && y < ufs.size());
//找到两个集合的根节点
int root1 = FindRoot(x);
int root2 = FindRoot(y);
//本身在一个集合中,不需要合并
if (root1 != root2) {
ufs[root1] += ufs[root2];
ufs[root2] = root1;
}
}
//找到某个集合的根节点
int FindRoot(int x) {
assert(x < ufs.size());
int ret = 0;
while (x >= 0) {
ret = x;
x = ufs[x];
}
return ret;
}
size_t Size() {
int ret = 0;
for (int i = 0; i < ufs.size(); i++) {
if (ufs[i] < 0) {
ret++;
}
}
return ret;
}
};
class Solution {
public:
int findCircleNum(vector<vector<int>>& isConnected) {
UnionFindSet ufs(isConnected.size());
for(int i=0;i<isConnected.size();i++){
for(int j=0;j<i;j++){
if(isConnected[i][j]==1){
ufs.Unoin(i,j);
}
}
}
return ufs.Size();
}
};
LeetCode等式方程的可满足性
因为等于具有传递性,这里使用并查集。
a和b相等代表他们在一个集合中。a和b不相等代表他们不能在一个集合中。
这里选择先将等式全部添加到集合中,之后再看不相同的等式是否在集合中即可。
此外,因为并查集只能是整数下标,所以需要使用字母和整数之间的映射来完成。
a->0 b->1……(直接定址法)即可
#include<assert.h>
class UnionFindSet {
private:
vector<int>ufs;
public:
UnionFindSet(size_t size) {
ufs.resize(size,-1);//初始化并查集
}
//x1和x2所在的两个集合合并
void Unoin(int x, int y) {
assert(x < ufs.size() && y < ufs.size());
//找到两个集合的根节点
int root1 = FindRoot(x);
int root2 = FindRoot(y);
//本身在一个集合中,不需要合并
if (root1 != root2) {
ufs[root1] += ufs[root2];
ufs[root2] = root1;
}
}
//找到某个集合的根节点
int FindRoot(int x) {
assert(x < ufs.size());
int ret = 0;
while (x >= 0) {
ret = x;
x = ufs[x];
}
return ret;
}
size_t Size() {
int ret = 0;
for (int i = 0; i < ufs.size(); i++) {
if (ufs[i] < 0) {
ret++;
}
}
return ret;
}
};
class Solution {
public:
bool equationsPossible(vector<string>& equations) {
UnionFindSet ufs(26);
for(const auto&e:equations){
//先把相等的字符串合并
if(e[1]=='='){
ufs.Unoin(e[0]-'a',e[3]-'a');
}
}
for(const auto&e:equations){
//判断不相同的字符串
if(e[1]=='!'){
if(ufs.FindRoot(e[0]-'a')==ufs.FindRoot(e[3]-'a')){
return false;
}
}
}
return true;
}
};
并查集最坏情况时间复杂度为O(N),结合这个题来讲最坏情况的时间复杂度为O(N^2)。但是这种情况概率很小。
4. 补充:并查集的效率优化,路径压缩
根据上文可知,并查集查找的速度与树的高度有关。
当查找节点后,如果能将这个节点到根节点路径上的节点都直接插入到根节点上,则可以显著降低树的高度,从而提高效率。
上述过程在查找节点的根节点时实现,找到根节点时先不返回,再遍历一遍更新节点的父节点即可。
#pragma once
#pragma once
#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;
class UnionFindSet {
private:
vector<int>ufs;
public:
UnionFindSet(size_t size) {
ufs.resize(size, -1);//初始化并查集
}
//x1和x2所在的两个集合合并
void Unoin(int x, int y) {
assert(x < ufs.size() && y < ufs.size());
//找到两个集合的根节点
int root1 = FindRoot(x);
int root2 = FindRoot(y);
//本身在一个集合中,不需要合并
if (root1 != root2) {
ufs[root1] += ufs[root2];
ufs[root2] = root1;
}
}
//找到某个集合的根节点
int FindRoot(int x) {
assert(x < ufs.size());
int root = x;
while (ufs[root] >= 0) {
root = ufs[root];
}
//把这个节点,这个节点到根节点路径上的所有节点插入到根节点上
while (ufs[x] >= 0) {
int parent = ufs[x];
ufs[x] = root;
x = parent;
}
return root;
}
size_t Size() {//返回并查集中集合的个数
int ret = 0;
for (int i = 0; i < ufs.size(); i++) {
if (ufs[i] < 0) {
ret++;
}
}
return ret;
}
};