算法导论学习笔记（四）图论之最小生成树

最小生成树是指在一个连通图中，有一个边集，使得这个边集覆盖所有点，且边的权值最小，则这个边集称为最小生成树。
算法的核心思想是贪心。

---

Kruskal算法是将边按权值排序，然后每次取最小的边，看边连接的两个点是否在生成树中，如果都在，则舍弃这条边，否则加入这条边，并将不在生成树的点加入生成树中。当所有边执行后，所产生的边集就是最小生成树。

MST-KRUSKAL( G, w)
    A = EMPTY
    for each vertex v ∈ G.V
        MAKE-SET( v)
    sort the edges of G.E into nondecreasing order by weight w
    for each edge( u, v) ∈ G.E
        if FIND-SET( u) != FIND-SET( v)
            A = A U { ( u, v) }
            UNION( u, v)
    return A

---

Prim算法是将任意一个点选为根节点，然后每次选择离生成树最近的点，将其加入到生成树中，并更新与新加入的点相连的点与新生成树的最小距离。当所有点被加入到生成树中时，所选择的边集为最小生成树。

MST-PRIM( G, w, r)
    for each u G.V
        u.key = ∞
        u.father = NIL
    r:key = 0
    Q is a priority queue
    Q = G.V
    while Q != ∅
        u = EXTRACT-MIN( Q)
        for each v ∈ G.Adj[u]
            if v Q and w( u, v) < v.key
                v.father = u
                v.key = w( u, v)

代码实现

Kruskal算法

struct Node
{
    int u,v;
    int value;
    void setNode(int u,int v,int value){
        this->u = u;
        this->v = v;
        this->value = value;
    }
}p[110];
bool cmp(Node a,Node b) {
    if(a.value == b.value){
        if(a.u == b.u)
            return a.v<b.v;
        return a.u < b.u;
    }
    return a.value < b.value;
}
int father[110];
int findFather(int i) {
    if(father[i] == i)
        return i;
    return father[i] = findFather(father[i]);
}
void buildFather(int a,int b) {
    if(findFather(a) != findFather(b) )
        father[findFather(a)] = findFather(b);
}
int kruskal(int n,int m) {
    int sum = 0;
    for(int i=1;i<=n;i++)
        father[i] = i;
    sort(p,p+m,cmp);
    for(int i=0;i<m;i++){
        if(findFather(p[i].u)!=findFather(p[i].v)) {
            sum += p[i].value;
            buildFather(p[i].u,p[i].v);
        }
    }
    return sum;
}

Prim算法

const int INF = 0x3f3f3f3f;
struct Node
{
    int father;
    int key;
};
int g[110][110];
Node p[110];
bool flag[110];
int prim(int n,int m)
{
    for(int i=1;i<=n;i++){
        flag[i] = false;
        p[i].father = i;
        p[i].key = INF;
    }
    p[1].key = 0;
    int sum = 0;
    while(true){
        int u = 0;
        int key = INF;
        for(int i=1;i<=n;i++){
            if(key > p[i].key && !flag[i]) {
                key = p[i].key;
                u = i;
            }
        }
        if( u == 0)break;
        flag[u] = true;
        sum += p[u].key;
        for(int i=1;i<=n;i++){
            if( g[u][i]>0 && !flag[i] && p[i].key > g[u][i] ) {
                p[i].key = g[u][i];
                p[i].father = u;
            }
        }
    }
    return sum;
}