HDU 1233 还是畅通工程（最小生成树 Prim+Kruskal）

原题地址

http://acm.hdu.edu.cn/showproblem.php?pid=1233

题意：（最小生成树裸题）有N个村庄，给出村庄两两之间的距离，要求铺设公路，使得任何两个村庄间都可以实现互通（不一定有直接的公路相连，只要能间接通过公路可达即可），计算最小的公路总长度。

解题思路

上一题《HDU 1232 畅通工程》考察的是并查集的应用，这一题考察了比较重要的最小生成树算法。
最小生成树算法有两种：Prim算法和Kruskal算法，见最小生成树算法讲解。

简单总结这两种算法：

• Prim算法从顶点的角度出发，每次选择距离当前集合最近的节点加入，直到所有节点都加入。该算法的时间复杂度为O(n²)，与图中边数无关，该算法适合于稠密图。
• Kruskal算法从边的角度出发，每次总是选择权重最小的边加入，直到加入n-1条边为止。（如果加入一条边后出现回路，skip这条边）。该算法的时间主要取决于边数，它较适合于稀疏图。

AC代码

Prim算法：

由于这道题目给出了所有的边数，所以可以视为稠密图。
Prim算法复杂度O(n^2)，耗时296ms。

PS：Prim算法可以进行堆优化，详见Prim算法 和 堆优化的Prim算法。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 105, INF = 0x3f3f3f;

int n, map[maxn][maxn], dist[maxn]; //map[i][j]记录两顶点间距离，dist[j]记录j到V中顶点的最小值
bool visited[maxn]; //顶点是否访问过（加入了连通集）

void init() //初始化距离和访问情况
{
    for (int i = 1; i<=n; ++i)
        dist[i] = INF;
    memset(visited, false, sizeof(visited));
}

int prim() //Prim算法返回最小生成树权值之和
{
    int sum = 0;
    //以1为起点
    for (int i = 2; i<=n; ++i) //更新1到所有顶点的距离
        dist[i] = map[1][i];
    visited[1] = true;
    for (int road = 0; road < n-1; ++road) //最终会生成n-1条道路
    {
        int minn = INF, pos;
        for (int j = 1; j<=n; ++j) //寻找到连通集的最小边
        {
            if (!visited[j] && dist[j] < minn)
            {
                minn = dist[j];
                pos = j; //pos记录该顶点
            }
        }
        visited[pos] = true;
        sum += dist[pos]; //加入该顶点
        for (int j = 1; j<=n; ++j) //松弛
        {
            if (!visited[j] && map[pos][j] < dist[j]) //更新连通集外顶点的最小距离
                dist[j] = map[pos][j];
        }
    }
    return sum;
}


int main()
{
    ios::sync_with_stdio(false);
    while (cin >> n && n)
    {
        init(); //初始化
        int u, v, tmp, ans;
        for (int i = 0; i < n*(n-1)/2; ++i)
        {
            cin >> u >> v >> tmp;
            map[u][v] = map[v][u] = tmp; //顶点间距离赋值
        }
        ans = prim();
        cout << ans << endl;
    }
    return 0;
}

Kruskal算法（贪心+并查集）

Kruskal算法复杂度O(E*logE)，E为边数。
耗时：280ms（非递归并查集），327ms（递归并查集）

#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 105;

typedef struct node
{
    int pre, suc, w;
    bool operator < (const node & A) const
    {
        return w < A.w;
    }
}Edge; //每条边的起始、终止和权重

Edge edge[maxn*maxn/2]; //记录每条边
int pre[maxn] = {0}; //记录每个顶点的上级

void make_set(int n) //初始化并查集
{
    for (int i = 1; i <= n; ++i)
        pre[i] = i;
}

/*
int find(int x) //递归找x的根节点
{
    if(pre[x] == x)
        return x;
    return pre[x] = find(pre[x]); //包含路径压缩
}
*/

int find_root(int x) //非递归找x的根节点
{
    int r = x;
    while (pre[r] != r)
        r = pre[r];
    //路径压缩
    int i = x, j;
    while (i != r)
    {
        j = pre[i];
        pre[i] = r;
        i = j;
    }
    return r;
}

int kruskal(int n, int num) //n顶点数， num边数
{
    sort(edge, edge+num); //按权重升序,注意是边数
    make_set(n); //并查集初始化
    int fx, fy;
    int sum = 0;
    for (int i = 0; i < num; ++i)
    {
        fx = find_root(edge[i].pre);
        fy = find_root(edge[i].suc);
        if (fx != fy) //如果不连通
        {
            pre[fy] = fx;
            sum += edge[i].w; //将这条边加入
        }
    }
    return sum;
}

int main()
{
    ios::sync_with_stdio(false);
    int n, num, ans;
    while(cin >> n && n)
    {
        num = (n * (n-1)) / 2;
        for (int i = 0; i < num; ++i)
            cin >> edge[i].pre >> edge[i].suc >> edge[i].w;
        ans = kruskal(n, num);
        cout << ans << endl;
    }
    return 0;
}