HDU 1102 Constructing Roads

题目：

Problem Description

There are N villages, which are numbered from 1 to N, and you should build some roads such that every two villages can connect to each other. We say two village A and B are connected, if and only if there is a road between A and B, or there exists a village C such that there is a road between A and C, and C and B are connected.

We know that there are already some roads between some villages and your job is the build some roads such that all the villages are connect and the length of all the roads built is minimum.

 

 

Input

The first line is an integer N (3 <= N <= 100), which is the number of villages. Then come N lines, the i-th of which contains N integers, and the j-th of these N integers is the distance (the distance should be an integer within [1, 1000]) between village i and village j.

Then there is an integer Q (0 <= Q <= N * (N + 1) / 2). Then come Q lines, each line contains two integers a and b (1 <= a < b <= N), which means the road between village a and village b has been built.

 

 

Output

You should output a line contains an integer, which is the length of all the roads to be built such that all the villages are connected, and this value is minimum.

 

 

Sample Input

3

0 990 692

990 0 179

692 179 0

1

1 2

Sample Output

179

 

---

题意：

•  求连通各村庄所需修路长度的最短长度

 

思路：

• 初始化成独立节点
• 将连通的村庄间的所需修道路长度置为0代表无需修路，不再计入总的维修长度
• 用结构体数组记录需要维修道路的两个村庄的编号及其间道路长度等信息，计算出结构体数组长度
• 对结构体数组中存储的道路长度从小到大排序，便于求最短的维修长度

 

代码：

#include <iostream>
#include <algorithm>
#define MAXN 101*50
using namespace std;

int pre[105];
int m[105][105];　　　//存储每两个村庄之间的距离
int n, q;
    
struct node{　　//结构体存储两个村庄结点信息即其间的距离
    int begin;
    int end;
    int len; 
}s[MAXN];

bool cmp(node a, node b)
{
    return a.len < b.len;
}

void init(int n)
{
    for(int i = 1; i <= n; i++)
    {
        pre[i] = i;
    }
    
}

int find(int x)
{
    while(x != pre[x])
        x = pre[x];
    
    return x;
}

int kruskal()
{
    int k = 0;
    for(int i = 1; i <= n; i++)　　
     {
        for(int j = 1; j <= n; j++)
        {
            if(i > j)　　//两村庄连通则可去可回，不重复记录
            {
                s[k].begin = i;
                s[k].end = j;
                s[k].len = m[i][j];
                k++;　　//记录需要连通的道路条数
            }
            
        }
    }
    int minlen = 0;
    sort(s, s + k, cmp);　　//按需要修的道路的长度从小到大排序
    for(int i = 0; i < k; i++)　　//判断两节点的根节点是否相同
    {
        int fx = find(s[i].begin);
        int fy = find(s[i].end);
        if(fx != fy)
        {
            pre[fx] = fy;　　//根节点不同则归并成同一结点并记入所需铺设的道路长度
            minlen += s[i].len;
        }
    } 
    return minlen;
 } 

int main()
{
    while(scanf("%d", &n) != EOF)
    {
        init(n);
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= n; j++)
              scanf("%d", &m[i][j]);
        }
        int x, y;    
        scanf("%d", &q);
        for(int i = 0; i < q; i++)    
        {
            scanf("%d %d", &x, &y);
            m[x][y] = m[y][x] = 0;　　//若两村庄已是连通的则无需修路，修路长度置为0
        }

        printf("%d\n", kruskal());
89     }
90     return 0;
}

 总结：

对于最小生成树求最短路径问题，要同时记录结点和边，并将边按从小到大的顺序进行排序，而后再判断两个带边的节点的根节点是否相同，若相同则已连通，不再计入，否则计入。