08-图7 公路村村通（浙大数据结构）

中国大学MOOC-陈越、何钦铭-数据结构-2022夏

08-图7 公路村村通

分数 30

作者 陈越

单位 浙江大学

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

输入格式:

输入数据包括城镇数目正整数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

 

Prim 算法求最小生成树：

/**
    Prim 算法求最小生成树：
*/

/**
#include <iostream>
#include <algorithm>

using namespace std;

const int maxn = 1010;
const int INF = 0x3fffffff;
int G[maxn][maxn]; //邻接矩阵
int d[maxn];  //顶点到“防护罩”的距离
bool hs[maxn];  //顶点是否已被访问

int Nv,Ne;

void Read(); //读入数据
int Prim(); //最小生成树，Prim算法

int main()
{
    fill(*G,*G+maxn*maxn,INF);
    Read();
    cout << Prim() << endl;
    return 0;
}

void Read() //读入数据
{
    cin >> Nv >> Ne;
    for(int i=0;i<Ne;++i)
    {
        int u,v,cost;
        cin >> u >> v >> cost;
        G[u][v] = G[v][u] = cost;
    }
}

int Prim() //最小生成树，Prim算法
{
    fill(d,d+maxn,INF);
    d[1]=0;

    int ans=0;
    for(int i=1;i<=Nv;++i)
    {
        int u=-1,MIN=INF;
        for(int j=1;j<=Nv;++j)
        {
            if(hs[j]==0 && d[j]<MIN)
            {
                u=j;
                MIN=d[j];
            }
        }

        if(u==-1)
            return -1;
        hs[u]=1;
        ans+=d[u];

        for(int v=1;v<=Nv;++v)
        {
            if(hs[v]==0 && G[u][v]!=INF && G[u][v] < d[v])
                d[v] = G[u][v];
        }
    }

    return ans;
}
*/

 2）Kruskal 算法求最小生成树;

/**
    2）Kruskal 算法求最小生成树;
*/

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

struct ENode
{
    int u,v;
    int cost;
};

const int maxn = 3010;
const int INF = 0x3fffffff;

ENode E[maxn];  //边图
int fath[maxn]; //存贮每个结点的根节点

int Nv,Ne;

bool cmp(ENode &a,ENode &b)
{
    return a.cost < b.cost;
}

void Read(); //读入数据
int FindFather(int x);
int Kruskal(); //最小生成树，Kruskal算法

int main()
{
    Read();
    cout << Kruskal() << endl;
    return 0;
}

void Read() //读入数据
{
    cin >> Nv >> Ne;
    ENode edge;
    for(int i=0;i<Ne;++i)
    {
        cin >> edge.u >> edge.v >> edge.cost;
        E[i] = edge;
    }
}

int FindFather(int x)
{
    if(fath[x]<0)
        return x;
    else
        return fath[x]=FindFather(fath[x]); //路径压缩
}

int Kruskal() //最小生成树，Kruskal算法
{
    memset(fath,-1,sizeof(fath));
    sort(E,E+Ne,cmp);
    int ans=0 ,Num_Edge=0; //ans存储最小生成树的顶点权值之和，Num_Edge 存储最小生成树的边数

    for(int i=0;i<Ne;++i)
    {
        int faU=FindFather(E[i].u);
        int faV=FindFather(E[i].v);
        if(faU!=faV)    //如果没有形成闭环，就可以加入最小生成树中
        {
            ans+=E[i].cost;
            fath[faU]=faV;
            ++Num_Edge;
            if(Num_Edge == Nv-1)
                break;
        }
    }

    if(Num_Edge != Nv-1)
        return -1;
    else
        return ans;
}