C++ 并查集（定义、路径压缩、应用(剑指 Offer II 116. 省份数量、LeetCode等式方程的可满足性)、模拟实现）

1.并查集的定义

并查集是一个多棵树的集合（森林）。

并查集由多个集合构成，每一个集合就是一颗树。
并：合并多个集合。查：判断两个值是否再一个集合中。

每棵树存在数组中，使用双亲表示法。数组每个元素的父节点。如果没有父节点数组保存-1。根节点位置的数组值就算这颗树节点的个数。
eg：

2.并查集的应用

剑指 Offer II 116. 省份数量

返回省份数量本质是返回并查集中集合的数量

由上图分析可知，我们只需要看二维矩阵的一半即可。因为矩阵一定是对称的。

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等式方程的可满足性

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;
	}
};