并查集【转】

 并查集（Disjoint set或者Union-find set）是一种简单的用途广泛的算法和数据结构。并查集是若干个不相交集合，能够实现较快的合并和判断元素所在集合的操作，应用很多，如其求无向图的连通分量个数等。

并查集可以方便地进行以下三种操作：

1、Make_Set(x) 把每一个元素初始化为一个集合

初始化后每一个元素的父亲节点是它本身，每一个元素的祖先节点也是它本身（也可以根据情况而变）。

2、Find_Set(x) 查找一个元素所在的集合

查找一个元素所在的集合，其精髓是找到这个元素所在集合的祖先。这个才是并查集判断和合并的最终依据。

判断两个元素是否属于同一集合，只要看他们所在集合的祖先是否相同即可。

合并两个集合，也是使一个集合的祖先成为另一个集合的祖先，具体见示意图。

3、Union(x,y) 合并x,y 所在的两个集合

合并两个不相交集合操作很简单：

利用Find_Set找到其中两个集合的祖先，将一个集合的祖先指向另一个集合的祖先。如图

并查集的优化：

1、Find_Set(x)时 路径压缩

寻找祖先时我们一般采用递归查找，但是当元素很多亦或是整棵树变为一条链时，每次Find_Set(x)都是O(n)的复杂度，有没有办法减小这个复杂度呢？

答案是肯定的，这就是路径压缩，即当我们经过"递推"找到祖先节点后，"回溯"的时候顺便将它的子孙节点都直接指向祖先，这样以后再次Find_Set(x)时复杂度就变成O(1)了，如下图所示；可见，路径压缩方便了以后的查找。

这两种技术可以互补，可以应用到另一个上，每个操作的平均时间仅为$O(alpha(n))$，$alpha(n)$是n = f(x) = A(x,x)的反函数，并且A是急速增加的阿克曼函数。因为$alpha(n)$是其的反函数，$alpha(n)$对于可观的巨大n还是小于5。因此，平均运行时间是一个极小的常数。

2、Union(x,y)时 按秩合并

即合并的时候将元素少的集合合并到元素多的集合中，这样合并之后树的高度会相对较小。

有了背景知识，我们来看如何利用它来解决：

给一个整数数组， 找到其中包含最多连续数的子集，比如给：15, 7, 12, 6, 14, 13, 9, 11，则返回: 5:[11, 12, 13, 14, 15] 。最简单的方法是sort然后scan一遍，但是要o(nlgn)，有什么O(n)的方法吗？

首先，Make_Set(x)将每个元素变成一个并查集，然后扫描，Union(x-1, x)，Union(x, x+1)。

接下来的问题是怎么快速找到x-1,x+1的位置？那么需要引入查找为常数复杂度的哈希表。

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

const int MAX = 100;
int Father[MAX];
int Rank[MAX];

void MakeSet(int x){
    Father[x] = x;
    Rank[x] = 1;
}

int FindFather(int x){
    if(x != Father[x])
        Father[x] = FindFather(Father[x]);
    return Father[x];
}

void Union(int x, int y){
    int a = FindFather(x);
    int b = FindFather(y);
    if(a == b)
        return;
    else{
        int ar = Rank[a];
        int br = Rank[b];
        if(ar <= br){
            Father[a] = b;
            Rank[b] += Rank[a];
        }else{
            Father[b] = a;
            Rank[a] += Rank[b];
        }
    }
}

int main()
{
    const int length = 15;
    int arr[length] = {15, 7, 12, 6, 14, 13, 10, 11, 4, 5, 8, 3, 2, 16, 17};
    hash_map<int,int> ihmap;
    for(int i = 0; i < length; ++i)
    {
        MakeSet(i);
        ihmap[arr[i]]=i;
    }

    for(int i = 0; i < length; ++i)
    {
        hash_map<int,int>::iterator tmp;
        tmp = ihmap.find(arr[i]-1);
        if(tmp != ihmap.end())
        {
            Union(i,tmp->second);            
        }
        tmp = ihmap.find(arr[i]+1);
        if(tmp != ihmap.end())
        {
            Union(i,tmp->second);            
        }
    }
    int max = Rank[0];
    int father = 0;
    for(int i = 1; i< length; ++i)
        if(Rank[i]>max){
            max = Rank[i];
            father = i;
        }
    cout<<max<<endl;

    for(int i = 0; i< length; ++i)
        if(Father[i] == father)
            cout<<arr[i]<<' ';
    cout<<endl;

    return 0;
}

转自：http://blog.csdn.net/doc_sgl/article/details/11667301