数据结构之并查集

作者：CYJB

出处：http://www.cnblogs.com/cyjb/

GitHub：https://github.com/CYJB/

并查集

并查集（Union-find Sets）是一种非常精巧而实用的数据结构，它主要用于处理一些不相交集合的合并问题。一些常见的用途有求连通子图、求最小生成树的 Kruskal 算法和求最近公共祖先（Least Common Ancestors, LCA）等。
使用并查集时，首先会存在一组不相交的动态集合 S={S1,S2,⋯,Sk}，一般都会使用一个整数表示集合中的一个元素。
每个集合可能包含一个或多个元素，并选出集合中的某个元素作为代表。每个集合中具体包含了哪些元素是不关心的，具体选择哪个元素作为代表一般也是不关心的。我们关心的是，对于给定的元素，可以很快的找到这个元素所在的集合（的代表），以及合并两个元素所在的集合，而且这些操作的时间复杂度都是常数级的。
并查集的基本操作有三个：

makeSet(s)：建立一个新的并查集，其中包含 s 个单元素集合。
unionSet(x, y)：把元素 x 和元素 y 所在的集合合并，要求 x 和 y 所在的集合不相交，如果相交则不合并。
find(x)：找到元素 x 所在的集合的代表，该操作也可以用于判断两个元素是否位于同一个集合，只要将它们各自的代表比较一下就可以了。

并查集的实现原理也比较简单，就是使用树来表示集合，树的每个节点就表示集合中的一个元素，树根对应的元素就是该集合的代表，如图 1 所示。



图 1 并查集的树表示
图中有两棵树，分别对应两个集合，其中第一个集合为 {a,b,c,d}，代表元素是 a；第二个集合为 {e,f,g}，代表元素是 e。
树的节点表示集合中的元素，指针表示指向父节点的指针，根节点的指针指向自己，表示其没有父节点。沿着每个节点的父节点不断向上查找，最终就可以找到该树的根节点，即该集合的代表元素。
现在，应该可以很容易的写出 makeSet 和 find 的代码了，假设使用一个足够长的数组来存储树节点（很类似之前讲到的静态链表），那么
makeSet 要做的就是构造出如图 2 的森林，其中每个元素都是一个单元素集合，即父节点是其自身：



图 2 构造并查集初始化
相应的代码如下所示，时间复杂度是 O(n)：

接下来，就是 find 操作了，如果每次都沿着父节点向上查找，那时间复杂度就是树的高度，完全不可能达到常数级。这里需要应用一种非常简单而有效的策略——路径压缩。
路径压缩，就是在每次查找时，令查找路径上的每个节点都直接指向根节点，如图 3 所示。



图 3 路径压缩
我准备了两个版本的 find 操作实现，分别是递归版和非递归版，不过两个版本目前并没有发现有什么明显的效率差距，所以具体使用哪个完全凭个人喜好了。

最后是合并操作 unionSet，并查集的合并也非常简单，就是将一个集合的树根指向另一个集合的树根，如图 4 所示。



图 4 并查集的合并
这里也可以应用一个简单的启发式策略——按秩合并。该方法使用秩来表示树高度的上界，在合并时，总是将具有较小秩的树根指向具有较大秩的树根。简单的说，就是总是将比较矮的树作为子树，添加到较高的树中。为了保存秩，需要额外使用一个与 uset 同长度的数组，并将所有元素都初始化为 0。

下面是按秩合并的并查集的完整代码，这里只包含了递归的 find 操作。

除了按秩合并，并查集还有一种常见的策略，就是按集合中包含的元素个数（或者说树中的节点数）合并，将包含节点较少的树根，指向包含节点较多的树根。这个策略与按秩合并的策略类似，同样可以提升并查集的运行速度，而且省去了额外的 rank 数组。
这样的并查集具有一个略微不同的定义，即若 uset 的值是正数，则表示该元素的父节点（的索引）；若是负数，则表示该元素是所在集合的代表（即树根），而且值的相反数即为集合中的元素个数。相应的代码如下所示，同样包含递归和非递归的 find 操作：

如果要获取某个元素 x 所在集合包含的元素个数，可以使用 -uset[find(x)] 得到。
并查集的空间复杂度是 O(n) 的，这个很显然，如果是按秩合并的，占的空间要多一些。find
和 unionSet 操作都可以看成是常数级的，或者准确来说，在一个包含 n 个元素的并查集中，进行 m次查找或合并操作，最坏情况下所需的时间为 O(mα(n))，这里的 α 是 Ackerman
函数的某个反函数，在极大的范围内（比可观察到的宇宙中估计的原子数量 1080 还大很多）都可以认为是不大于
4 的。具体的时间复杂度分析，请参见《算法导论》的 21.4 节 带路径压缩的按秩合并的分析。

