并查集

并查集：一种树型的数据结构，用于处理一些不相交集合的合并及查询问题。

对于数组中的元素，我们如何表示元素a与元素b属于一个集合呢？比较容易想到的方法就是如果两个元素属于同一个集合，我们就将对应下标的数组中的值设为一个相同的标记来表示。为了区分不同的集合，每个集合的标记都应该是唯一的，一个比较好的方法就是取该标记为集合元素的最小值。我们看一下查找的过程，假设该数组为father[MAX]，为了查找元素a与元素b是否属于同一个集合，只需要看father[a]是否等于father[b]，常量时间的复杂度。那么合并两个集合呢？为了合并，首先还是要查找，比较father[a]与father[b]，假如father[a]<father[b]，就要把father[b]集合中所有元素的值都设为father[a],时间复杂度为O(n)。如果合并操作为m次，时间复杂度就为O(nm)，效率并不算高。

怎么改进呢？

上面的分析中，我们看到导致低效的一个重要原因在于合并操作，它需要修改另一个集合所有元素的标记。能不能做到只修改一次呢？这时容易想到合并两颗树的操作，如果采用树形结构上面的效率会不会提高呢？这时我们采用一棵树来表示一个集合，如果两个元素具有相同的树根，就认为它们属于同一个集合。如此以来，查找过程的平均复杂度就变为O(lgn)，比上面的方法反而下降了；但是合并操作的复杂度也降低到了O(lgn)。

分析

第二种方案对于合并操作较多的情况相比第一种方案可以明显降低时间复杂度。对于第二种方案也有比较糟糕的情况，就是当我们每次合并的时候，都把高度较大的树加到高度较小的树上，导致树的高度不断增大，这时查找操作的复杂度大大提高，接近于线性时间复杂度，那么其效率就会低于第一种方案。因此，可以考虑按秩合并。维护一个rank数组，表示树的高度，在合并时，把高度小的树合并到高度大的树上。另外一点，对于并查集，我们需要的最重要的信息还是元素是否属于同一个集合，至于树的结构并不重要，可以采用路径压缩进行优化，效率能得到明显的提高。

参考代码：

#define MAX 100005
int father[MAX];
void init(){
	int i = 0;
	for(i = 0;i < MAX;i++) father[i] = i;
}

int find(int x){
	return father[x] == x?x:(father[x] = find(father[x]));
}

void union(int a,int b){
	int ra = find(a);
	int rb = find(b);
	if(ra == rb) return;
	if(ra<rb) father[rb] = ra;
	else father[ra] = rb;
}

并查集并不难理解，下面主要通过一些题目，加深理解运用

HDU2545 树上战争

Time Limit: 10000/4000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 545    Accepted Submission(s): 292


Problem Description
给一棵树，如果树上的某个节点被某个人占据，则它的所有儿子都被占据，lxh和pfz初始时分别站在两个节点上，谁当前所在的点被另一个人占据，他就输了比赛，问谁能获胜
 
Input
输入包含多组数据
每组第一行包含两个数N，M（N，M<=100000），N表示树的节点数，M表示询问数，N=M=0表示输入结束。节点的编号为1到N。
接下来N-1行，每行2个整数A，B(1<=A,B<=N)，表示编号为A的节点是编号为B的节点的父亲
接下来M行，每行有2个数，表示lxh和pfz的初始位置的编号X，Y(1<=X,Y<=N,X!=Y)，lxh总是先移动

 
Output
对于每次询问，输出一行，输出获胜者的名字
 
Sample Input

2 1

1 2

1 2

5 2

1 2

1 3

3 4

3 5

4 2

4 5

0 0

Sample Output

lxh pfz lxh 提示： 本题输入、输出都很多，请使用scanf和printf代替cin、cout。

 
并查集水题：搜索到根结点的距离，比树要灵活。谁距离根结点越近，谁就获胜。相等的情况下，谁先走，谁获胜。

