最小生成树算法

最小生成树有两种算法：Kruskal算法 和 Prim算法

算法一：Kruskal算法

基本思想就是：每次选择目前剩余的边中的权值最小的边，若将此边加入图中，不会形成环，则可以加入图中，否则舍弃。判断是否会形成环可以使用并查集算法。

以 HDU - 1879 题为例(题目链接：https://vjudge.net/problem/HDU-1879 )，代码如下：

#include <algorithm>
#include <queue>
#include <cstdio>
#include <iostream>
#include <cstring>
#include <map>
#include <cmath>
using namespace std;

const int maxn = 100 + 10;
int N, M;

int ans, f[maxn];

struct Node{
    int x, y, d;
    Node(int x=0,int y=0,int d=0):x(x),y(y),d(d){}
    bool operator < (const Node& t) const {
        return d < t.d;
    }
};
Node edge[maxn*maxn];

// 并查集
int find(int a) {
    return f[a] == a ? a : f[a]=find(f[a]);
}

void Kruskal(){
    for(int i = 1; i <= N; ++i) f[i] = i;

    //按照边的权值从小到大进行选取
    for(int i = 0; i < M; ++i){
        int u = find(edge[i].x);
        int v = find(edge[i].y);
        if(u != v){
            f[u] = v;
            ans += edge[i].d;
        }
    }
}

int main(){
    while(scanf("%d", &N) == 1 && N){
        M = N*(N-1)/2;
        for(int i = 0; i < M; ++i){
            int u, v;
            scanf("%d%d%d%d", &edge[i].x, &edge[i].y, &u, &v);
            if(v == 1) edge[i].d = 0;
            else edge[i].d = u;
        }
        sort(edge, edge+M);
        ans = 0;
        Kruskal();
        cout << ans << endl;
    }
    return 0;
}

这个算法是按照边来计算的，所以算法复杂度为O(eloge)，下面的Prim算法是依据结点来计算的，复杂度是O(n^2)

算法二：Prim算法

基本思想和Dijkstra算法思想有点类似，可以参考Dijkstra算法的思想，链接：https://www.cnblogs.com/DynastySun/p/9351584.html，代码如下：

#include <algorithm>
#include <queue>
#include <cstdio>
#include <iostream>
#include <cstring>
#include <map>
#include <cmath>
using namespace std;

const int INF = 0x3f3f3f3f;
const int maxn = 100 + 10;

int ans, N, M, G[maxn][maxn];

void Prim(){
    int start = 1;
    int flag[maxn], dis[maxn];
    memset(flag, 0, sizeof(flag));
    for(int i = 1; i <= N; ++i) {
        dis[i] = G[i][1];
        last[i] = start;
    }
    dis[start] = 0;
    flag[start] = 1;
    for(int i = 1; i < N; ++i){
        int MIN = INF;
        int k;
        for(int j = 1; j <= N; ++j)
            if(!flag[j] && MIN > dis[j]){
                MIN = dis[j];
                k = j;
            }

        flag[k] = 1;
        ans += MIN;

        for(int j = 1; j <= N; ++j)
            if(!flag[j] && dis[j] > G[j][k]) {
                dis[j] = G[k][j];
            }
    }
}

int main(){
    while(scanf("%d", &N) == 1 && N){
        memset(G, INF, sizeof(G));
        M = N*(N-1)/2;
        for(int i = 0; i < M; ++i){
            int a, b, c, d;
            scanf("%d%d%d%d", &a, &b, &c, &d);
            if(d == 1) G[a][b] = G[b][a] = 0;
            else G[a][b] = G[b][a] = c;
        }
        ans = 0;
        Prim();
        printf("%d
", ans);
    }
    return 0;
}