并查集

并查集是一种用于不相交集合上的操作的高级数据结构。

对于不相交集合，一般的操作包括两种：查询某个结点所属集合的代表元素、合并两个集合。

针对这两种操作，我们可以设计这样一种数据结构：

用编号0－n表示所有结点，用一个数组 parent[ ] 存储他们所属的集合的代表元素的编号。

初始化时，每个元素单独构成一个集合，因此 parent[i] = i。

当执行合并操作的时候，比如说把结点1合并到结点2所在的集合，则需要使用 parent[1] = parent[2]。但是如果把整个集合合并到另一个集合，就需要把集合内的每个点的 parent 都指向新集合的代表元素，这样很费时间。因此可以把 parent[i] 设置成结点i的父亲结点，使用递归的方式，如果要找结点1的集合的代表元素，则先找到 x = parent[1]，然后判断是否 x == parent[x]，如果是的话说明x就是代表元素，否则再递归查找 parent[x]，最终找到的那个元素就是该集合的代表元素。

所以并查集的两种操作可以描述如下：

1、查，即查找某个结点所在的集合的代表元素

使用递归查找的方式，对于结点x，若 parent[x] = x，则直接返回x，否则令 y = parent[x]，返回 parent[y]。

2、并，即合并两个结点所在的集合

假设结点分别为x和y，则先使用查找操作找到两个结点所属集合的代表元素px和py，若 px == py 则说明两个结点已经在同一个集合中。否则的话，直接使用 parent[px] = py 或 parent[py] = px 即可。

对于并查集的两个优化：

一、启发式合并：对于集合合并有一个优化，那就是把较小的集合合并到较大的集合上，这样可以让集合树高度不致于太高，加快查找操作的速度。因此用另一个数组 count[] 存储集合的大小，由于使用递归查找代表元素，因此实际上只有集合的代表元素对应的 count[i] 才拥有整个集合的大小，其他结点只是用于辅助。

二、路径压缩：在递归查找某个结点所属集合的代表元素时，顺便把沿途遇到的非代表元素的父亲指向最终的结点——代表元素，这样可以加快后续的查找。

完整代码实现如下：

//DisjointSet.h

#ifndef _DISJOINT_SET_
#define _DISJOINT_SET_

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

class UnionFindSet
{
public:
	UnionFindSet(int _nodeNumber);	//初始化
	~UnionFindSet();
	int findRoot(int node);			//查找代表元素
	bool unionNodes(int node1, int node2);	//合并结点所在集合
	int getNodeNumber();			//获取总结点数
protected:
private:
	int nodeNumber;
	vector<int> parent;				//结点的父亲
	vector<int> count;				//集合的大小
};

#endif

//DisjointSet.cpp

#include "DisjointSet.h"

UnionFindSet::UnionFindSet(int _nodeNumber): nodeNumber(_nodeNumber)
{
	parent.resize(nodeNumber);
	count.resize(nodeNumber);
	for (int i = 0; i < nodeNumber; ++i)
	{
		parent[i] = i;
		count[i] = 1;
	}
}

UnionFindSet::~UnionFindSet()
{
	parent.clear();
	count.clear();
}

int UnionFindSet::findRoot(int node)
{
	if (parent[node] == node) return node;
	else 
	{
		parent[node] = findRoot(parent[node]);	//路径压缩
		return parent[node];
	}
}

bool UnionFindSet::unionNodes(int node1, int node2)
{
	int r1 = findRoot(node1);
	int r2 = findRoot(node2);
	if (r1 == r2) return false;
	//启发式合并
	if (count[r1] < count[r2])
	{
		count[r2] += count[r1];
		parent[r1] = r2;
	}
	else
	{
		count[r1] += count[r2];
		parent[r2] = r1;
	}
}

int UnionFindSet::getNodeNumber()
{
	return nodeNumber;
}

//main.cpp

#include "DisjointSet.h"
#include <string>
using namespace std;

int main()
{
	int n;
	cout << "input the size: ";
	cin >> n;
	UnionFindSet ufs(n);
	string str;
	int node1, node2;
	while (cin >> str)
	{
		if (str == "union" || str == "UNION")
		{
			cin >> node1 >> node2;
			if (node1 >= ufs.getNodeNumber() || node2 >= ufs.getNodeNumber())
			{
				cout << "error" << endl;
				continue;
			}
			if (ufs.unionNodes(node1, node2))
			{
				cout << "union " << node1 << " and " << node2 << " successfully" << endl;
			}
			else
			{
				cout << node1 << " and " << node2 << " are already in the same set" << endl;
			}
		}
		else if (str == "find" || str == "FIND")
		{
			cin >> node1;
			if (node1 >= ufs.getNodeNumber())
			{
				cout << "error" << endl;
				continue;
			}
			cout << "the root of " << node1 << " is " << ufs.findRoot(node1) << endl;
		}
		else break;
	}
	return 0;
}