转:并查集总结 例题: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)非递归路径压缩:只压缩当前节点                    

[cpp] view plaincopy
 
  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)非递归路径压缩:压缩当前节点以及当前节点父节点并向上压缩直至到达根节点

[cpp] view plaincopy
 
  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了。

 

代码实现:

[cpp] view plaincopy
 
  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;
}*/

  

  

posted @ 2015-04-20 22:09  非我非非我  阅读(669)  评论(0编辑  收藏  举报