HDOJ 1879 HDU 1879 继续畅通工程 ACM 1879 IN HDU

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

题目地址:
         http://acm.hdu.edu.cn/showproblem.php?pid=1879
题目描述:

继续畅通工程

Time Limit:  2000 / 1000  MS (Java / Others)    Memory Limit:  32768 / 32768  K (Java / Others)
Total Submission(s):  4134     Accepted Submission(s):  1602


Problem Description
省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。现得到城镇道路统计表，表中列出了任意两城镇间修建道路的费用，以及该道路是否已经修通的状态。现请你编写程序，计算出全省畅通需要的最低成本。
 

Input
测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N (  1 <  N  <   100  )；随后的 N(N - 1 ) / 2  行对应村庄间道路的成本及修建状态，每行给4个正整数，分别是两个村庄的编号（从1编号到N），此两村庄间道路的成本，以及修建状态：1表示已建，0表示未建。

当N为0时输入结束。
 

Output
每个测试用例的输出占一行，输出全省畅通需要的最低成本。
 

Sample Input
3
1   2   1   0
1   3   2   0
2   3   4   0
3
1   2   1   0
1   3   2   0
2   3   4   1
3
1   2   1   0
1   3   2   1
2   3   4   1
0
 

Sample Output
3
1
0

题目分析:

这道题几乎是和  HDU1233 <---详情请点击.    
几乎一模一样, 唯一不同的是: 在一些村庄之间已经有路存在了!!!!
这很好办. 我们只需要在输入的时候把已经存在的路提前加入并查集就行了.
接下来的就 是 MST 了...........

代码如下:

MiYu原创, 转帖请注明 : 转载自 ______________白白の屋

#include  < iostream >
#include  < algorithm >
using   namespace  std;
typedef  struct  {
      int  parent;
      int  height;   
}Tset;  

typedef  struct  treeUFS{
        public :
              treeUFS( int  n  =   0 ):N(n + 1 ) {  set   =   new  Tset[N];
                                          visited  =   new   bool [N]; 
                                           for  (  int  i  =   0 ; i  !=  N;  ++  i) 
                                           set [i].parent  =  i, set [i].height  =   1 ,visited[i]  =   false ; 
                                        }
               ~ treeUFS(){ delete []  set ; };
               int  find (  int  x ){   int  r  =  x;   while  ( r  !=   set [r].parent ) r  =   set [r].parent;
                                    return  r;
                                }
               void  setVisit (  int  x,  int  y ) { visited[x]  =  visited[y]  =   true ; } 
               bool  getVisit (  int  x ) {  return  visited[x]; }
               void  Merge(  int  x, int  y ){  x  =  find ( x );  y  =  find ( y );  
                                            if  ( x  ==  y )  return ;
                                            if  (  set [x].height  ==   set [y].height ){
                                                 set [y].parent  =  x;
                                                 set [x].height  ++ ;
                                           }
                                            else   if  (  set [x].height  <   set [y].height ) {
                                                      set [x].parent  =  y;       
                                                   }
                                            else {    set [y].parent  =  x;
                                               }
                                        }
        private :
              Tset  * set ;
               bool   * visited;
               int  N;         
}treeUFS; 
typedef  struct  edge {
        int  v1,v2;
        int  wei; 
        int  isBuild;    
}EDGE;
EDGE edge[ 5005 ];
bool  cmp ( EDGE A, EDGE B )
{
      return  A.wei  <  B.wei; 
}
int  main ()
{
     int  N;
     while  ( scanf (  " %d " , & N ) , N )
    {
             int  n  =  N  *  ( N  -   1  )  /   2 ;     
             int  v1,v2,b;
            memset ( edge,  0  ,  sizeof  ( edge ) );
            treeUFS UFS ( N ); 
             for  (  int  i  =   1 ; i  <=  n;  ++  i ) 
            {
                  scanf (  " %d%d " ,  & edge[i].v1, & edge[i].v2 );
                  scanf (  " %d%d " ,  & edge[i].wei, & edge[i].isBuild );
                   if  ( edge[i].isBuild  ==   1  )
                  {
                       UFS.Merge ( edge[i].v1, edge[i].v2 );
                       UFS.setVisit ( edge[i].v1, edge[i].v2 );
                  }
            } 
            sort ( edge  +   1 , edge  +  n  +   1 , cmp );
             int  sum  =   0 ;
             for  (  int  i  =   1 ; i  <=  n;  ++  i )
            {
                   if  ( (  ! UFS.getVisit(edge[i].v1)  ||   ! UFS.getVisit(edge[i].v2) )  ||  UFS.find(edge[i].v1)  !=  UFS.find(edge[i].v2) )
                  {
                        UFS.setVisit ( edge[i].v1, edge[i].v2 );
                        UFS.Merge ( edge[i].v1, edge[i].v2 );
                        sum  +=  edge[i].wei;
                  }        
            }
            printf (  " %d\n " ,sum );
    }
     return   0 ; 
}