并查集

什么是并查集？　　并查集是一种树型的数据结构，用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。常常在使用中以森林来表示。

并查集的主要操作：

　　(1)查找：查找元素所在的集合即根节点

　　(2)合并：将两个元素所在的集合合并为一个集合

　　合并两个不相交集合判断两个元素是否属于同一集合

　　亲戚(Relations)

　　思路点拨

　　一 问题实质

　　初步分析觉得本题是一个图论中判断两个点是否在同一个连通子图中的问题。对于题目中的样例，以人为点，关系为边，建立无向图如下：

　　图0-0-1 {请补充图解}

　　比如判断3和4是否为亲戚时，我们检查3和4是否在同一个连通子图中，结果是，于是他们是亲戚。又如7和10不在同一个连通子图中，所以他们不是亲戚。

　　用图的数据结构的最大问题是，我们无法存下多至(M=)2 000 000条边的图，后面关于算法时效等诸多问题就免谈了。

　　用图表示关系过于“奢侈”了。其实本题只是一个对分离集合（并查集）操作的问题。

　　我们可以给每个人建立一个集合，集合的元素值有他自己，表示最开始时他不知道任何人是它的亲戚。以后每次给出一个亲戚关系a, b，则a和他的亲戚与b和他的亲戚就互为亲戚了，将a所在集合与b所在集合合并。对于样例数据的操作全过程如下：

　　输入关系 分离集合

　　初始状态

　　(2,4) {2,4}

　　(5,7) {2,4} {5,7}

　　(1,3) {1,3} {2,4} {5,7}

　　(8,9) {1,3} {2,4} {5,7} {8,9}

　　(1,2) {1,2,3,4} {5,7} {8,9}

　　(5,6) {1,2,3,4} {5,6,7} {8,9}

　　(2,3) {1,2,3,4} {5,6,7} {8,9}

　　最后我们得到4个集合{1,2,3,4}, {5,6,7}, {8,9}, ，于是判断两个人是否亲戚的问题就变成判断两个数是否在同一个集合中的问题。如此一来，需要的数据结构就没有图结构那样庞大了。

　　算法需要以下几个子过程：

　　(1) 开始时，为每个人建立一个集合SUB-Make-Set(x)；

　　(2) 得到一个关系后a,b，合并相应集合SUB-Union(a,b)；

　　(3) 此外我们还需要判断两个人是否在同一个集合中，这就涉及到如何标识集合的问题。我们可以在每个集合中选一个代表标识集合，因此我们需要一个子过程给出每个集合的代表元SUB-Find-Set(a)。于是判断两个人是否在同一个集合中，即两个人是否为亲戚，等价于判断SUB-Find-Set(a)=SUB-Find-Set(b)。

　　有了以上子过程的支持，我们就有如下算法。

　　PROBLEM-Relations(N, M, a1,…,aM, b1,…,bM, Q, c1,…,cQ, d1,…,dQ)

　　1 for i←1 to N

　　2 do SUB-Make-Set(i)

　　3 for i←1 to M

　　4 do if SUB-Find-Set(ai)SUB-Find-Set(bi)

　　5 then SUB-Union(ai, bi)

　　6 for i←1 to Q

　　7 do if SUB-Find-Set(ci)=SUB-Find-Set(di)

　　8 then output “Yes”

　　9 else output “No”

　　解决问题的关键便为选择合适的数据结构实现分离集合的操作，使算法的实现效率最高。

　　二 单链表实现

　　一个节点对应一个人，在同一个集合中的节点串成一条链表就得到了单链表的实现。在集合中我们以单链表的第一个节点作为集合的代表元。于是每个节点x（x也是人的编号）应包含这些信息：指向代表元即表首的指针head[x]，指向表尾的指针tail[x]，下一个节点的指针next[x]。

　　SUB-Make-Set(x)过程设计如下：

　　SUB-Make-Set(x)

　　10 head[x]←x

　　11 tail[x]←x

　　12 next[x]←NIL

