《数据结构》08-图7 公路村村通

题目

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

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

分析

1. Kruskal 算法

#include<iostream>
#include<queue>
#include<vector> 
#define MaxVertex 1005
typedef int Vertex;
using namespace std;
int N;  // 顶点 
int M;  // 边 
int parent[MaxVertex];   // 并查集
struct Node{
    Vertex v1;
    Vertex v2;
    int weight;
    // 重载运算符 
    bool operator < (const Node &a) const
    {
        return weight>a.weight;
    }
}; 
priority_queue<Node> q;  // 最小堆 
vector<Node> MST; // 最小生成树 
int sum;
// 初始化图信息 
void build(){
    Vertex v1,v2;
    int w;
    cin>>N>>M;
    for(int i=1;i<=N;i++){
        parent[i] = -1;
    } 
    // 初始化点
    for(int i=0;i<M;i++){
        cin>>v1>>v2>>w;
        struct Node tmpE;
        tmpE.v1 = v1;
        tmpE.v2 = v2;
        tmpE.weight = w;
        q.push(tmpE); 
    }
    sum = 0;
}
//  路径压缩查找 
int Find(int x){
    if(parent[x] < 0)
        return x;
    else
        return parent[x] = Find(parent[x]);
} 
//  按秩归并 
void Union(int x1,int x2){
    x1 = Find(x1);
    x2 = Find(x2);
    if(parent[x1] < parent[x2]){
        parent[x1] += parent[x2];
        parent[x2] = x1;
    }else{
        parent[x2] += parent[x1];
        parent[x1] = x2;
    }
} 
void Kruskal(){
    while(MST.size()!=M-1 && !q.empty()){
        Node E = q.top();    // 最小堆，出队权重最小的 
        q.pop();   
        if(Find(E.v1) != Find(E.v2)){
     // 判断是否属于同一集合 
            sum += E.weight;
            Union(E.v1,E.v2);    // 并 
            MST.push_back(E);
        }
    }
}
int main(){
    build();
    Kruskal();
    // 图连通 
    if(MST.size()==N-1)
        cout<<sum;
    else 
        cout<<-1;
    return 0;
}

2. Prim 算法

#include<iostream>
#include<vector>
#define INF 100000
#define MaxVertex 1005
typedef int Vertex; 
int G[MaxVertex][MaxVertex];
int parent[MaxVertex];   // 并查集 
int dist[MaxVertex]; // 距离 
int Nv;    // 结点 
int Ne;    // 边 
int sum;  // 权重和 
using namespace std; 
vector<Vertex> MST;  // 最小生成树 
// 初始化图信息 
void build(){
    Vertex v1,v2;
    int w;
    cin>>Nv>>Ne;
    for(int i=1;i<=Nv;i++){
        for(int j=1;j<=Nv;j++)
            G[i][j] = 0;  // 初始化图 
        dist[i] = INF;   // 初始化距离
        parent[i] = -1;  // 初始化并查集 
    }
    // 初始化点
    for(int i=0;i<Ne;i++){
        cin>>v1>>v2>>w;
        G[v1][v2] = w;
        G[v2][v1] = w;
    }
}
// Prim算法前的初始化 
void IniPrim(Vertex s){
    dist[s] = 0;
    MST.push_back(s);
    for(Vertex i =1;i<=Nv;i++)
        if(G[s][i]){
            dist[i] = G[s][i];
            parent[i] = s;
        } 
}
// 查找未收录中dist最小的点 
Vertex FindMin(){
    int min = INF;
    Vertex xb = -1;
    for(Vertex i=1;i<=Nv;i++)
        if(dist[i] && dist[i] < min){
            min = dist[i];
            xb = i;
        }
    return xb;
}
void Prim(Vertex s){
    IniPrim(s);
    while(1){
        Vertex v = FindMin();
        if(v == -1)
            break;
        sum += dist[v];
        dist[v] = 0;
        MST.push_back(v);
        for(Vertex w=1;w<=Nv;w++)
            if(G[v][w] && dist[w])
                if(G[v][w] < dist[w]){
                    dist[w] = G[v][w];
                    parent[w] = v;
                }
    }
}
int main(){
    build();
    Prim(1);
    if(MST.size()==Nv)
        cout<<sum;
    else
        cout<<-1;
    return 0;
}