PTA 7-10 公路村村通 (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算法可以成为“加点法”，即每次迭代选择相连的最小代价边的对应的点，加入到最小生成树中。算法从某一个顶点s开始，逐渐长大覆盖整个连通网的所有顶点。如下图所示：

//Prim算法
#include<iostream>
#include<stdio.h>
#define MAXVEX 1005
#define MAXEDGE 3005
#define IFINITY 65535

using namespace std;
int G[MAXVEX][MAXVEX];
int N,M;//城镇数目和候选道路数目
int Prim()
{
    int NumVexes = 0;//初始化加入的节点数
    int MinLength = 0;
    int lowcost[MAXVEX];
    int start = 1;//从城镇1开始
    for(int i = 1;i < MAXVEX;i++)
        lowcost[i] = G[start][i];

    lowcost[start] = 0;
    NumVexes = 1;
    int min_cost;
    int k;
    for(int i = 1;i < N;i++)
    {
        min_cost = IFINITY;
        for(int j = 1;j < N+1;j++)
        {
            if(lowcost[j] != 0 && lowcost[j] < min_cost)
            {
                k = j;
                min_cost = lowcost[j];
            }
        }

        if(min_cost != IFINITY)
        {
            NumVexes++;
            MinLength += min_cost;
            lowcost[k] = 0;
            for(int j = 1;j < N+1;j++)
            {
                if(lowcost[j] != 0 && G[k][j] < lowcost[j])
                {
                    lowcost[j] = G[k][j];
                }
            }
        }
    }
    if(NumVexes == N)
        return MinLength;
    else
        return -1;

}

int main()
{
    cin >> N >> M;
    int b,e,w;
    for(int i = 0;i < MAXVEX;i++)
    {
        for(int j = 0;j < MAXVEX;j++)
        {
            G[i][j] = G[j][i] = IFINITY;
        }
    }
    for(int i = 0;i < M;i++)
    {
        cin >> b >> e >> w;
        G[b][e] = G[e][b] = w;
    }
    printf("%d",Prim());

    return 0;
}

这里的lowcost变量，即为每次更新顶点后所得的代价边数组，注意每次更新顶点后需将其对应的lowcost置为0以防止重复判断。

第二种方法：

克鲁斯卡尔（Kruskal）算法 ：

此算法可以称为“加边法”，初始最小生成树边数为0，每迭代一次就选择一条满足条件的最小代价边，加入到最小生成树的边集合里。 

//Kruskal算法
#include<iostream>
#include<stdio.h>
#define MAXVEX 1001
#define MAXEDGE 3001
using namespace std;
typedef struct {
	int b;
	int e;
	int weight;
}Edge;
Edge edge[MAXEDGE];
void sortEdge(Edge *edge, const int& M)
{
	Edge temp;
	for (int i = 0; i < M; i++)
	{
		for (int j = i + 1; j < M; j++)
		{
			if (edge[i].weight > edge[j].weight)
			{
				temp = edge[i];
				edge[i] = edge[j];
				edge[j] = temp;
			}
		}
	}

}
int find_parent(int *parent, int f)
{
	while (parent[f] > 0)
	{
		f = parent[f];
	}
	return f;
}

int Kruskal(Edge* edge, const int &N, const int &M)
{
	int parent[MAXVEX];
	int NumEdges = 0;//初始化选中的边数
	int MinLength = 0;//初始化最短路径长度
	for (int i = 1; i < N+1; i++)
	{//初始化数组为1
		parent[i] = 0;
	}
	for (int i = 0; i < M; i++)
	{
		int n = find_parent(parent, edge[i].b);
		int m = find_parent(parent, edge[i].e);
		if (NumEdges == N-1)
			break;
		if (n != m)
		{
			parent[n] = m;
			NumEdges++;
			MinLength += edge[i].weight;
		}

	}
	if (NumEdges == N-1)
		return MinLength;
	else
		return -1;

}

int main()
{
	int N, M;//城镇数目和候选道路数目
	cin >> N >> M;
	for (int i = 0; i < M; i++)
	{
		cin >> edge[i].b >> edge[i].e >> edge[i].weight;
	}
	sortEdge(edge, M);
	printf("%d", Kruskal(edge, N, M));
	return 0;
}

 注意：每次新加入边时，需注意不能出现回路。