　　求代表元的SUB-Find-Set(x)过程设计如下：

　　SUB-Find-Set(x)

　　13 return head[x]

　　前两个过程比较简单，SUB-Union(a,b)稍微复杂一点。我们要做的是将b所在链表加到a所在链表尾，然后b所在链表中的所有节点的代表元指针改指a所在链表的表首节点，如图所示。

　　图0-0-2

　　过程的伪代码如下：

　　SUB-Union(a,b)

　　14 next[tail[head[a]]]←head

　　15 tail[head[a]]←tail[head]

　　16 p←head

　　17 while pNIL

　　18 do head[p]←head[a]

　　19 p←next[p]

　　现在我们来分析一下算法的时间效率。SUB-Make-Set(x)和SUB-Find-Set(x)都只需要O(1)的时间，而SUB-Union(a,b)的时间效率与b所在链表的长度成线性关系。最坏情况下，即有操作序列SUB-Union(N-1,N), SUB-Union(N-2,N-1), …, SUB-Union(1,2)时，整个算法PROBLEM-Relations的时间复杂度为O(N+M+N2+Q)=O(N2+M+Q)。

　　由于算法的时间复杂度中O(M+Q)是必需的，因此我们要让算法更快，就要考虑如何使减小O(N2)。

　　我们想到合并链表时，我们可以用一种启发式的方法：将较短的表合并到较长表上。为此每个节点中还需包含表的长度的信息。这比较容易实现，我们就不写出伪代码了。

　　我们来分析一下现在SUB-Union(a,b)的时间复杂度。

　　首先我们给出一个固定对象x的代表元指针head[x]被更新次数的上界。由于每次x的代表元指针被更新时，x必然在较小的集合中，因此x的代表元指针被更新一次后，集合至少含2个元素。类似地，下一次更新后，集合至少含4个元素，继续下去，当x的代表元指针被更新 log k 次后，集合至少含k个元素，而集合最多含n个元素，所以x的代表元指针至多被更新 log n 次。所以M次SUB-Union(a,b)操作的时间复杂度为O(NlogN+M)。算法总的时间复杂度为O(N log N + M + Q)。

　　三 分离集合的森林

　　分离集合的另一种更快的实现是用有根树来表示集合：每棵树表示一个集合，树中的节点对应一个人。图示出了一个分离集合的森林。

　　图0-0-3

　　每个节点x包含这些信息：父节点指针p[x]，树的深度rank[x]。其中rank[x]将用于启发式合并过程。

　　于是建立集合过程的时间复杂度依然为O(1)。

　　SUB-Make-Set(x)

　　20 p[x]←x

　　21 rank[x]←0

　　用森林的数据结构来实现的最大好处就是降低SUB-Union(a,b)过程的时间复杂度。

　　SUB-Union(a,b)

　　22 SUB-Link(SUB-Find-Set(a),SUB-Find-Set(b))

　　SUB-Link(a,b)

　　23 p[a]←b

　　合并集合的工作只是将a所在树的根节点的父节点改为b所在树的根节点。这个操作只需O(1)的时间。而SUB-Union(a,b)的时间效率决定于SUB-Find-Set(x)的快慢。

　　SUB-Find-Set(x)

　　24 if x=p[x]

　　25 then return x

　　26 else return SUB-Find-Set(p[x])

　　这个过程的时效与树的深度成线性关系，因此其平均时间复杂度为O(logN)，但在最坏情况下（树退化成链表），时间复杂度为O(N)。于是PROBLEM-Relations最坏情况的时间复杂度为O(N(M+Q))。有必要对算法进行优化。

　　第一个优化是启发式合并。在优化单链表时，我们将较短的表链到较长的表尾，在这里我们可以用同样的方法，将深度较小的树指到深度较大的树的根上。这样可以防止树的退化，最坏情况不会出现。SUB-Find-Set(x)的时间复杂度为O(log N)，PROBLEM-Relations时间复杂度为O(N + logN (M+Q))。SUB-Link(a,b)作相应改动。

