并查集

定义
并查集是一种树型的数据结构，用于处理一些不相交集合（Disjoint Sets）的合并及查询问题。常常在使用中以森林来表示。集就是让每个元素构成一个单元素的集合，也就是按一定顺序将属于同一组的元素所在的集合合并。

主要操作
1.初始化
把每个点所在集合初始化为其自身。
通常来说，这个步骤在每次使用该数据结构时只需要执行一次，无论何种实现方式，时间复杂度均为O(N)。
2.查找
查找元素所在的集合，即根节点。
3.合并
将两个元素所在的集合合并为一个集合。
通常来说，合并之前，应先判断两个元素是否属于同一集合，这可用上面的“查找”操作实现。

方法（1）

// 查 O(1)
int find1(int x)
{
    return set[x];   //set[x]为初始化数组
}

//并 O(N)
void Merge1(int a,int b)
{
   int i=min(a,b);  //取最小的
   int j=max(a,b);  //取最大的
   for(k=1;k<=N;k++)
   {
      if(set[k]==j) 
         set[k]=i;  //最小的来并合
   }
}

缺点：对于合并操作，需要用for循环来搜索全部的元素，复杂，有待改进。

方法（2）:每个集合用一棵有根树来表示。

//查 最坏情况O(N)
int find2(int x)
{
   int r=x;
   while(set[r]!=r)
      r=set[r];    //寻根点
   return r;
}

//并 O(1)
void Merge2(int a,int b)
{
   if(a>b)
      set[a]=b;  //取最小的并
    else
      set[b]=a;
}

优化后的算法

//查 最坏情况O(logN)
int find2(int x)
{
   int r=x;
   while(set[r]!=r)
      r=set[r];    
   return r;
}

//并 O(1)
int Merge3(int a,int b)
{
   if(height(a)==height(b))
   {
      height(a)=height(a)+1;
      set[b]=a;
   }
   else if(height(a)<height(b))
      set[a]=b;
   else
      set[b]=a;
}

带路径压缩的查找算法

int find3(int x)
{
      int r = x;
      while (set[r] != r) //循环结束，则找到根节点
          r = set[r];       
      i = x;                 // r是最终的根节点
      while (i != r) //本循环修改查找路径中所有节点
      {   
          j = set[i];
         set[i] = r;
          i = j;
      }}

例题1：畅通工程
题目描述：
某省调查城镇交通状况，得到现有城镇道路统计表，表中列出了每条道路直接连通的城镇。省政府“畅通工程”的目标是使全省任何两个城镇间都可以实现交通（但不一定有直接的道路相连，只要互相间接通过道路可达即可）。问最少还需要建设多少条道路？
输入描述：
测试输入包含若干测试用例。每个测试用例的第1行给出两个正整数，分别是城镇数目N ( < 1000 )和道路数目M；随后的M行对应M条道路，每行给出一对正整数，分别是该条道路直接连通的两个城镇的编号。为简单起见，城镇从1到N编号。 注意:两个城市之间可以有多条道路相通,也就是说3 31 21 22 1这种输入也是合法的当N为0时，输入结束，该用例不被处理。
输出描述：
对每个测试用例，在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

参考代码

#include<iostream>
using namespace std;
int bin[1002];
int findx(int x)
{    int r=x;
    while(bin[r] !=r)
        r=bin[r];
    return r;
}
void merge(int x,int y)
{
    int fx,fy;
    fx = findx(x);
    fy = findx(y);
    if(fx != fy)
        bin[fx] = fy;
}


int main()
{   int n,m,i,x,y,count;
    while(cin>>n && n)
    {
        for(i=1;i<=n;i++)
            bin[i] = i;
        for(cin>>m;m>0;m--)
        {   cin>>x>>y;
            merge(x,y);
        }
        for(count=-1, i=1;i<=n;i++)
            if(bin[i] == i)
                count ++;
        cout<<count<<endl;
    }  
    return 0;
}

例题2：小希的迷宫
题目描述：
上次Gardon的迷宫城堡小希玩了很久（见Problem B），现在她也想设计一个迷宫让Gardon来走。但是她设计迷宫的思路不一样，首先她认为所有的通道都应该是双向连通的，就是说如果有一个通道连通了房间A和B，那么既可以通过它从房间A走到房间B，也可以通过它从房间B走到房间A，为了提高难度，小希希望任意两个房间有且仅有一条路径可以相通（除非走了回头路）。小希现在把她的设计图给你，让你帮忙判断她的设计图是否符合她的设计思路。比如下面的例子，前两个是符合条件的，但是最后一个却有两种方法从5到达8。
输入描述：
输入包含多组数据，每组数据是一个以0 0结尾的整数对列表，表示了一条通道连接的两个房间的编号。房间的编号至少为1，且不超过100000。每两组数据之间有一个空行。 整个文件以两个-1结尾。
输出描述：
对于输入的每一组数据，输出仅包括一行。如果该迷宫符合小希的思路，那么输出”Yes”，否则输出”No”。

Sample Input
6 8 5 3 5 2 6 4
5 6 0 0

8 1 7 3 6 2 8 9 7 5
7 4 7 8 7 6 0 0

3 8 6 8 6 4
5 3 5 6 5 2 0 0

-1 -1

Sample Output
Yes
Yes
N

参考代码：

#include <iostream>
#include<cstdlib>
struct node
{
   int parent;
   int weight;
};

node maze[100001];
int visit[100001];  //是集合中的元素都被标记

int findfather ( int i )
{
    while ( i != maze[i].parent )
          i = maze[i].parent;
    return i;
}
void merge ( int a, int b )
{
     if ( maze[a].weight == maze[b].weight )
     {
          maze[b].parent = a;
          maze[a].weight = b;
     }

     else if ( maze[a].weight > maze[b].weight )
          maze[b].parent = a;
     else
         maze[a].parent = b;
}
int main ()
{    
    int a, b, a1, b1, sign;
    while ( cin>>a>>b )
    {
          memset (visit , 0, sizeof (visit));
          int maxn = 0;
          int minn = 1000000;
      for ( int i = 1; i < 100001; i ++ )
          {
           maze[i].parent = i;
           maze[i].weight = 1;
          }
          if ( a == -1 && b == -1 )      break;
          if ( a == 0 && b == 0 )
          {      cout<<"Yes\n";        continue; }
          sign = 0;
          do {
              if ( a < minn )     minn = a; 
       if ( b < minn )     minn = b;
              if ( a > maxn )     maxn = a;
       if ( b > maxn )     maxn = b;
              visit[a] = visit[b] = 1;
              a1 = findfather (a);
              b1 = findfather (b);
              if ( a1 == b1 )   //节点同根
              {   sign=-1;  }
              else
                  merge (a1, b1);
              cin>>a>>b;
              if ( a== 0 && b == 0)  break;
          }while (1);
          if ( sign == -1 )
          {               cout<<"No\n";          }
      if ( sign == 0 )
          {
               for (int i = minn; i <= maxn; i ++)
               {
                   if ( visit[i] && maze[i].parent == i )
                   sign ++;
               }
               if (sign == 1)               cout<<"Yes\n";
               else               cout<<"No\n";
          }
    }
     return 0;
}