hdu1233 - 还是畅通工程 (求最小生成树)（Kruskal）

还是畅通工程

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

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年

                                没啥好说的，巩固复习了

/***********************************
*
*   acm:   hdu-1233
*
*	title: 还是畅通工程
*
*	time : 2014.8.14
*
***********************************/

//考察 最小生成树
//本题运用 Kruskal算法

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAXEDGE 4950
#define MAXVEX 100

typedef struct Edge
{
    int begin;
    int end;
    int weight;
} Edge;

void Swapn(Edge *edges, int i, int j)
{
    int temp;

    temp = edges[i].begin;
    edges[i].begin = edges[j].begin;
    edges[j].begin = temp;

    temp = edges[i].end;
    edges[i].end = edges[j].end;
    edges[j].end = temp;

    temp = edges[i].weight;
    edges[i].weight = edges[j].weight;
    edges[j].weight = temp;
}


void sort(Edge edges[], int length)
{
    int i;
    int j;
    int k;

    for (i = 0; i < length - 1; i++)
    {
        k = i;
        for (j = i + 1;  j < length; j++)
        {
            if (edges[k].weight > edges[j].weight)
            {
                k = j;
            }
        }

        if (k != i)
        {
            Swapn(edges, k, i);
        }
    }
}

int Find(int parent[], int f)
{
    int k = f;
    int temp;

    while (parent[f] >= 0)
    {
        f = parent[f];
    }

    while (k != f)
    {
        temp = parent[k];
        parent[k] = f;
        k = temp;
    }

    return f;
}


int MiniSpanTree_Kruskal(Edge edges[], int lenth)
{
    int n;
    int m;
    int i;
    int parent[MAXVEX];
    int temp;
    int num = 0;

    memset(parent, -1, sizeof(parent));

    for (i = 0; i < lenth; i++)
    {
        n = Find(parent, edges[i].begin);
        m = Find(parent, edges[i].end);

        if (n != m)
        {
            temp = parent[n] + parent[m];

            if (parent[n] > parent[m])
            {
                parent[n] = m;
                parent[m] = temp;
            }
            else
            {
                parent[m] = n;
                parent[n] = temp;
            }

            num += edges[i].weight;
        }
    }

    return num;
}

int main()
{
    int n;
    int i;
    int length;
    Edge edges[MAXEDGE];


    while (scanf("%d", &n), n)
    {
        length = 0;
        n = n * (n - 1) / 2;

        for (i = 0; i < n; i++)
        {
            scanf("%d%d%d", &edges[i].begin, &edges[i].end, &edges[i].weight);
            length++;
        }

        sort(edges, length);

        n = MiniSpanTree_Kruskal(edges, length);

        printf("%d\n", n);
    }

    return 0;
}