Kruskal算法

问题描述：求无向连通图G<V, E>最小生成树（MST）。（不知道什么是MST的见Prim算法中的算法依据一栏）

算法步骤：

本质是贪心。

①   将G中的n个顶点看成是n个独立的连通分量，可记为T<V,X>

②   每次找当前剩余的权值最小的边，若分属不同的连通分量，则将其加入T

③   重复②，直到所有点连通

算法实现：

①   取权值最小的边，可使用最小堆或快排。

②   判断是否属于同一连通分量，可基于树的父指针表示法中的并查集算法。并查集可以使用重量权衡合并规则和路径压缩进行优化。

算法补充：

并查集算法：把n个节点分到多个集合，快速查找属于哪个集合，快速合并两个集合的算法。

方法是使用森林，同一个集合的点在森林的同一棵树里，拥有同一个根节点。节点采用父指针表示法，即每个节点有指向父结点的指针，根节点无父节点。合并两个集合相当于合并两棵树，只要把一棵树的根节点改为另一棵的根节点即可。查集只要不断向上直到根节点，如果是根节点相同代表在同一个集合内。
并查集优化：

重量权衡合并规则：结点较少树的根结点指向结点较多树的根结点。

路径压缩：查找一个结点X的根结点时可以采用路径压缩。设根结点为R，则路径压缩把由X到R的路径上每个结点的父指针均设置为直接指向R。

算法复杂度：O(eloge) e为边数

 

例：POJ 1251 Jungle Roads

 

View Code 

#include <iostream>
#include <set>
using namespace std;

int n;
class Edge
{
public:
    int x, y, cost;
    Edge(int x_, int y_, int cost_): x(x_), y(y_), cost(cost_){};
    bool operator< (const Edge& e) const{    return cost < e.cost;}
};
multiset<Edge> edge;//sorted
class ParTree//Parent Tree;
{
private:
    int a[26];
    int size[26];
public:
    ParTree()
    {
        for (int i = 0; i < 26; i++)
        {
            a[i] = i;
            size[i] = 1;
        }
    }
    int Find(int i)//找到c所属根节点
    {
        if (i == a[i])
            return i;
        a[i] = Find(a[i]);//路径压缩
        return a[i];
    }
    void Union(int i, int j)
    {
        int p = Find(i);
        int q = Find(j);
        if (size[p] < size[q])//重量权衡，轻者并入重者
        {
            a[p] = q;
            size[q] += size[p];
        }
        else
        {
            a[q] = p;
            size[p] += size[q];
        }
    }
};

int Kruskal()
{
    ParTree* p = new ParTree;
    int totalCost = 0;
    int MstEdgeNum = 0;

    for (multiset<Edge>::iterator i = edge.begin(); i != edge.end(); i++)
    {
        if (p->Find(i->x) == p->Find(i->y))
            continue;
        p->Union(i->x, i->y);
        totalCost += i->cost;
        MstEdgeNum++;
        if (MstEdgeNum == n-1)//MST has n-1 edges
            return totalCost;
    }
    return -1;
}
int main(void)
{
    char c1,c2;
    int t, len;
    while (cin >> n, n)
    {
        edge.clear();
        for (int i = 0; i < n-1; i++)
        {
            cin >> c1;
            cin >> t;
            for (int j = 0; j < t; j++)
            {
                cin >> c2;
                cin >> len;
                edge.insert(Edge(int(c1-'A'), int(c2-'A'), len));
            }
        }
        cout << Kruskal() << endl;
    }
    //system("pause");
    return 0;
}