zoukankan      html  css  js  c++  java
  • 转:并查集总结 例题: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
    ",sum-1);
    		//sum棵数就需要修sum-1条路来连接 
    	}
    	return 0;
    }*/
    

      

      

  • 相关阅读:
    对象数组输出学生信息
    对象数组实现添加和显示客户信息
    控制台输出模拟注册登录幸运抽奖
    对象数组和for循环遍历输出学生的信息
    控制台输出<迷你DVD管理>
    CF524B 题解
    优先队列的重载运算符
    [洛谷日报第19期]Codeforces游玩攻略(转)
    最短路(三种基础算法)
    P2032 扫描
  • 原文地址:https://www.cnblogs.com/tonghao/p/4442821.html
Copyright © 2011-2022 走看看