HDOJ HDU 1863 畅通工程 ACM 1863 IN HDU

HDU 1863 畅通工程题解

最新推荐文章于 2025-09-12 17:02:52 发布

转载最新推荐文章于 2025-09-12 17:02:52 发布 · 75 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/MiYu/archive/2010/08/18/1802675.html

文章标签：

#测试 #java #数据结构与算法

本文介绍了HDU 1863畅通工程项目的一道算法题，采用Kruskal算法解决最小生成树问题，实现全省任意两村庄间的公路交通，并附带详细的代码解释。

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

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

畅通工程

Time Limit: 1000 / 1000 MS (Java / Others) Memory Limit: 32768 / 32768 K (Java / Others)
Total Submission(s): 5783 Accepted Submission(s): 2128

Problem Description
省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可）。经过调查评估，得到的统计表中列出了有可能建设公路的若干条道路的成本。现请你编写程序，计算出全省畅通需要的最低成本。

Input
测试输入包含若干测试用例。每个测试用例的第1行给出评估的道路条数 N、村庄数目M ( < 100 )；随后的 N
行对应村庄间道路的成本，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间道路的成本（也是正整数）。为简单起见，村庄从1到M编号。当N为0时，全部输入结束，相应的结果不要输出。

Output
对每个测试用例，在1行里输出全省畅通需要的最低成本。若统计数据不足以保证畅通，则输出“ ? ”。

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

Sample Output
3
?

题目分析:

最小生成树的问题. ---> 用 prim 或者 kruskal 算法求解, 我是用的kruskal算法.

按边的值做非降序排列, 然后从小到大对每条边一次判断, 如果2个顶点未全部访问或者不在同一个集合,那么加上这条边.直到最后一条边.
最后判断一下图的连通性,如果不是连通的, 输出 ? , 否则输出已选则的边的总和.

做这个题的时候WA了6次, 一直找不到原因, 没办法的情况下,又把数据结构的书翻出来,把 kruskal
算法复习了一遍, 再次检查代码, 发现问题了, 算法的过程是一条边一条边的加入集合内, 我居然NC
的在输入的时候就全部加入集合了, 结构导致 kruskal 算法的断言没有起到作用. YM.

代码如下:

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 init () { for ( int i = 0 ; i != N; ++ i)
                              set [i].parent = i, set [i].height = 1 ,visited[i] = false ;  }
               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;
typedef struct edge {
        int v1;
        int v2;
        int wei;
}EDGE;
EDGE edge[ 10005 ];
bool cmp ( EDGE A, EDGE B )
{
      return A.wei < B.wei;
}
int main ()
{
     int N,M;
     while ( scanf ( " %d%d " , & N, & M ) , N )
    {
             int v1,v2;
             if ( M == 0 )
            {
                 puts ( " ? " );
                  continue ;
            }
            memset ( edge, 0 , sizeof ( edge ) );
            treeUFS UFS ( M );
             for ( int i = 1 ; i <= N; ++ i )
            {
                  scanf ( " %d%d " , & edge[i].v1, & edge[i].v2 );
                  scanf ( " %d " , & edge[i].wei );
            }
            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;
                  }
            }
             int tCount = UFS.getTreeCount();
             if ( tCount != 1 )
            {
                 puts ( " ? " );
                  continue ;
            }
            printf ( " %d\n " ,sum );
    }
     return 0 ;
}

转载于:https://www.cnblogs.com/MiYu/archive/2010/08/18/1802675.html