#include<iostream>
#include<cstdio>
using namespace std;
int father[100005];
int find(int x){
    int num = 0;
    while(x!=father[x]){
        x=father[x];
        num++;
    }
    return num;
}
int main(){
    int m,n;
    int son,fath;
    int lxh,pfz;
    while(scanf("%d%d",&n,&m)&&(m!=0&&n!=0)){
        int tmpN=n-1;
        while(tmpN--){
            scanf("%d%d",&fath,&son);
            father[son] = fath;
        }
        int tmpM = m;
        int lxhHeight,pfzHeight;
        while(tmpM--){
            scanf("%d%d",&lxh,&pfz);
            lxhHeight = find(lxh);
            pfzHeight = find(pfz);
            if(lxhHeight<=pfzHeight)
                printf("lxh\n");
            else
                printf("pfz\n");
        }
    }
    return 0;
}

HDU1272 小希的迷宫

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 27206    Accepted Submission(s): 8391

Problem Description

上次Gardon的迷宫城堡小希玩了很久（见Problem B），现在她也想设计一个迷宫让Gardon来走。但是她设计迷宫的思路不一样，首先她认为所有的通道都应该是双向连通的，就是说如果有一个通道连通了房间A和B，那么既可以通过它从房间A走到房间B，也可以通过它从房间B走到房间A，为了提高难度，小希希望任意两个房间有且仅有一条路径可以相通（除非走了回头路）。小希现在把她的设计图给你，让你帮忙判断她的设计图是否符合她的设计思路。比如下面的例子，前两个是符合条件的，但是最后一个却有两种方法从5到达8。

 

Input

输入包含多组数据，每组数据是一个以0 0结尾的整数对列表，表示了一条通道连接的两个房间的编号。房间的编号至少为1，且不超过100000。每两组数据之间有一个空行。
整个文件以两个-1结尾。

 

Output

对于输入的每一组数据，输出仅包括一行。如果该迷宫符合小希的思路，那么输出"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
No
   
   

并查集：只要满足所有的点都是连通的，并且没有环即可。通过判断只有一个根结点可以说明所有的点都是连通的。本来打算用set保存所有输入的结点，最后再判断set里所有的结点的根节点都一样，但是老是StackOverflow。通过增加一个标记数组配合father数组即可实现相同的功能。还要注意，输入为0 0的时候，输出Yes.

#include<stdio.h>
#include<string.h>
#define MAX 100005

int father[MAX];
void init(){
	for(int i=0;i<100000;i++){
		father[i]=i;
	}
}

int find(int x){
	if(x==father[x])
		return x;
	return father[x] = find(father[x]);
	/*
	int r=x;
	while(father[r]!=r)
		r=father[r];
	return r;
	*/
}

int main(){
	int m,n,used[100005],flag;
	while(scanf("%d%d",&m,&n)&&(m!=-1&&n!=-1)){
		if(m==0 && n==0){
			printf("Yes\n");
			continue;
		}
		init();
		flag=0;
		memset(used,0,sizeof(used));
		used[m]=used[n]=1;
		father[find(m)]=find(n);
		
		while(scanf("%d%d",&m,&n)&&(m!=0&&n!=0)){
			
			if(find(m)==find(n))
				flag=1;
			else{
				used[m]=used[n]=1;
				father[find(n)] = find(m);
			}
		}
		
		if(flag==1){
			printf("No\n");
			continue;
		}
		int cnt=0;
		for(int i=1;i<MAX;i++){
			if(used[i] && father[i]==i)
				cnt++;
		}
		if(cnt==1)
			printf("Yes\n");
		else
			printf("No\n");
	}
	return 0;
}

HDU1232 畅通工程

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 31466    Accepted Submission(s): 16566

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


    
    

     
     

      
      Hint
     
     
     
     Hint
    
    
    
     
Huge input, scanf is recommended.
   
   

 

把相互连通的城镇看做一个结点，n个互不连通的点需要n-1条边。

#include<stdio.h>
#include<iostream>
using namespace std;
#define MAX 1005

int father[MAX];
void init(){
	for(int i=0;i<MAX;i++)
		father[i]=i;
}
int find(int x){
	if(x==father[x])
		return x;
	return father[x] = find(father[x]);
}
void merge(int a,int b){
	int art = find(a);
	int brt = find(b);
	if(art!=brt)
		father[art] = brt;
}

int main(){
	int m,n;
	int a,b;
	while(scanf("%d",&m)&&m){
		init();
		scanf("%d",&n);
		while(n--){
			scanf("%d%d",&a,&b);
			merge(a,b);
		}
		int cnt=0;
		for(int i=1;i<=m;i++)
			if(father[i]==i)
				cnt++;
		printf("%d\n",cnt-1);
	}
	return 0;
}