hdoj-1233-还是畅通工程

题目：hdoj-1233

题解：

本题是典型的最小生成树问题，给出的是无向图，这里使用的方法是Prim最小生成树算法。

Reference

Prim算法参照：最小生成树-Prim算法和Kruskal算法，讲的很详细了。

测试的时候可以参考这幅图：

算法介绍：

主要步骤(摘自上文链接)：

1).输入：一个加权连通图，其中顶点集合为V，边集合为E；

2).初始化：Vnew = {x}，其中x为集合V中的任一节点（起始点），Enew = {},为空；

3).重复下列操作，直到Vnew = V：

a.在集合E中选取权值最小的边<u, v>，其中u为集合Vnew中的元素，而v不在Vnew集合当中，并且v∈V（如果存在有多条满足前述条件即具有相同权值的边，则可任意选取其中之一）；

b.将v加入集合Vnew中，将<u, v>边加入集合Enew中；

4).输出：使用集合Vnew和Enew来描述所得到的最小生成树。

本题维护两个数组：

(1)Primgh二维数组，存储图。

(2)refer数组，判断一个节点是否在Vnew中。

用于存边的数组Enew在本题中不需要。

代码：

//
//  main.cpp
//  Prim_1233
//
//  Created by wasdns on 16/11/24.
//  Copyright © 2016年 wasdns. All rights reserved.
//
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <string.h>
#define maxn 10000005;
using namespace std;
int Primgh[10000][10000];                        //存储图
bool refer[10005];                               //判断是否在Enew中
/*
    用于初始化的函数
 */
void Initial(int n, int m)
{
    int i, j;
    for (i = 1; i <= n; i++)
    {
        refer[i] = false;
        for (j = 1; j <= n; j++)
        {
            if (i == j) {
                Primgh[i][j] = 0;
            }
            else Primgh[i][j] = maxn;
        }
    }
    int u, v, w;
    for (i = 1; i <= m; i++)
    {
        cin >> u >> v >> w;
        Primgh[u][v] = w;
        Primgh[v][u] = w;
    }
}
/*
    Prim算法，主体部分
 */
int Prim_Alg(int n, int m)
{
    Initial(n, m);
    int i, j, k;
    int ans = 0;
    //最小生成树的路径长度                 
    refer[1] = true;
    //选择点1出发        
    //最小生成树一共有n-1条边，因此需要寻找最短边n-1次，基于贪心
    for (i = 1; i <= n-1; i++)
    {
        int minlen = maxn;
        //minlen: 在Vnew中的节点所连接的边中，寻找cost最小的边
        int rcd = 1;
        //cost最小的边有两个节点，rcd记录其中的不属于Vnew的节点
        for (j = 1; j <= n; j++)
        {
            if (!refer[j]) continue;
            //遍历Vnew中的所有节点
            int len1 = maxn;
            //对于Vnew中的某个节点来说，所连接的最短的路径cost大小
            int rcd1 = 1;
            //对于Vnew中的某个节点来说，rcd记录的节点
            //贪心，寻找这个节点连接的cost最小的路径
            for (k = 1; k <= n; k++)
            {
                if (!refer[k])
                {
                    if (Primgh[j][k] < len1) {
                        len1 = Primgh[j][k];
                        rcd1 = k;
                    }
                }
            }
            if (len1 < minlen) {
                //判断贪心得到的路径是否是全局cost最短
                minlen = len1;
                rcd = rcd1;
            }
        }
        /*Debug：*/
        //char check = 'A'+rcd-1;
        //cout << "rcd: " << check << endl;
        //cout << "minlen: " << minlen << endl;
        refer[rcd] = true;
        //贪心求出cost最小的路径，rcd记录的节点入Vnew
        rcd = 1;
        //重置rcd
        ans += minlen;
    }
    return ans;
}
int main()
{
    int n, m;
    while (scanf("%d", &n) != EOF)
    {
        if (n == 0) break;
        m = n * (n-1) / 2;
        cout << Prim_Alg(n, m) << endl;
    }
    return 0;
}

2016/11/24