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; 
}