最小树形图——朱刘算法

一、相关定义

定义：设G = (V,E)是一个有向图，它具有下述性质：

1. G中不包含有向环；　
2. 存在一个顶点v_i，它不是任何弧的终点，而V中的其它顶点都恰好是唯一的一条弧的终点，则称 G是以v_i为根的树形图。

最小树形图就是有向图G = (V, E)中以v_i为根的树形图中权值和最小的那一个。

另一种说法：最小树形图，就是给有向带权图一个特殊的点root，求一棵以root为根节点的树使得该树的的总权值最小。

性质：最小树形图基于贪心和缩点的思想。

缩点：将几个点看成一个点，所有连到这几个点的边都视为连到收缩点,所有从这几个点连出的边都视为从收缩点连出

 

二、算法描述

【概述】

为了求一个图的最小树形图，①先求出最短弧集合E₀；②如果E₀不存在，则图的最小树形图也不存在；③如果E₀存在且不具有环，则E₀就是最小树形图；④如果E₀存在但是存在有向环，则把这个环收缩成一个点u，形成新的图G₁，然后对G₁继续求其的最小树形图，直到求到图G_i，如果G_i不具有最小树形图，那么此图不存在最小树形图，如果G_i存在最小树形图，那么逐层展开，就得到了原图的最小树形图。

【实现细节】

设根结点为v_0，

• （1）求最短弧集合E₀

　　从所有以v_i(i ≠ 0)为终点的弧中取一条最短的，若对于点i，没有入边，则不存在最小树形图，算法结束；如果能取，则得到由n个点和n-1条边组成的图G的一个子图G'，这个子图的权值一定是最小的，但是不一定是一棵树。

• （2）检查E₀

　　若E₀没有有向环且不包含收缩点,则计算结束，E₀就是图G以v₀为根的最小树形图；若E₀含有有向环，则转入步骤(3)；若E₀没有有向环,但是存在收缩点，转到步骤(4)。

• （3）收缩G中的有向环

