并查集算法

算法思想：

1.初始化功能：把每个点所在集合初始化为其自身。

2.查找功能：查找元素所在的集合，即根节点。

2.合并功能：将两个元素所在的集合合并为一个集合。

例题：若某个家族人员过于庞大，要判断两个是否是亲戚，确实不容易，给出某个亲戚关系图，求任意给出的两个人是否具有亲戚关系。

规定：x和y是亲戚，y和z是亲戚，那么x和z也是亲戚。如果x,y是亲戚，那么x的亲戚都是y的亲戚，y的亲戚也都是x的亲戚。

Input（输入）

第一行：三个整数n,m,p，（n< =5000,m< =5000,p< =5000）分别表示有n个人，m个亲戚关系，询问p对亲戚关系。以下m行：每行两个数a,b.(1<=a,b<=n),表示a和b具有亲戚关系。接下来p行：每行两个数

a，b。表示询问a和b是否具有亲戚关系。

Output（输出）

共P行，每行一个’Yes’或’No’。表示第p个询问的答案为“有”或“没有”亲戚关系。

 

样例：

9 7 1

2 4

5 7

1 3

8 9

1 2

5 6

2 3

1 9

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

初始状态：{1} {2} {3} {4} {5} {6} {7} {8} {9}

输入关系 分离集合

输入第二行：2 4  后：{2,4}{1} {3} {5} {6} {7} {8} {9}

输入第三行：5 7  后：{2,4} {5,7} {1} {3} {6} {8} {9}

输入第四行：1 3  后： {1,3} {2,4} {5,7}{6} {8} {9}

输入第五行：8 9  后：{1,3} {2,4} {5,7} {8,9}{6}

输入第六行：1 2  后： {1,2,3,4} {5,7} {8,9}{6}

输入第七行：5 6  后：{1,2,3,4} {5,6,7} {8,9}

输入第八行：2 3  后：{1,2,3,4} {5,6,7} {8,9}

判断亲戚关系

输入第二行：2 4  后：因为1,9不在同一集合内，所以输出"NO"。

最后我们得到3个 集合{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)。

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

 

//初始化
for(int i=0;i<n;i++)
{
    SUB-Make-Set(i);
}
//合并
for(int i=0;i<n;i++)
{
    if(SUB-Find-Set(ai) != SUB-Find-Set(bi))
　　{　
       SUB-Union(ai, bi);
    }
}

//询问
fou(int i=0;i<n;i++)
{  
    if(SUB-Find-Set(ci)==SUB-Find-Set(di))
　　{ 
      output “Yes” 
    }
　　else
　　{ 
      output “No” 
    }
}

 

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

 

优化反向

1. 单链表实现

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

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

SUB-Make-Set(x)
{
    for(int i=0;i<x;i++)
    {
        head[x]=x;
        tail[x]=x;
        next[x]=0;
    }
}

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

SUB-Find-Set(x)
{
    return head[x];
}

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

过程的伪代码如下：

SUB-Union(a,b)
{
    next[tail[head[a]]]=head[b];
    int p=head[b];
    while(p!=0)
    {
        head[p]=head[a];
        p=next[p];
    }
}

整个算法PROBLEM-Relations的 时间复杂度为O(N+M+N^2+Q)=O(N^2+M+Q)。

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

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

合并链表后的 时间复杂度：

首先我们给出一个固定对象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(NlogN+M+Q)。

2.并查集森林

编辑

并查集的另一种更快的实现是用有根树来表示 集合：每棵树表示一个集合，树中的节点对应一个人。

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

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

SUB-Make-Set(x)
{
    for(int i=0;i<x;i++)
    {
        p[i]=i;
        rank[i]=0;
    }
}

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

SUB-Union(a,b)
{
    //SUB-Link(SUB-Find-Set(a),SUB-Find-Set(b))
    SUB-Link(a,b)
    p[a]=b;
}

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

SUB-Find-Set(x)
{
    if(x==p[a])
    {
        return x;
    }
    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)
{
    if(rank[a]>rank[b])
    {
        p[b]=a;
        rank[b]+=rank[a];
    }
    else
    {
        p[a]=b;
        rank[a]+=rank[b];
    }
}

然而算法的耗时主要还是花在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)
{
    if(x!=p[x])
    {
        p[x]=SUB-Find-Set(p[x]);
    }
    return p[x];
}

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

SUB-Find-Set(x)
{
    int r=x;
    while(r!=p[x])
    {
        r=p[r];
    }
    while x?r
     do q←p[x]
     p[x]←r
     x←q
     return r
}

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

优化路径压缩

思想

每次查找的时候，如果路径较长，则修改信息，以便下次查找的时候速度更快。

实现

第一步，找到根结点。

第二步，修改查找路径上的所有节点，将它们都指向根结点。

 

int find(int x)
{
    if(fa[x]==x)
    {
        return x;
    }
    return fa[x]=find(fa[x]);
}

 

模板：

/fa[x]表示x的最远祖先
int fa[50002];
//初始化，一开始每个点单独成集合
void build(int qwq) 
{
    for(int i=1;i<=qwq;i++)
    {
        fa[i]=i;
    }
    return ;
} 
//找到x的最远祖先，并且压缩路径
int find(int x)
{
    if(fa[x]==x)
    {
        return x;
    }
    return fa[x]=find(fa[x]);
}
//判断x,y是不是在同一个集合里，直接判断最远祖先是不是一样的 
bool che(int x,int y)
{
    return find(x)==find(y);
}
//合并x,y，我们在判断x和y是不是同一个集合里，
//路径压缩之后fa[x],fa[y]已经是最远祖先了，
//所以直接将fa[x]的父亲连接在fa[y]的祖先上
void mer(int x,int y)
{
    if(!che(x,y)) 
    {
        fa[fa[x]]=fa[y];
    }
    return ;
}