中国大学MOOC-数据结构基础习题集、06-3、公路村村通

题目链接：http://www.patest.cn/contests/mooc-ds/06-3

题目分析：典型最小生成树问题，且只需输出树各边的权值之和出来就可以了。博主这里用的是Prim算法。

特别说明：

　　1. 用邻接矩阵表示图比较容易。保存路径长度就可以了。因为强调了数组下标从1开始，因此在输入完n和m时，先执行一步n++，方便以后为数组申请空间。

　　2. 二维数组的动态申请及初始化，不推荐大家#define一个较大的数，然后直接int a[MAX][MAX]，这样做是十分不负责的，十分浪费空间。如果不会的同学，可以参见如下方法：

    // 用邻接矩阵存储图
    int **data = new int*[n];
    for(int i=0; i<n+1; i++)
    {
        data[i] = new int[n];
    }
    // 邻接矩阵初始化
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<n; j++)
        {
            data[i][j] = MAXNUM;
        }
    }

　　3. 求“尚未收集”的dist值最小的函数，参数是dist，collected标记是否被收集，及数组的长度n。注意数组下标从1开始：

int minDist(int dist[], bool collected[], int n)
{
    int mindist = MAXNUM;
    int icount = NOTEXIST;
    for(int i=1; i<n ; i++)
    {
        if(dist[i] < mindist && collected[i] == false)
        {
            icount = i;
            mindist = dist[i];
        }
    }
    return icount;
}

　　4. 用#define定义无穷大（100000000）和不存在（-1），避免程序中出现魔数，也方便修改。

#define MAXNUM 10000000
#define NOTEXIST -1

　　5. 可以用fill函数，对一个数组进行快速初始化，避免写for循环。方法如下：

fill(a, a+aLen, 100);    // 数组a长度为aLen，用100填满整个数组

代码分析：

　　普利姆算法：24~71（其中parent数组不设定也可以，这里并没有要求表示树的结构）

　　主函数：72~100（注意输入图的数据时，注意是图是无向图，也就是双向图）

#include <iostream>
#include <stack>

#define MAXNUM 10000000
#define NOTEXIST -1

using namespace std;

int minDist(int dist[], bool collected[], int n)
{
    int mindist = MAXNUM;
    int icount = NOTEXIST;
    for(int i=1; i<n ; i++)
    {
        if(dist[i] < mindist && collected[i] == false)
        {
            icount = i;
            mindist = dist[i];
        }
    }
    return icount;
}

int Prim(int *data[], int n, int m)
{
    // 集合: 用来存储收集到的结点
    stack<int> MST;
    MST.push(0);
    // dist: 记录长度
    int *dist = new int[n];
    fill(dist, dist+n, MAXNUM);
    dist[1] = 0;
    // collected: 标记是否被访问
    bool *collected = new bool[n];
    fill(collected, collected+n, false);
    // parent: 记录树的结构
    int *parent = new int[n];
    fill(parent, parent+n, NOTEXIST);
    // output: 最终结果
    int output = 0;
    while (1)
    {
        int V = minDist(dist, collected, n);
        if (V == NOTEXIST)
            break;
        MST.push(V);
        output += dist[V];
        dist[V] = 0;
        collected[V] = true;
        for(int W=1; W<n; W++)
        {
            if(data[V][W] != MAXNUM         // 如果W是V的邻接点
               && collected[W] == false     // 如果W没有被访问
               && data[V][W] < dist[W])
            {
                dist[W] = data[V][W];
                parent[W] = V;
            }
        }
    }
    if(MST.size() != n)
        return NOTEXIST;
    else
        return output;
}
/*
dist[V] = E(s,V)或 正无穷
parent[s] = -1（代表根结点）
T = O( |V|2 )
*/

int main()
{
    int n, m;
    cin >> n >> m;
    n++;
    // 用邻接矩阵存储图
    int **data = new int*[n];
    for(int i=0; i<n+1; i++)
    {
        data[i] = new int[n];
    }
    // 邻接矩阵初始化
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<n; j++)
        {
            data[i][j] = MAXNUM;
        }
    }
    for(int i=0; i<m; i++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        data[a][b] = c;
        data[b][a] = c;
    }
    cout << Prim(data, n, m) << endl;
    return 0;
}

AC成果：