来两道ACM水题练练手
1.How much tables

Problem Description

Today is Ignatius' birthday. He invites a lot of friends. Now it's dinner time. Ignatius wants to know how many tables he needs at least. You have to notice that not all the friends know each other, and all the friends do not want to stay with strangers.

One important rule for this problem is that if I tell you A knows B, and B knows C, that means A, B, C know each other, so they can stay in one table.

For example: If I tell you A knows B, B knows C, and D knows E, so A, B, C can stay in one table, and D, E have to stay in the other one. So Ignatius needs 2 tables at least.

Input

The input starts with an integer T(1<=T<=25) which indicate the number of test cases. Then T test cases follow. Each test case starts with two integers N and M(1<=N,M<=1000). N indicates the number of friends, the friends are marked from 1 to N. Then M lines
follow. Each line consists of two integers A and B(A!=B), that means friend A and friend B know each other. There will be a blank line between two cases.

Output

For each test case, just output how many tables Ignatius needs at least. Do NOT print any blanks.

Sample Input

2
5 3
1 2
2 3
4 5

5 1
2 5

Sample Output

2
4

题目大意是：Ignatius请客吃饭，他要保证存在关系的朋友坐在一桌，而没有关系的朋友不能坐在一桌。例如A与B是朋友，B与C是朋友，那么A、B、C可以坐在一桌。现在问需要多少桌。

#include <iostream>
using namespace std;

const int MAXSIZE=1000;
int uset[MAXSIZE];
int rank[MAXSIZE];          //记录每个集合的秩
void makeSet( int size )    //makeSet初始化每个元素，将每个元素视为一个集合，以他们自己为代表。
{
for( int i=1; i<=size; i++ )
{
uset[i]=i;
rank[i]=0;
}
}

int find( int x )    //这里利用了路径压缩的策略，使得平均查找时间保持在常数级。这里x表示第x个朋友，而uset[x]则记录了他所属集合的代表。
{
if( x!=uset[x])
{
uset[x]=find(uset[x]);
}

return uset[x];
}

void unionSet( int x, int y )
{
if( (x=find(x)) == (y=find(y)) )
{
return;
}
if( rank[x] > rank[y] )
{
uset[y] = x;
}
else
{
uset[x] = y;
if( rank[x] == rank[y] )
{
rank[y]++;
}
}
}

int tables( int* uset, int size )    //tables函数是根据不同题目自定义的，这里的做法是遍历uset数组，记录下uset中有多少不同的代表，即有多少不相交集合，那么就摆多少桌
{
bool* bitarray = new bool[size+1];
for( int i=0; i<=size; i++ )
{
bitarray[i]=false;
}

for( int i=1; i<=size; i++ )
{
bitarray[find(uset[i])]=true;
}

int count=0;
for( int i=1; i<=size; i++ )
{
if( bitarray[i] == true )
{
count++;
}
}

return count;
}

int main( void )
{
int n;
cin>>n;
while( n > 0 )
{
int N,M;
cin>>N>>M;
makeSet(N);
for( int i=1; i<=M; i++ )
{
int f1,f2;
cin>>f1>>f2;
unionSet(f1,f2);
}

cout<<tables(uset,N)<<endl;

n--;

}
return 0;
}

2.畅通工程

Problem Description

某省调查城镇交通状况，得到现有城镇道路统计表，表中列出了每条道路直接连通的城镇。省政府“畅通工程”的目标是使全省任何两个城镇间都可以实现交通（但不一定有直接的道路相连，只要互相间接通过道路可达即可）。问最少还需要建设多少条道路？

Input

测试输入包含若干测试用例。每个测试用例的第1行给出两个正整数，分别是城镇数目N ( < 1000 )和道路数目M；随后的M行对应M条道路，每行给出一对正整数，分别是该条道路直接连通的两个城镇的编号。为简单起见，城镇从1到N编号。

注意:两个城市之间可以有多条道路相通,也就是说

3 3

1 2

1 2

2 1

这种输入也是合法的

当N为0时，输入结束，该用例不被处理。

Output

对每个测试用例，在1行里输出最少还需要建设的道路数目。

Sample Input

4 2
1 3
4 3
3 3
1 2
1 3
2 3
5 2
1 2
3 5
999 0
0

Sample Output

1
0
2
998

HintHint
Huge input, scanf is recommended.

题目分析：这道题不用多说，就是一个赤裸裸的并查集问题。计算出不相交集合的个数以后，减去1就可以了。代码就不多说了，参考上一题代码。