最小生成树相关算法总结

最小生成树应该是我们相当熟悉的东西了。对于一个连通的无向图G，G中权值最小的生成树称为最小生成树。这是最小生成树的定义，在这片文章里我会把最近学到的关于最小生成树及其相关的算法做一个总结和分享吧， 并会把我整理的模版贴出来。

对于最基本的的最小生成树问题我们可以使用kruskal算法和prime算法（前者适用于稀疏图）在O(mlogm)与O(nlogn+m)时间内解决。关于这两种最基本的算法我就不在这里多说了。

一、最小瓶颈路问题

在最小生成树的实际应用中我们常常会遇到这一类问题，给你一张无向带权连通图和两个节点u,v让你求u,v之间的一条路径使得u->v路径上最大的边权最小值。这一类问题我们称之为最小瓶颈路问题。

对于这种问我们分两种讨论：

（1）单个询问

首先，我们从最简单的一个询问来说。我们很容易就能想到对于这一类问题我们可以先求出最小生成树然后在树上执行一次dfs然后就能求出答案了，我想这种应该是最简单的做发复杂度是O(mlogm)能够满足题目的需求。复杂度是不能优化了，但我们可不可以减少一下代码的长度呢，当然可以在这里我引用郭华阳在2007年发表的国家集训队论文里的算法。

首先我们看如下过程：

这几张ppt一看很清楚了吧。下面有一道基础的题目可以练一下uva 534：http://www.cnblogs.com/shu-xiaohao/p/3531626.html

 （2）多个询问

单个询问非常的简单但是对于多组询问上述解法就没有用武之地了。那这时候我们怎么处理呢？利用倍增法处理，下面列出算法步骤：

1.求出最小生成树

2.倍增法预处理出f数组f[i][j]表示j号结点2^i次方个父亲。

3.根据每个询问查询lca在过程中统计最大的边，即为答案。

对于这个算法我们要求不仅掌握最小生成树还需要会lca的倍增法。下面给出代码：

const int LEN = 100000+10;
const int LOG_LEN = 25;
struct edge{int from, to;ll val;};
vector<pil> Map[LEN];
edge e[LEN];
int n, m, fa[LEN], q, qa, qb, parent[LOG_LEN][LEN], depth[LEN];
ll dis[LOG_LEN][LEN];
bool cmp(edge a, edge b){return a.val<b.val;}
//UFSET
void init(){for(int i=0; i<LEN; i++)fa[i] = i;}
int Find(int a){return fa[a]==a?a:Find(fa[a]);}
void Union(int a, int b){int pa = Find(a), pb = Find(b);if(pa!=pb)fa[pa] = pb;}

//Use Kruskal to build MST
void Kruskal()
{
    sort(e, e+m, cmp);
    init();
    int cnt = 0;
    for(int i=0; i<m; i++){
        int a = e[i].from, b = e[i].to;
        ll v = e[i].val;
        if(Find(a) == Find(b))continue;
        Union(a, b);
        Map[a].PB(MP(b,v));
        Map[b].PB(MP(a,v));
        cnt++;
        if(cnt == n-1) return ;
    }
}

//LCA
void dfs(int v, int f, int d)
{
    parent[0][v] = f;
    dis[0][v] = -1;
    depth[v] = d;
    for(int i=0; i<Map[v].size(); i++){
        pil nv = Map[v][i];
        if(nv.first!=f) dfs(nv.first, v, d+1);
        else dis[0][v] = nv.second;
    }
}

void init_lca()
{
    memset(dis, 0, sizeof dis);
    memset(depth, -1, sizeof depth);
    for(int i=1; i<=n; i++)if(depth[i]<0)dfs(i, -1, 0);
    for(int k=0; k+1<LOG_LEN; k++){
        for(int i=1; i<=n; i++){
            if(parent[k][i]<0) parent[k+1][i] = dis[k+1][i] = -1;
            else {
                parent[k+1][i] = parent[k][parent[k][i]];
                dis[k+1][i] = max(dis[k][i], dis[k][parent[k][i]]);
            }
        }
    }
}

ll lca(int u, int v)
{
    if(depth[v] > depth[u]) swap(u, v);
    ll ret = 0;
    for(int i=0; i<LOG_LEN; i++){
        if((depth[u]-depth[v]) >> i & 1) {
            ret = max(ret, dis[i][u]);
            u = parent[i][u];
        }
    }
    if(u==v) return ret;
    for(int i=LOG_LEN-1; i>=0; i--){
        if(parent[i][u]!=parent[i][v]){
            ret = max(ret, dis[i][u]);
            ret = max(ret, dis[i][v]);
            u = parent[i][u];v = parent[i][v];
        }
    }
    ret = max(ret, dis[0][u]);
    ret = max(ret, dis[0][v]);
    return ret;
}

 

对于这个也有一道基础例题uva 11354：http://www.cnblogs.com/shu-xiaohao/p/3532800.html

二、次小生成树问题

另一类相关问题就是次小生成树了。题目的要求就是求出权值第二小的最小生成树的值（若最小有两种方案则值相等），对于次小生成树都有一种暴力做法就是枚举所有不在最小生成树中的边这个能求出答案但是复杂度太高往往无法承受，下面给出一种 O(n^2)算法。

1.求出最小生成树。

2.dfs出每个点对之间的最大边长。

3.枚举所有不在最小生成树上的边设(u,v),删除原来u,v之间最大边长，加上这条边的边长，更新答案。

怎么样简单吧。

给出代码：

const int LEN = 101;
int Map[LEN][LEN];
int n, m, top, fa[LEN], dis[LEN][LEN], tag[LEN*LEN], vis[LEN];
struct E{
    int u, v, val;
}edge[LEN*LEN];

bool cmp(E a, E b){return a.val < b.val;}
void init(){for(int i=0; i<LEN; i++) fa[i] = i;}
int Find(int x){return fa[x] == x ? x : fa[x] = Find(fa[x]);}

int kruskal(){
    int cnt = 0, ret = 0;
    init();
    memset(tag, 0, sizeof tag);
    sort(edge, edge+m, cmp);
    for(int i=0; i<m; i++){
        int pa = Find(edge[i].u), pb = Find(edge[i].v);
        if(pa == pb) continue;
        fa[pa] = pb;
        cnt ++;
        Map[edge[i].u][edge[i].v] = Map[edge[i].v][edge[i].u] = edge[i].val;
        tag[i] = 1;
        ret += edge[i].val;
        if(cnt == n-1) break;
    }
    return ret;
}

void dfs(int bg, int v, int val){
    vis[v] = 1;
    dis[bg][v] = val;
    for(int i=1; i<=n; i++){
        if(Map[v][i] != INF && vis[i] == 0) dfs(bg, i, max(val, Map[v][i]));
    }
}

int main()
{
        //input  
        int ans = kruskal();
        for(int i=1; i<=n; i++){
            memset(vis, 0, sizeof vis);
            dfs(i, i, 0);
        }
        for(int i=0; i<m; i++){
            if(tag[i])continue;
            //更新答案
        }
    }
    return 0;
}

这个问题也是给出一道基础例题 poj 1679:http://www.cnblogs.com/shu-xiaohao/p/3543195.html

好了差不多讲完了，其实还有最小树形图（zhuliu算法），最小限制生成树，k度最小生成树（参见2004汪汀国家队论文）。感觉这些都比较难等以后掌握好了在写总结吧。这里的算法大多十分简单。由于水平有限，若发现问题欢迎留言一定及时更正！