HDOJ 1875 HDU 1875 畅通工程再续 ACM 1875 IN HDU

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

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

畅通工程再续

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


Problem Description
相信大家都听说一个“百岛湖”的地方吧，百岛湖的居民生活在不同的小岛中，当他们想去其他的小岛时都要通过划小船来实现。现在政府决定大力发展百岛湖，发展首先要解决的问题当然是交通问题，政府决定实现百岛湖的全畅通！经过考察小组RPRush对百岛湖的情况充分了解后，决定在符合条件的小岛间建上桥，所谓符合条件，就是2个小岛之间的距离不能小于10米，也不能大于1000米。当然，为了节省资金，只要求实现任意2个小岛之间有路通即可。其中桥的价格为 100元 / 米。
 

Input
输入包括多组数据。输入首先包括一个整数T(T  <=   200 )，代表有T组数据。
每组数据首先是一个整数C(C  <=   100 ),代表小岛的个数，接下来是C组坐标，代表每个小岛的坐标，这些坐标都是  0   <=  x, y  <=  1000的整数。
 

Output
每组输入数据输出一行，代表建桥的最小花费，结果保留一位小数。如果无法实现工程以达到全部畅通，输出”oh ! ”.
 

Sample Input
2
2
10   10
20   20
3
1   1
2   2
1000   1000
 

Sample Output
1414.2
oh !

题目分析:

因为边没有直接给出, 而是给的坐标点, 所以需要先计算 每一个点到其他任意一点的距离, 并且记录下来.  如下 :
      for ( int i = 1; i <= N; ++ i )
           {
                 for ( int j = 1; j < i; ++ j )
                 {
                       edge[n].v1 = i;
                       edge[n].v2 = j;
                       edge[n].len = sqrt (  0.0 + POW (LD[i].x - LD[j].x) + POW ( LD[i].y - LD[j].y ) ); 
                       n ++;
                 }
           }
注意红色部分!!  这样做很安全, 不加的话, G++可以通过,但在C++上会出现编译问题, 哥悲剧了2次 CE   T .T.

将边记录好以后, 就是正宗的 最小生成树问题了.........直接KRUSKAL了. 这个我比较熟习, 呵呵.

代码如下:

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


#include  < iostream >
#include  < algorithm >
#include  < cmath >
#define  POW(x) ( (x) * (x) )
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;
                                               }
                                        }
               int  getTreeCount (){  int  nCount  =   0 ;  for  (  int  i  =   1 ; i  <  N;  ++  i ){
                                                          if  ( find (i)  ==  i ){
                                                              nCount  ++ ; 
                                                         }
                                                   }
                                    return  nCount;
                                 }
        private :
              Tset  * set ;
               bool   * visited;
               int  N;         
}treeUFS; 
struct  island{
        int  x,y;
}LD[ 105 ];
typedef  struct  edge{
        int  v1,v2;
        double  len;
}EDGE;
EDGE edge[ 5050 ];
bool  cmp ( EDGE A, EDGE B )
{
      return  A.len  <  B.len; 
}
int  main ()
{
     int  T;
    scanf (  " %d " , & T );
     while  ( T  --  )
    {
            int  N;
           scanf (  " %d " , & N );
           treeUFS UFS ( N );
            for  (  int  i  =   1 ; i  <=  N;  ++  i )
           {
                  int  x,y;
                 scanf (  " %d%d " , & LD[i].x, & LD[i].y );
           } 
            int  n  =   1 ;
            for  (  int  i  =   1 ; i  <=  N;  ++  i )
           {
                  for  (  int  j  =   1 ; j  <  i;  ++  j )
                 {
                       edge[n].v1  =  i;
                       edge[n].v2  =  j;
                       edge[n].len  =  sqrt (  0.0   +  POW (LD[i].x  -  LD[j].x)  +  POW ( LD[i].y  -  LD[j].y ) ); 
                       n  ++ ;
                 }
           }
            double  sum  =   0.0 ;
           n  =  N  *  ( N  -   1  )  /   2 ;
           sort ( edge  +   1 , edge  +  n  +   1  , cmp );
            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) )  &&  edge[i].len  >= 10   &&  edge[i].len  <=   1000  ) 
                 {
                        UFS.setVisit ( edge[i].v1, edge[i].v2 );
                        UFS.Merge ( edge[i].v1, edge[i].v2 );
                        sum  +=  edge[i].len; 
                 }
           }
            int  tCount  =  UFS.getTreeCount();
            if  ( tCount  !=   1  )
           {
                 puts (  " oh! "  );
                  continue ; 
           }
           printf (  " %.1lf\n " ,sum  *   100  );
    }
     return   0; 
}