最小生成树之Kruskal算法

最小生成树：

Kruskal算法描述：该算法是基于贪心的思想得到的。首先我们把所有的边按照权值先从小到大排列，接着按照顺序选取每条边，如果这条边的两个端点不属于同一集合，那么就将它们合并，直到所有的点都属于同一个集合为止。合并顶点可以利用并查集，换而言之，Kruskal算法就是基于并查集的贪心算法。

Kruskal算法流程：
1. 新建图G，G中拥有原图中相同的节点，但没有边；
2. 将原图中所有的边按权值从小到大排序；
3. 从权值最小的边开始，如果这条边连接的两个节点于图G中不在同一个连通分量中，则添加这条边到图G中；
4. 重复3，直至图G中所有的节点都在同一个连通分量中。

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1863
部分代码讲解：

//route compression
int findParent(int x) {
    int root = x;

    while (root != parent[root]) root = parent[root];
    while (root != x) {
        int temp = parent[x];

        parent[x] = root;
        x = temp;
    }
    return root;
}

findParent函数的作用不仅找出x的root节点，而且使x的所有祖先节点的parent都为root，这是并查集的一个路径压缩优化。

void Union(int x, int y) {
    int x_rank = Rank[x];
    int y_rank = Rank[y];

    if (x_rank < y_rank) {
        parent[x] = y;
    }
    else {
        parent[y] = x;
        if (x_rank == y_rank) {
            x_rank++;
        }
    }
}

Union函数的作用就是将两棵不同的树按照各自的rank(秩)合并，将秩小的合并到秩大的树上。

代码实现如下：

#include <iostream>
#include <vector>
#include <algorithm>
#define MAXN 100000
using namespace std;

struct Node
{
    int a, b, price;
};
int parent[MAXN], Rank[MAXN];

void init(int m) {
    for (int i = 1; i <= m; i++) {
        parent[i] = i;
        Rank[i] = 0;
    }
}

bool sort_by_price(const Node& a, const Node& b) {
    return a.price < b.price;
}

//route compression
int findParent(int x) {
    int root = x;

    while (root != parent[root]) root = parent[root];
    while (root != x) {
        int temp = parent[x];

        parent[x] = root;
        x = temp;
    }
    return root;
}

void Union(int x, int y) {
    int x_rank = Rank[x];
    int y_rank = Rank[y];

    if (x_rank < y_rank) {
        parent[x] = y;
    }
    else {
        parent[y] = x;
        if (x_rank == y_rank) {
            x_rank++;
        }
    }
}

int Kruskal(int n, int m, vector<Node> route) {
    int nEdge = 0, res = 0;

    for (int i = 0; i < n&&nEdge < m; i++) {
        int x = findParent(route[i].a);
        int y = findParent(route[i].b);

        if (x != y) {
            Union(x, y);
            nEdge++;
            res += route[i].price;
        }
    }
    if (nEdge != m-1) return -1;
    return res;
}

int main() {
    int n, m;

    while (cin >> n >> m) {
        int start, end, price, res;
        vector<Node> route;
        Node temp;

        if (n == 0) break;
        for (int i = 0; i < n; i++) {
            cin >> start >> end >> price;
            temp.a = start;
            temp.b = end;
            temp.price = price;
            route.push_back(temp);
        }
        init(m);
        sort(route.begin(), route.end(), sort_by_price);
        res = Kruskal(n, m, route);

        if (res == -1) cout << "?" << endl;
        else cout << res << endl;
    }
    return 0;
}