转：并查集总结 例题：hdoj 1232 畅通工程

引述之类的就免了，我们现在做题碰到的并查集基础题目大都是连通城市（或者村庄学校），接下来我们就称每一个城市为一个元素。我们解决此类题目运用的是树结构，每个集合用一棵树表示，而树的节点用于存储集合中的元素名。举个实例：有A，B，C，D这4个城市，我们用树结构连通的形式如下：

A

|

B

|

C

|

D

在这个树结构里面，A是根节点即没有父节点的节点，A是B的父节点，B是C的父节点，C是D的父节点，而且对于连通4个城市A，B，C，D的树结构来说它有且只有一个根节点（这也是判断城市是否全部连通的重要依据）。

并查集中有一个很重要的数组set[ ]，我们用它来储存当前元素的父节点，像上述例子我们可以这样表示set[B]=A，set[C]=B，set[D]=C。代表什么就不多说了，这个set[ ]要记在心里，后面要用到，当然在此之前我们要初始化set[ i ]  =  i，即set[A]=A，set[B]=B，set[C]=C=，set[D]=D  最后一步会用到！！。

并查集有二个要点：

（一）查：查找根节点（首先我们要知道若城市（我们还称其为元素）全部连通，总会有find(任何元素)=唯一的元素即根节点 成立）

我们用find( )函数实现，这里就需要上面的set[ ]了。具体代码如下：

（1）非递归路径压缩：只压缩当前节点

1. int find(int parent)
2. {
3. while(parent!=set[parent])
4. parent=set[parent];
5. return parent;
6. }

在这里我们通过find( )函数便可以得到如下的运行：

元素A              B                 C               D

find(A)=A；find(B)=A；find(C)=B；find(D)=C；

结束          find(A)=A；find(B)=A；find(C)=B；

结束    find(A)=A；find(B)=A；

结束     find(A)=A；

我们会发现在这个过程中，除了A之外，其它的都会啰嗦一些，明白地说，若是元素很多，将会很耗时。怎么改进呢？？？为什么不能就4次结束呢？

这样不行吗？find(A)=A；find(B)=A——>find(A)=A；find(C)=B——>find(B)=A——>find(A)=A；find(D)=C——>find(C)=B——>find(B)=A——>find(A)=A。

当然可以，这就是路径压缩：每个元素只需一次就可以找到根节点   ，就像下面的树结构一样。

A

/   |   \

B    C   D

代码实现：

（2）非递归路径压缩：压缩当前节点以及当前节点父节点并向上压缩直至到达根节点

1. int find(int parent)
2. {
3. int child=parent;
4. int t;
5. while(parent!=set[parent])
6. parent=set[parent];
7. //这里面关于变量间转换较多，一定要理解，不理解也要记好
8. //一直查找到child==parent
9. while(child!=parent)//不是根节点
10. {
11. t=set[child];//把当前元素的父节点用t记录下来
12. set[child]=parent;
13. child=t;//把t赋值给当前元素
14. }
15. return parent;
16. }

（3）递归路径压缩：

int find(int father)
{
	if(father==set[father])
	   return father;
	return father=find(set[father]);
}

　　

通过该过程，我们各需一次就可以得到下面运行：

A                B                C              D

find(A)=A    find(B)=A   find(C)=A   find(D)=A

（二）并：合并  这个过程中我们采用了merge来合并没有共同根节点的元素

首先我们已经知道若城市（我们还称其为元素）全部连通，总会有find(任何元素)=其中唯一的元素即根节点成立，相反的，若有两个元素x，y满足find(x)!=find(y)说明什么？当然是它们不在一棵树上（或者说它们中有一个城市还未连通），因为一棵树只有一个根节点不是吗？那么我们要怎么办？是啊，只需要把其中一个元素当作另一个元素的父节点就OK了。

代码实现：

1. void merge(int x,int y)
2. {
3. int fx=find(x);
4. int fy=find(y);
5. if(fx!=fy)
6. set[fx]=fy;
7. }

好好回味一下，再向下看！！！

整体思路说完了：

到了最关键的一步，还是上面A，B，C，D4个城市，我们在开始的时候已经初始化过了set[ i ] = i ，而且我们知道了一棵树中只有一个根节点，那么通过什么办法判断A，B，C，D是否在一棵树上呢？或者说全部连通了呢？

若遍历A，B，C，D若set[ i ] = i 的次数超过一次说明什么？此时，我们就可以认为该元素和其他元素不在一棵树上；相反则说明全部连通！！！

转自http://blog.csdn.net/chenzhenyu123456/article/details/43371209

畅通工程

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 34727    Accepted Submission(s): 18361

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

 

/*
题意：汉语题不用多解释
题解： 将给出的所有的路合并之后，判断现在总共有多少棵树
（判断方法：判断树根的个数，树根的个数就是树的个数），
树根的判断方法：如果当前节点的父节点等于自身，那么他就是根节点
*/
/*#include<stdio.h>  //hdu1232
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#define MAX 1010
#define INF 0x3f3f3f
using namespace std;
int city,road;
int set[MAX];
int find(int fa)//查找根节点
{
	int ch=fa;
	int t;
	while(set[fa]!=fa)
	    fa=set[fa];
	while(ch!=fa)
	{
		t=set[ch];
		set[ch]=fa;
		ch=t;
	}
	return fa;
}
int mix(int x,int y)//合并根节点
{
	int fx,fy;
	fx=find(x);
	fy=find(y);
	if(fx!=fy)
	set[fx]=fy;
}
int main()
{
	int i,j,k,t;
	while(scanf("%d",&city),city)
	{
		scanf("%d",&road);
		for(i=0;i<=city;i++)
		    set[i]=i;
		while(road--)
		{
			scanf("%d%d",&k,&t);
			mix(k,t);
		}
		int sum=0;
		for(i=1;i<=city;i++)//遍历查找根节点个数
		{
			if(set[i]==i)
			sum++;
		}
		printf("%d\n",sum-1);
		//sum棵数就需要修sum-1条路来连接
	}
	return 0;
}*/