　　把G中的环C收缩成点u，对于图G中两端都属于C的边就会被收缩掉，其他弧仍然保留，得到一个新的图G1，G₁中以收缩点为终点的弧的长度要变化。变化的规则是：设点v在环C中，且环中指向v的边的权值为w，点v'不在环C中，则对于G中的每一条边<v', v>，在G₁中有边<v', u>和其对应，且权值W_G1(<v', u>) = W_G(<v', v>) - w；对于图G中以环C中的点为起点的边<v', v>，在图G₁中有边<u, v'>，则W_G1(<u, v'>) = W_G(<v', v>)。有一点需要注意,在这里生成的图G₁可能存在重边。

　　对于图G和G_1：

　　①如果图G₁中没有以v₀为根的最小树形图，则图G也没有；

　　②如果G₁中有一v₀为根的最小树形图，则可按照步骤（4）的展开方法得到图G的最小树形图。

所以，应该对于图G₁代到(1)中反复求其最小树形图，直到G₁的最小树形图u求出。

• （4）展开收缩点

　　假设图G₁的最小树形图为T₁,那么T₁中所有的弧都属于图G的最小树形图T。将G₁的一个收缩点u展开成环C，从C中去掉与T₁具有相同终点的弧，其他弧都属于T。

【小结】

对最小树形图做个小小的总结：

1：清除自环，自环是不可能存在于任何最小树形图中的；

2：求出每个顶点的的最小入边；

3：判断该图是否存在最小树形图，由 1 可以判定，或者以图中顶点v作为根节点遍历该图就能判断是否存在最小树形图；

4：找环，之后建立新图，缩点后重新标记。

【图示——最小树形图构造流程】

 

解读：第一幅图为原始图G，首先对于图G求其最短弧集合E_0，即第二幅图G_1；然后检查E₀是满足条件，在这里，可以看到G₁具有两个环，那么把这两个环收缩，如第三幅图所示，U1、U2分别为收缩后的点，然后将对应的权值进行更新，起点是环中的点，终点是环外的点，则权值不变。反之，起点是环外的点，终点是环内的点，则权值应该减去E₀中指向环内点的权值，形成新的图，如第三幅图，对于其反复求最小树形图，直到不存在最小树形图，或者求得缩点后的图的最小树形图，然后展开就好了，如第六幅图。

如果只要求计算权值的话，则不需要展开，所有环中权值的和加上其他各个点与点之间，或者收缩点和点之间的权值就是总的权值。

 POJ 3164模板：

#include <iostream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <cstring>
#include <algorithm>
#include <string>
#include <set>
#include <ctime>
#include <queue>
#include <map>
#include <sstream>

#define CL(arr, val)    memset(arr, val, sizeof(arr))
#define REP(i, n)       for((i) = 0; (i) < (n); ++(i))
#define FOR(i, l, h)    for((i) = (l); (i) <= (h); ++(i))
#define FORD(i, h, l)   for((i) = (h); (i) >= (l); --(i))
#define L(x)    (x) << 1
#define R(x)    (x) << 1 | 1
#define MID(l, r)   (l + r) >> 1
#define Min(x, y)   x < y ? x : y
#define Max(x, y)   x < y ? y : x
#define E(x)    (1 << (x))

const double eps = 1e-6;
const double inf = ~0u>>1;
typedef long long LL;

using namespace std;

const int N = 110;
const int M = 10010;

struct node {
    double x, y;
} point[N];

struct edg {
    int u, v;
    double cost;
} E[M];

double In[N];
int ID[N];
int vis[N];
int pre[N];
int NV, NE;

double SQ(int u, int v) {
    return sqrt((point[u].x - point[v].x)*(point[u].x - point[v].x) +
                (point[u].y - point[v].y)*(point[u].y - point[v].y));
}

double Directed_MST(int root) {
    double ret = 0;
    int i, u, v;
    while(true) {
        REP(i, NV)   In[i] = inf;
        REP(i, NE) {    //找最小入边
            u = E[i].u;
            v = E[i].v;
            if(E[i].cost < In[v] && u != v) {
                In[v] = E[i].cost;
                pre[v] = u;
            }
        }
        REP(i, NV) {    //如果存在除root以外的孤立点，则不存在最小树形图
            if(i == root)   continue;
            //printf("%.3lf ", In[i]);
            if(In[i] == inf)    return -1;
        }

        int cnt = 0;
        CL(ID, -1);
        CL(vis, -1);
        In[root] = 0;

        REP(i, NV) {    //找环
            ret += In[i];
            int v = i;
            while(vis[v] != i && ID[v] == -1 && v != root) {
                vis[v] = i;
                v = pre[v];
            }
            if(v != root && ID[v] == -1) {  //重新标号
                for(u = pre[v]; u != v; u = pre[u]) {
                    ID[u] = cnt;
                }
                ID[v] = cnt++;
            }
        }
        if(cnt == 0)    break;
        REP(i, NV) {
            if(ID[i] == -1) ID[i] = cnt++;    //重新标号
        }
        REP(i, NE) {    //更新其他点到环的距离
            v = E[i].v;
            E[i].u = ID[E[i].u];
            E[i].v = ID[E[i].v];
            if(E[i].u != E[i].v) {
                E[i].cost -= In[v];
            }
        }
        NV = cnt;
        root = ID[root];
    }
    return ret;
}

int main() {
    ...
}

 

面说的是定根的情况，如果是不定根的情况我们可以虚拟一个根，让虚拟根到每个节点的距离为图上所有边的权值之和加一。这样找到最小树形图后再减掉所有边的权值之和加一就可以了。

比如HUD 2121

#include <iostream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <cstring>
#include <algorithm>
#include <string>
#include <set>
#include <ctime>
#include <queue>
#include <map>
#include <sstream>

#define CL(arr, val)    memset(arr, val, sizeof(arr))
#define REP(i, n)       for((i) = 0; (i) < (n); ++(i))
#define FOR(i, l, h)    for((i) = (l); (i) <= (h); ++(i))
#define FORD(i, h, l)   for((i) = (h); (i) >= (l); --(i))
#define L(x)    (x) << 1
#define R(x)    (x) << 1 | 1
#define MID(l, r)   (l + r) >> 1
#define Min(x, y)   x < y ? x : y
#define Max(x, y)   x < y ? y : x
#define E(x)    (1 << (x))

const int eps = 1e-6;
const int inf = ~0u>>1;
typedef long long LL;

using namespace std;

const int N = 1024;
const int M = N*N;

struct edg {
    int u, v;
    int cost;
} E[M];

int In[N];
int ID[N];
int vis[N];
int pre[N];
int NV, NE;
int Minroot;

int Directed_MST(int root) {
    int ret = 0;
    int i, u, v;
    while(true) {
        REP(i, NV)   In[i] = inf;
        REP(i, NE) {    //找最小入边
            u = E[i].u;
            v = E[i].v;
            if(E[i].cost < In[v] && u != v) {
                In[v] = E[i].cost;
                if(u == root)   Minroot = i;    //不能直接等于v，因为会缩边
                pre[v] = u;
            }
        }
        REP(i, NV) {    //如果存在除root以外的孤立点，则不存在最小树形图
            if(i == root)   continue;
            if(In[i] == inf)    return -1;
        }

        int cnt = 0;
        CL(ID, -1);
        CL(vis, -1);
        In[root] = 0;

        REP(i, NV) {    //找环
            ret += In[i];
            int v = i;
            while(vis[v] != i && ID[v] == -1 && v != root) {
                vis[v] = i;
                v = pre[v];
            }
            if(v != root && ID[v] == -1) {  //重新标号
                for(u = pre[v]; u != v; u = pre[u]) {
                    ID[u] = cnt;
                }
                ID[v] = cnt++;
            }
        }
        if(cnt == 0)    break;
        REP(i, NV) {
            if(ID[i] == -1) ID[i] = cnt++;    //重新标号
        }
        REP(i, NE) {    //更新其他点到环的距离
            v = E[i].v;
            E[i].u = ID[E[i].u];
            E[i].v = ID[E[i].v];
            if(E[i].u != E[i].v) {
                E[i].cost -= In[v];
            }
        }
        NV = cnt;
        root = ID[root];
    }
    return ret;
}

int main() {
    //freopen("data.in", "r", stdin);
    int i, l, x;
    while(~scanf("%d%d", &NV, &NE)) {
        l = 0; x = NE;
        REP(i, NE) {
            scanf("%d%d%d", &E[i].u, &E[i].v, &E[i].cost);
            l += E[i].cost;
        }
        l++;
        REP(i, NV) {
            E[NE].u = NV;
            E[NE].v = i;
            E[NE].cost = l;
            NE++;
        } NV++;
        int ans = Directed_MST(NV-1);
        if(ans == -1 || ans  >= 2*l)   puts("impossible");
        else    printf("%d %d\n", ans - l, Minroot - x);
        cout << endl;
    }
    return 0;
}

 转自：传送门