　　SUB-Link(a,b)

　　27 if rank[a]>rank

　　28 then p←a

　　29 else p[a]←b

　　30 if rank[a]=rank

　　31 then rank←rank+1

　　然而算法的耗时主要还是花在SUB-Find-Set(x)上。

　　第二个优化是路径压缩。它非常简单而有效。如图所示，在SUB-Find-Set(1)时，我们“顺便”将节点1, 2, 3的父节点权改为节点4，以后再调用SUB-Find-Set(1)时就只需O(1)的时间。

　　图0-0-4

　　于是SUB-Find-Set(x)的代码改为：

　　SUB-Find-Set(x)

　　32 if xp[x]

　　33 then p[x]←SUB-Find-Set(p[x])

　　34 return p[x]

　　该过程首先找到树的根，然后将路径上的所有节点的父节点改为这个根。实现时，递归的程序有许多栈的操作，改成非递归会更快些。

　　SUB-Find-Set(x)

　　35 r←x

　　36 while rp[r]

　　37 do r←p[r]

　　38 while xr

　　39 do q←p[x]

　　40 p[x]←r

　　41 x←q

　　42 return r

　　改进后的算法时间复杂度的分析十分复杂，如果完整的写出来足可写一节，这里我们指给出结论：改进后的PROBLEM-Relations其时间复杂度为O(N+(M+Q)(M+Q,N))，其中(M+Q,N)为Ackerman函数的增长极为缓慢的逆函数。你不必了解与Ackerman函数相关的内容，只需知道在任何可想象得到的分离集合数据结构的应用中，(M+Q,N)  4，因此PROBLEM-Relations的时间复杂度可认为是线性的O(N+M+Q)。

　　解(略)

　　本题的输入数据量很大，这使得我们的程序会在输入中花去不少时间。如果你用Pascal写程序，可以用库函数SetTextBuf为输入文件设置缓冲区，这可以使输入过程加快不少。如果你是用C语言的话，就不必为此操心了，系统会自动分配缓冲区。

 

 

 

 

并查集，就是Union-Find Set，也称不相交集合 (Disjoint Set)。这在数据结构中本是很简单的一种东西。当然，我是指算法的实现简单，而非其理论分析简单。但我今天还是要扯一下这个，因为我突然发现我这几天写的并查集都是错的，今天做题时才发现。所以还是把这个很简单的数据结构总结一下。

正如它的名字揭示的，并查集的基本操作有两个：Union和Find。其中Find(x)返回元素x所在的集合的编号，Union(i,j)将i与j所在的集合合并，也就是说在此之后对它们中的每一个调用Find的返回值必须是一样的。

实现时采用父亲表示法的树结构，保证所有在一个集合里的元素都在一棵树内，集合的代表元素就是根。初始时所有节点的父节点都是自身，查找时只须沿着向上的路径查找即可；如果要将两棵树合并只须将其中一棵的根的父节点设为另一棵树的根即可。最主要的优化是所谓路径压缩。简言之，就是在Find的实现时并不简单的return find(U[x]); 而是 return U[x]=find(U[x]); 这样就将当前节点到根的路径上的所有节点的父亲都设为了根，将原本可能比较长的路径“压缩”了。当然这是递归的实现，非递归的话需要沿路径走两次，第一次找到根，第二次再改变。

union操作更简单，只是U[find(x)]=find(y);一句而已。我前两天写Tarjan算法时把这一句错写成U[x]=find(y)，竟然也AC了……汗……不过今天做另一道需要并查集的题目就没那么幸运了。

路径压缩的并查集n个操作的序列的均摊复杂度为O(nα(n))，其中 α是阿柯曼函数的一个反函数，增长极慢，在可以想象的n的范围内不超过5，故可视为常数。

并查集的一般用途就是用来维护某种具有自反、对称、传递性质的关系的等价类。

实现并查集只需要一个数组和两个分别是两行和一行的函数，故不再发示例代码了。

April 12, 2007 · Filed under 程序园