​

活动地址：CSDN21天学习挑战赛
学习的最大理由是想摆脱平庸，早一天就多一份人生的精彩；迟一天就多一天平庸的困扰。

题目描述

现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。

输入格式:

输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到N编号。

输出格式:

输出村村通需要的最低成本。如果输入数据不足以保证畅通，则输出−1，表示需要建设更多公路。

输入样例:

6 15
1 2 5
1 3 3
1 4 7
1 5 4
1 6 2
2 3 4
2 4 6
2 5 2
2 6 6
3 4 6
3 5 1
3 6 1
4 5 10
4 6 8
5 6 3

输出样例:

12

说明

代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB
题目来源PTA：https://pintia.cn/problem-sets/15/problems/718

解题代码

#include
#define INF 100005

int prim(int n,int road[][1005])
{

    int dist[n+1];
    int flag[n+1];
    memset(flag,0,sizeof(flag));
    memset(dist,INF,sizeof(dist));
    for(int i=1;i<=n;i++){
        dist[i]=road[1][i];
    }
    flag[1]=1;
    dist[1]=0;
    for(int i=1;i<n;i++){
        int k;
        int minNum=INF;
        for(int j=1;j<=n;j++){
            if(dist[j]<minNum&&!flag[j]){
                k=j;
                minNum=dist[j];
            }
        }
        flag[k]=1;
        for(int j=1;j<=n;j++){
            if(!flag[j]&&road[k][j]<dist[j]){
                dist[j]=road[k][j];
            }
        }
    }
    int ans=0;
    for(int i=1;i<=n;i++){
        if(dist[i]==INF){
            return -1;
        }
        ans+=dist[i];
    }
    return ans;
}

int main()
{
    int n,m;
    int v,u,cost;
    int road[1005][1005];
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                road[i][j]=INF;
            }
        }
        for(int i=1;i<=m;i++){
            scanf("%d%d%d",&v,&u,&cost);
            road[v][u]=cost;
            road[u][v]=cost;
        }
        int min=prim(n,road);
        printf("%d",min);
        
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

解题思路

这道题我刚开始想着dijkstra也能做，但是忽略了dijkstra算法是针对源点到某一点的距离，而prim算法是针对某一点到生成树的最短距离，这样就会有偏差，虽然两个算法很相似，但是还是有不同，例如下面这个。

此时如果按照dijkstra算法去找，他会找长度为7的边，因为它是找与源点的最短距离（假设源点是0），而Prim算法是找此时与生成树最短距离的点，选择的是长度为1的边。这样子最终得到的结果就不同了。
用dijkstra算法做上面那道题，样例出来的结果永远是21，而Prim算法就能做对，就是这个原因。