最小生成树

2018-02-19 23:48:26

现在看，以下内容乱七八糟，什么鬼玩意，大家别看了，现在没删是方便我自己回顾代码

题目：http://acm.hdu.edu.cn/showproblem.php?pid=1233

生成树：对于一个图G(V,E)，选一个点集为V，边集为E' ∈ E的子图称为生成树。

最小生成树：一个图的生成树有很多，里面权值和最小的生成树为最小生成树（仅有一个）。

求解方法有两个：Prim（普里姆）和Kruskal（克鲁斯卡尔）

Prim

复杂度：O(n^2)，所以适合稠密图（点少边多）。思想跟dijkstra基本一致，代码也基本一致。

假设我们要构造一棵生成树，那么选取一个到树的距离dis(u)最短的点u加到树上，则该树的权值和最小，然后更新所有跟点u相连且不在树上的点v。选取点u后，点v到树上的距离为dis[v] = min( dis[v] , map[u,v] )。然后重复这样选取更新n-1次（n-1个边即可连n个点）

#include <cstdio>
#include <string.h>
#include <iostream>
using namespace std;

const int maxn = 105;
const int inf = 0x3f3f3f3f;

int n, m;
int dis[maxn], mat[maxn][maxn], vis[maxn];
//dis[i]: i点到目标的最小生成树的距离
int prim(int src) {
    int ans = 0;
    for (int i = 1; i <= n; ++i) {
        dis[i] = mat[src][i];
        vis[i] = 0;
    }
    vis[src] = 1; 
    dis[src] = 0;
    //循环N-1次
    for (int i = 0; i < n - 1; ++i) {
        int tmp = inf, k; 
        for (int j = 1; j <= n; ++j) {
            if (!vis[j] && dis[j] < tmp) {
                tmp = dis[j];  //寻找未在树上的 距离最小的点
                k = j;
            }
        }
        ans += tmp;
        vis[k] = 1;
        for (int j = 1; j <= n; ++j) { //更新选中的点相邻点的距离 为 相邻点到当前点的距离，这个也是到树的距离
            if (!vis[j] && mat[k][j] < dis[j]) {
                dis[j] = mat[k][j] ;
            }
        }
    }
    return ans;
}

int main() {
    int a, b, c;
    while (cin >> n, n) {
        int m = n * (n - 1) / 2;
        memset(mat, inf, sizeof(mat));

        for (int i = 0; i < m; ++i) {
            cin >> a >> b >> c;
            mat[a][b] = mat[b][a] = c;
        }
        cout << prim(1) << endl;
    }
    return 0;
}

Kruskal

复杂度：O(elog₂v)，适合稀疏图（点多边少）。思想极其简单。

图中最短的那条边肯定在最小生成树上（废话），所以加到树上，那么剩下的图中最短的边还是肯定符合在最小树上的条件，就这样每次选最短的边即可。（须保证图联通才可直接使用）同时，选的边两点必须不在同一个联通分量里，用一个father数组区分，father[i]表示i号点所在的集合，如果father[i] = father[j]则表示在一个联通分量里。

#include <cstdio>
#include <string.h>
#include <iostream>
#include <algorithm>
#define rep( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define clr( a , x ) memset ( a , x , sizeof (a) );
using namespace std;

const int maxn = 105;
const int maxm = 105*100;  //无向边
const int inf = 0x3f3f3f3f;

int n,m;
int father[maxn];       

struct Edge{
    int u,v,w;
}edge[maxm];    

bool cmp(Edge a,Edge b){
    return a.w < b.w;
}

int kruskal(){
    int ans = 0;
    sort(edge,edge+m,cmp); //排序目的：当a点可以和b、c点组成集合时优先和成本低的组合 
    rep(i,0,m-1){
        int u = edge[i].u;
        int v = edge[i].v;
        int fu = father[u];
        int fv = father[v];
        if(fu != fv){
            ans += edge[i].w;
            rep(j,1,n){  //合并后把 以其中一个点为根的所有点集 father都更新为另外个点的父亲
                if(father[j] == fv){
                    father[j] = fu;
                }
            }
        }
    }
    return ans;
}

int main(){
    // freopen("1.in","r",stdin);
    while(cin>>n,n){
        m = n*(n-1)/2;
        rep(i,1,n){
            father[i] = i;
        }
        rep(i,0,m-1){
            cin >> edge[i].u >> edge[i].v >> edge[i].w;
        }
        cout<<kruskal()<<endl;
    }
    return 0;
}

上面

    int fu = father[u];
    int fv = father[v];
    if(fu != fv){
        ans += edge[i].w;
        rep(j,1,n){
            if(father[j] == fv){
                father[j] = fu;
            }
        }
    }

的fu,fv不能省略成

if(father[u] != father[v]){
    ans += edge[i].w;
    rep(j,1,n){
        if(father[j] == father[v]){
            father[j] = father[u];
        }
    }
}

会WA

并查集优化Kruskal

#include <cstdio>
#include <string.h>
#include <iostream>
#include <algorithm>
#define rep( i , a , b ) for ( int i = a ; i <= b ; ++ i )
#define clr( a , x ) memset ( a , x , sizeof (a) );
using namespace std;

const int maxn = 105;
const int maxm = 105*100;  //无向边
const int inf = 0x3f3f3f3f;

int n,m;
int f[maxn];       

struct Edge{
    int u,v,w;
}edge[maxm];    

bool cmp(Edge a,Edge b){
    return a.w < b.w;
}

int find(int x){
    if(x != f[x])
        f[x] = find(f[x]);
    return f[x];
}

void merge(int x,int y){
    int fx = find(x);
    int fy = find(y);
    if(fx != fy){
        f[fx] = fy;
    }
}

int kruskal(){
    int ans = 0;
    sort(edge,edge+m,cmp);
    rep(i,0,m-1){
        int u = edge[i].u;
        int v = edge[i].v;
        int fu = find(u);
        int fv = find(v);
        if(fu != fv){
            ans += edge[i].w;
            merge(u,v);
        }
    }
    return ans;
}

int main(){
    // freopen("1.in","r",stdin);
    while(cin>>n,n){
        m = n*(n-1)/2;
        rep(i,1,n){
            f[i] = i;
        }
        rep(i,0,m-1){
            cin >> edge[i].u >> edge[i].v >> edge[i].w;
        }
        cout<<kruskal()<<endl;
    }
    return 0;
}