《数据结构与算法分析：C语言描述》复习——第九章“图论”——Kruskal算法

2014.07.04 23:03

简介：

　　给定一个无向带权连通图（三个条件），选出n-1条边将这n个顶点连成一棵树，使得这棵树的权值之和最小。

描述：

　　本次使用Kruskal算法来解决这个问题。

　　如果有n个顶点的话，我们需要n-1条边来拼成一棵树。

　　Kruskal算法的基本思路，是每次拼上一条边，看看是否会造成一个环，如果会形成环则放弃这条边。

　　怎么保证拼成的那棵树权值最小呢？把所有边按权值由小到大排序。从小到大一个个试就可以了。

　　怎么确定加入一条边后是否会形成环呢？用并查集。对于一条无向图的边u-v，如果并查集中u和v对应的根节点相同，代表u、v已经连通了，这时再加入u-v就会形成一个环。

　　Kruskal算法可以说是学完并查集之后的第一个应用了。

　　由于需要对所有边进行排序，所以Kruskal算法的效率对于密集图（和恐惧症无关）肯定不那么好。

实现：

// My implementation for Prim's Algorithm, for minimum spanning tree problem.
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

const int INFINITY = 1000000000;

struct Edge {
    int x;
    int y;
    int cost;
    Edge(int _x = 0, int _y = 0, int _cost = 0): x(_x), y(_y), cost(_cost) {};
};

bool comparator(const Edge &e1, const Edge &e2) {
    return e1.cost < e2.cost;
}

int findRoot(vector<int> &dj, int x)
{
    int r, k;
    
    r = x;
    while (r != dj[r]) {
        r = dj[r];
    }
    
    // Path compression speeds up the disjoint set.
    k = x;
    while (x != r) {
        x = dj[x];
        dj[k] = r;
        k = x;
    }
    
    return r;
}

int kruskalsAlgorithm(const vector<vector<int> > &graph)
{
    // Kruskal's Algorithm for weighted undirected graph.
    int n;
    n = (int)graph.size();
    if (n < 2) {
        return 0;
    }
    
    // Disjoint set
    vector<int> dj;
    vector<Edge> edges;
    int rx, ry;
    int i, j;
    
    for (i = 0; i < n; ++i) {
        for (j = i + 1; j < n; ++j) {
            if (graph[i][j] == INFINITY) {
                continue;
            }
            edges.push_back(Edge(i, j, graph[i][j]));
        }
    }
    sort(edges.begin(), edges.end(), comparator);

    dj.resize(n);
    for (i = 0; i < n; ++i) {
        dj[i] = i;
    }
    
    int edge_count = n - 1;
    int min_cost = 0;
    int ec = (int)edges.size();
    for (i = 0; i < ec; ++i) {
        rx = findRoot(dj, edges[i].x);
        ry = findRoot(dj, edges[i].y);
        if (rx == ry) {
            continue;
        }
        dj[rx] = ry;
        findRoot(dj, edges[i].x);
        
        min_cost += edges[i].cost;
        --edge_count;
        if (edge_count == 0) {
            break;
        }
    }
    edges.clear();
    
    return min_cost;
}

int main()
{
    vector<vector<int> > graph;
    int n;
    int nk;
    int i, j;
    int tmp, tmp_dist;
    int min_cost;
    
    while (cin >> n && n > 0) {
        graph.resize(n);
        for (i = 0; i < n; ++i) {
            graph[i].resize(n, INFINITY);
        }
        
        for (i = 0; i < n; ++i) {
            cin >> nk;
            for (j = 0; j < nk; ++j) {
                cin >> tmp >> tmp_dist;
                graph[i][tmp] = graph[tmp][i] = tmp_dist;
            }
        }
        
        min_cost = kruskalsAlgorithm(graph);
        
        cout << "The weighted sum of minimum spanning tree is " << min_cost << "." << endl;
        
        for (i = 0; i < n; ++i) {
            graph[i].clear();
        }
        graph.clear();
    }
    
    return 0;
}