HDOJ 1233 还是通畅工程

还是畅通工程

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 22993    Accepted Submission(s): 10224

Problem Description

某省调查乡村交通状况，得到的统计表中列出了任意两村庄间的距离。省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可），并要求铺设的公路总长度为最小。请计算最小的公路总长度。

 

Input

测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( < 100 )；随后的N(N-1)/2行对应村庄间的距离，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间的距离。为简单起见，村庄从1到N编号。
当N为0时，输入结束，该用例不被处理。

 

Output

对每个测试用例，在1行里输出最小的公路总长度。

 

Sample Input

  
  

   
   3
1 2 1
1 3 2
2 3 4
4
1 2 1
1 3 4
1 4 1
2 3 3
2 4 2
3 4 5
0
  
  

 

Sample Output

  
  

   
   3
5


   
   

    
    

     
     Hint
    
    
Hint
   
   
   
    
Huge input, scanf is recommended.
  
  

 

Source

浙大计算机研究生复试上机考试-2006年

 

Recommend

JGShining   |   We have carefully selected several similar problems for you:   1102  1875  1879  1301  1162 

/*
*project:HDOJ1233
*version:最小生成树（Kruskal算法）
*author:骨灰在飞扬
*Memory:412K
*Time:156MS
*note:
*date:2014/3/29
*/
#include <iostream>
#include <algorithm>
using namespace std;

const int MAX = 5000;
int n;
int parent[MAX], treeDeep[MAX];
struct Node
{
   int s;
   int e;
   int weight;
};
Node edge[MAX];

bool comp(const Node& a, const Node& b)
{
   return a.weight < b.weight;
}

void make_set()
{
   for(int i = 1; i <= n; i++)
   {
       parent[i] = i;
       treeDeep[i] = 0;
   }
}

int find_set(int x)
{
   if(x != parent[x])
       parent[x] = find_set(parent[x]);
   return parent[x];
}

void union_set(int x, int y)
{
   x = find_set(x);
   y = find_set(y);
   if(x == y)
       return;
   if(treeDeep[x] > treeDeep[y])
       parent[y] = x;
   else
   {
       parent[x] = y;
       if(treeDeep[x] == treeDeep[y])
           treeDeep[y]++;
   }
}

int main()
{
   //freopen("E:\\vcpp\\test.txt", "r", stdin);

   while(cin >> n , n)
   {
       make_set();
       int edges = n*(n-1)/2;
       for(int i = 1; i <= edges; i++)
       {
           scanf("%d %d %d", &edge[i].s, &edge[i].e, &edge[i].weight);
       }
       sort(edge+1, edge+edges+1, comp);

       int sum = 0;
       for(int i = 1; i <= edges; i++)
       {
           int x = find_set(edge[i].s);
           int y = find_set(edge[i].e);
           if( x == y )
               continue;
           union_set(x, y);
           sum += edge[i].weight;
       }
       cout << sum << endl;
   }
   return 0;
}

/*
*project:HDOJ1233
*version:最小生成树（Priml算法）
*author:骨灰在飞扬
*Memory:804K
*Time:156MS
*note:
*date:2014/3/29
*/
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

const int MAX = 5000;
const int INF = 0x7fffffff;
int n;

int dist[MAX], weight[MAX][MAX];

int main()
{
   //freopen("E:\\vcpp\\test.txt", "r", stdin);

   while(cin >> n , n)
   {
       int edges = n*(n-1)/2;
       // Initial
       for(int i = 1; i <= n; i++)
       {
           for(int j = 1; j <= n; j++)
           {
               weight[i][j] = MAX;
           }
       }
       memset(dist, 0, sizeof(dist));
       for(int i = 1; i <= edges; i++)
       {
           int t1, t2, t3;
           scanf("%d %d %d", &t1, &t2, &t3);
           weight[t1][t2] = t3;
           weight[t2][t1] = t3;
       }
       bool visit[MAX] = {false};

       vector<int> S;    // S是顶点V的一个非空子集，当S扩展到V时，算法结束
       S.push_back(1);
       visit[1] = true;

       int sum = 0;
       // 找出轻量级边
       int vertexEnd;
       while(S.size() < n)
       {
           // 更新dist[i]
           for(int i = 1; i <= n; i++)
           {
               if(visit[i])
                   continue;
               int mmin = INF;
               for(int j = 0; j < S.size(); j++)
               {
                   if(weight[i][S[j]] < mmin)
                   {
                       mmin = weight[i][S[j]];
                   }
               }
               dist[i] = mmin;
           }
           // 查找轻量级边
           int mmin = INF;
           for(int i = 1; i <= n; i++)
           {
               if(!visit[i] && dist[i] < mmin)
               {
                   mmin = dist[i];
                   vertexEnd = i;
               }
           }
           S.push_back(vertexEnd);
           visit[vertexEnd] = true;
           sum += mmin;
       }
       cout << sum << endl;
   }
   return 0;
}