并查集UnionFindSet （ufs）

并查集原理

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

2.具体案例
①例子：比如有10个人去了学校，其中4个人是来自同一个地方的，3个人是来同自一个地方的，剩下3个人也是来自同一个地方的，那么开始这10个人是互不相识的，都是一个小个体，然后给这个几个人进行标识{0,1,2,3,4,5,6,7,8,9};但是没过多久，这几个人因为是来自同一个地方的人有相同的爱好，就走到了一起，所以这几个人要组合。

假设我们对开始的这几个人刚入学进行标记，如下图（其中我们以下标为负数代表这个人是单个个体）：

然后这几个人要进行分组，假设4个人的小分组为{0,6,7,8}，其中的一个3个人的小分组为{1,4,9}，另外一个3个人的小分组为{2,3,5}，则按照如上情况进行分组，我们可以画出如下图：

我们用森林的形式进行表示，取一个该组的成员成为根(其实这个根随便选，只要是该组的一个就好了，而我们为了方便，以小号选择根节点)，其他属于该组的成员成为其孩子节点就好了。

这样我们就可以将其编号以及表示划分为以下情况了：

其中：

• 数组的下标对应集合中元素的编号。
• 数组中如果为负数，负号代表的是根，而数字大小代表该组成员个数。
• 数组中如果为非负数，代表该元素双亲在数组中的下标。

②：如果说此时有两个小组熟悉了，它们要互相认识，那么就可以进行两个小组的合并。假设一个4人小组和一个3人小组进行合并：

合并完，那么情况就如上图所示

3.并查集的实现解决的问题：

• 查找元素属于哪个集合：沿着数组表示树形关系以上一直找到根。(即：树中中元素为负数的位置)
• 查看两个元素是否属于同一个集合：沿着数组表示的树形关系往上一直找到树的根，如果根相同表明在同一个集合，否则不在。
• 将两个集合归并成一个集合
  ①：将两个集合中的元素合并。
  ②：将一个集合名称改成另一个集合的名称。
• 集合的个数：遍历数组，数组中元素为负数的个数即为集合的个数。

并查集实现

#include<iostream>
#include<vector>
using namespace std;

template<class T>
class Unionfindset
{
public:
	Unionfindset(int size):_ufs(size,-1)
	{}
	~Unionfindset()
	{}
public:
	bool Union(int x,int y)
	{
		int root1 = FindRoot(x);
		int root2 = FindRoot(y);

		if (root1 == root2)    //证明两个数本来就属于同一个组
		{
			return true;
		}
		
		if (abs(_ufs[root1]) < abs(_ufs[root2]))   //小的往大的合并，会减少修改的次数(修改是在寻找根
		{                                          //节点的时候修改的)
			swap(root1, root2);
		}

		_ufs[root1] += _ufs[root2];
		_ufs[root2] = root1;
		return true;
	}
	int FindRoot(int x)    //找到其所属组
	{
		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;
	}
	int SumSize()                       //目前有多少组
	{
		int count = 0;
		for (auto& e : _ufs)
		{
			if (e < 0)
			{
				count++;
			}
		}
		return count;
	}
private:
	vector<int> _ufs;
};

并查集应用

请看如下例题：

这道题其实目的很明确，就是要将有同一个省份的城市划到一个集合中，然后最后返回的是省份的大小，其实这道题完全符合我们上面并查集的条件，所以直接将我们上面写的的代码给入，然后操作即可：

template<class T>
class Unionfindset
{
public:
	Unionfindset(int size):_ufs(size,-1)
	{}
	~Unionfindset()
	{}
public:
	bool Union(int x,int y)
	{
		int root1 = FindRoot(x);
		int root2 = FindRoot(y);

		if (root1 == root2)    //证明两个数本来就属于同一个组
		{
			return true;
		}
		
		if (abs(_ufs[root1]) < abs(_ufs[root2]))   //小的往大的合并，会减少修改的次数(修改是在寻找根
		{                                          //节点的时候修改的)
			swap(root1, root2);
		}

		_ufs[root1] += _ufs[root2];
		_ufs[root2] = root1;
		return true;
	}
	int FindRoot(int x)    //找到其所属组
	{
		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;
	}
	int SumSize()                       //目前有多少组
	{
		int count = 0;
		for (auto& e : _ufs)
		{
			if (e < 0)
			{
				count++;
			}
		}
		return count;
	}
private:
	vector<int> _ufs;
};
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 < isConnected[i].size();++j)
            {
                if(isConnected[i][j] == 1)     //两个城市在一个省份，进行合并
                {
                   ufs.Union(i,j);
                }
            }
        }
        return ufs.SumSize();
    }
};

其实，在真正解题的时候，我们其实没必要将并查集的类必须接出来，直接使用一个数组进行模拟替代即可，如下：

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[i].size();++j)
            {
                if(isConnected[i][j] == 1)
                {
                    int root1 = FindRoot(i);
                    int root2 = FindRoot(j);
                    if(root1 != root2)
                    {
                        ufs[root1] += ufs[root2];
                        ufs[root2] = root1;
                    }
                }
            }
        }

        int count = 0;
        for(auto& e : ufs)
        {
            if(e < 0)
            {
                ++count;
            }
        }
        return count;
    }
};