http://poj.org/problem?id=3164

给出有向图下的点位置和单向边，求出图的最小生成树
不能用无向图算法，应该为朱-刘算法
算法步骤如下：
1.判断图的连通性，若不连通直接无解，否则一定有解。
2.为除了根节点以外的所有点选择一个权值最小的入边，假设用pre数组记录前驱，f数组记录选择的边长，记所选边权和为temp。
3.（可利用并查集）判断选择的的边是否构成环，若没有则直接ans+=temp并输出ans，若有，则进行下一步操作。
4.对该环实施缩点操作，设该环上有点V1，V2……Vi……Vn，缩成的点为node ，对于所有不在环中的点P进行如下更改：
（1） 点P到node的距离为min{a[p,Vi]-f[Vi]} (a为边集数组)
（2）点node到p的距离为min{a[Vi,p]}

#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <vector>
#include <string>
#include <cmath>
using namespace std;

const int maxn = 103;
const double inf = 1e100;
int n, m, vis[maxn], pre[maxn], inc[maxn];
double x[maxn], y[maxn], w[maxn][maxn];
double getdis(int u, int v) {
    return sqrt((x[u] - x[v]) * (x[u] - x[v]) + (y[u] - y[v]) * (y[u] - y[v]));
}
void dfs(int u) {
    vis[u] = 1;
    for(int i = 1; i <= n; i++) if(w[u][i] != inf && !vis[i]) 
        dfs(i);
}
int main()
{

    while(~scanf("%d%d", &n, &m)) {
        for(int i = 1; i <= n; i++) scanf("%lf%lf", &x[i], &y[i]);

        for(int i = 1; i <= n; ++i) 
            for(int j = i; j <= n; ++j) 
                w[i][j] = w[j][i] = inf;
        memset(vis, 0, sizeof(vis));

        for(int i = 0; i < m; i++) {
            int u, v;
            scanf("%d%d", &u, &v);
            w[u][v] = min(w[u][v], getdis(u, v));
        }

        dfs(1);
        bool flg = true;
        for(int i = 1; i <= n; i++) if(!vis[i]) flg = false;
        if(!flg) {
            puts("poor snoopy");
            continue;
        }

        double ans = 0;
        memset(vis, 0, sizeof(vis));
        memset(inc, 0, sizeof(inc));
        while(true) {
            for(int i = 2; i <= n; i++) if(!inc[i]){
                w[i][i] = inf, pre[i] = i;
                for(int j = 1; j <= n; j++) if(!inc[j] && w[j][i] < w[pre[i]][i]) {
                    pre[i] = j;
                }
            }

            int i;
            for(i = 2; i <= n; i++) if(!inc[i]) {
                int j = i, cnt = 0;
                while(j != 1 && cnt <= n && pre[j] != i) cnt++, j = pre[j];
                if(cnt > n || j == 1) continue;
                break;
            }

            if(i > n) {
                for(int j = 2; j <= n; j++) if(!inc[j]) ans += w[pre[j]][j];
                break;
            }
            memset(vis, 0, sizeof(vis));
            int j = i;
            do{ ans += w[pre[j]][j], j = pre[j], vis[j] = inc[j] = 1; }
            while(j != i);
            inc[i] = 0;

            for(int k = 1; k <= n; k++) if(vis[k]) {
                for(int j = 1; j <= n; j++) if(!vis[j]) {
                    if(w[i][j] > w[k][j]) w[i][j] = w[k][j];
                    if(w[j][k] < inf && w[j][k] - w[pre[k]][k] < w[j][i]) 
                        w[j][i] = w[j][k] - w[pre[k]][k];
                }
            }
        }
        printf("%.2f\n", ans);
    }
}

我们知道，无向图的最小生成树的求法有Krusal和prime算法，一个是归点一个是归边，在具体实现上Krusal可以用并查集实现，难度不大。

这里稍微区别一下最短路径和最小生成树（因为我又搞混了23333）
最小生成树能够保证首先是树（对于n个顶点的图只有n-1条边），其次保证任意两个顶点之间都可达，再次保证这棵树的边权值之和为最小，但不能保证任意两点之间是最短路径；
最短路径保证从源点S到目地点D的路径最小（有向图中不要求终点能到起点），不保证任意两个顶点都可达;
最小生成树是用最小代价遍历整个图中所有顶点，所有的权值和最小。而最短路径只是保证出发点到终点的路径和最小，不一定要经过所有顶点；
最小生成树是到一群点（所有点）的路径代价和最小，是一个n-1条边的树，最短路径是从一个点到另一个点的最短路径；
总之，最小生成树一定保证包含所有结点，而最短路径则不然。若题目要求必须每个点都必须经过，则是MST的问题；若只要求起点终点的最小消费，则是最短路径问题。

那么，对于有向图求最小生成树应该如何求呢？有向图就意味着可能有环，比如下面的图：

1、2结点形成一个环，应该删除哪一条边呢？如果从3出发，就会删掉2->1的边，如果从4出发，就会删掉1->2的边。那么如果把1、2合成一个点，所以3的权值更新为9-3=6，同理4的权值变为7-4 = 3。相当于变相删除不需要走的边。
有向图的最小生成树（最小树形图）求解步骤如下：

• 先求出最短弧集合E0；

对于节点1 = min{3,9},结点2 = min{4,7},结点4 = 1

• 如果E0不存在，则图的最小树形图也不存在；
• 如果E0存在且不具有环，则E0就是最小树形图；
• 如果E0存在但是存在有向环，则把这个环收缩成一个点u，形成新的图G1，然后对G1继续求其的最小树形图，直到求到图Gi，如果Gi不具有最小树形图，那么此图不存在最小树形图，如果Gi存在最小树形图，那么逐层展开，就得到了原图的最小树形图。

对于上面那张图，整个过程直观地看就是这样：



下面是一个更科学的流程图：

附上代码：

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
#define INF 0x7f7f7f7f
const int maxn = 105;
const int maxm = 100050;

int n, m;
int in[maxn];  //保存每个点的最小入权值
int pre[maxn];  //保存最小权值的父节点
int vis[maxn], id[maxn]; //vis是访问标识，id是重新分配的节点号
struct E{
    int from,to,dis;
}edge[maxm];

int dist_mst(int n,int m,int root){  //节点数、边数、根节点
    int ans = 0;
    while(1){
        for(int i = 0; i < n;++i)in[i] = INF;
        for(int i = 0; i < m;++i){
          int u = edge[i].from;
          int v = edge[i].to;
          //非根节点选出最小边，并记录父节点
          if(in[v] > edge[i].dis && u != v){
            in[v] = edge[i].dis;
            pre[v] = u;
            }
          }
          //若除了根节点外还有入度为0的结点，即孤立点，则没有最小生成树
          for(int i = 0; i < n;++i){
            if(i == root)continue;
            if(in[i] == INF)return -1;
          }
          memset(vis,-1,sizeof(vis));
          memset(id,-1,sizeof(id));
          int cnt = 0;
          in[root] = 0;
          for(int i = 0; i < n;++i){
            ans += in[i];
            int v = i;
            //每个不断向上搜寻父节点，要么找到根节点，要么找到自己，形成一个环
            //id[v] ！= -1意味着当前结点已经被重新分配过节点号了，即已经处理了自环
            while(vis[v] != i && id[v] == -1 && v != root){
                vis[v] = i;
                v = pre[v];
            }
            //vis[v] == i 即找到了自环，接下来进行缩点（在一个环内分配同一节点号）
            if(v != root && id[v] == -1){
                for(int u = pre[v];u != v;u = pre[u])id[u] = cnt;
                id[v] = cnt++;
            }
            }
            //没有使用cnt，说明已经没有环，结果已经保存在ans中
            if(cnt == 0)break;
            //为不在环中的分配节点号
            for(int i = 0; i < n;++i){
                if(id[i] == -1)id[i] = cnt++;
          }
          //更新边集节点号
          for(int i = 0; i < m;++i){
            int u = edge[i].from;
            int v = edge[i].to;
            edge[i].from = id[u];
            edge[i].to = id[v];
            if(id[u] != id[v])edge[i].dis -= in[v];
            //这里id[u] != id[v]说明  edges[i]这条边原来不在有向环中，
            //如果这条边指向了有向环，那么它的边权就要减少  in[v] 等价于整个环的边权减去in[v]
            //而如果没有指向有向环，说明它与这个有向环毫无关系，那么在之前的寻找自环缩点过程中已经把这条边的权值加上了，所以这里避免重复计算让这条边的权值减小in[v]变为0
          }
          n = cnt;
          root = id[root];
    }
    return ans;

}
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=0;i<m;i++){
        scanf("%d%d%d",&edge[i].from,&edge[i].to,&edge[i].dis);
        if(edge[i].from==edge[i].to)
            edge[i].dis=INF;
    }
    int res=dist_mst(n,m,0);
    if(res==-1)
        printf("No\n");
    else
        printf("%d\n",res);
    return 0;
}

一道例题：POJ3164 Command Network
这道题套模板，但是要注意把int改为double。(POJ判题真的很严格orz)
附上AC代码：

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
#define INF 0x3f3f3f3f
using namespace std;
const int maxn = 10001;
const int maxm = 100050;

int n, m;
double in[maxn];
int pre[maxn];
int vis[maxn], id[maxn];
struct E{
    int from,to;
    double dis;
}edge[maxm];
struct P{
    double x,y;
    double getDis(P p){
        return sqrt((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y));
    }
}point[maxn];
double dist_mst(int n,int m,int root){
    double ans = 0;
    while(1){
        for(int i = 0; i< n;++i)in[i] = INF;
        for(int i = 0; i < m;++i){
          int u = edge[i].from;
          int v = edge[i].to;
          if(in[v] > edge[i].dis && u != v){
            in[v] = edge[i].dis;
            pre[v] = u;
            }
          }
          for(int i = 0; i < n;++i){
            if(i == root)continue;
            if(in[i] == INF)return -1;
          }
          memset(vis,-1,sizeof(vis));
          memset(id,-1,sizeof(id));
          int cnt = 0;
          in[root] = 0;
          for(int i = 0; i < n;++i){
            ans += 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(int u = pre[v];u != v;u = pre[u])id[u] = cnt;
                id[v] = cnt++;
            }
            }

            if(cnt == 0)break;
            for(int i = 0; i < n;++i){
                if(id[i] == -1)id[i] = cnt++;
          }
          for(int i = 0; i < m;++i){
            int u = edge[i].from;
            int v = edge[i].to;
            edge[i].from = id[u];
            edge[i].to = id[v];
            if(id[u] != id[v])edge[i].dis -= in[v];
          }
          n = cnt;
          root = id[root];
    }
    return ans;

}
int main(){
    int n,m;
    while(~scanf("%d%d",&n,&m)){
    for(int i=0;i<n;i++){
        scanf("%lf%lf",&point[i].x,&point[i].y);
    }
    for(int i = 0; i < m;++i){
        int x,y;
        scanf("%d%d",&x,&y);
        edge[i].from = x-1;
        edge[i].to = y-1;
        if(edge[i].from != edge[i].to) edge[i].dis = point[x-1].getDis(point[y-1]);
        else edge[i].dis = INF;
    }
    double res=dist_mst(n,m,0);
    if(res==-1)
        printf("poor snoopy\n");
    else
        printf("%.2lf\n",res);
    }
    return 0;
}

  做了POJ的一道题，总是WA，不知道为什么，后来去看了，才知道，原来有向图的最小生成树与无向图不一样，它得是从某个点出发能遍历到其他所有点的才行，以此为条件，我们学习到了最小树形图。

  与很多其他人的讲解不一样吧，我把我看了博客后自己的思路分享出来，关于什么是最小树形图。

  我们知道的既然要建立最小树形图，就要理解什么是最小树形图，（概念好难懂啊，还是自己写的清楚明白），我们从某一点出发（或者是固定点），能通过它跑完所有点的最小花费，就是最小树形图了。

  那么，怎么去搭建最小树形图？会有人看到关于最小弧这样的讲法，诶！确实是这样的，但是你们理解什么是最小弧吗？我们想构建一颗最小生成树的时候，就是找到这样的最优解的边逐条放进去的（Kruskal算法思想），但是这也是一样的，我们找到所有非根节点的最小入边，先把这样的所有入边给加进来，那么得到的一幅图，可能还真是不完全，要是遇到了个环，岂不是有趣，或者呢，压根就走不完！不就GG？所以，就这样就被我们想出了两个需要判断的条件了。

  把所有的最小入边先加起来，我们得到了一个花里胡哨的图，可能它就是多个环的集合，也许恰好是答案，这都是不确定的，若是恰好是已经没有环了，那么这就是答案了；反之，就是有环，那么，我们得到的边，就不一定是所有的点构在一起的图（也许会成为森林这样的情况），那么，把环搜索起来吧，我们把一个环搜索成一个点，然后对于它（新点——即所谓的缩点）的入边，我们建立新边的时候，需要考虑到我们得删除原来在这幅图里的改点的入边（就是我们已经存入了这个原节点的入边了，但是，它却构成了环，说明不是我想要的解），所以，新边的权值就是原权值减去终点节点的最小入边。然后，节点数就会变少了，我们就可以继续在这样子优化下去了。直到上面说到的没有再构成环的时候，就说明是解了。

然后呢，我这挂一道Ice_cream’s world II HDU--2121的解题报告，带上完整的注释说明：

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
const int maxN = 1005;
int N, M;
ll sum;
struct Eddge    //存边
{
    int u, v;
    ll val;
    Eddge(int a=0, int b=0, ll c=0):u(a), v(b), val(c) {}
}edge[maxN*maxN];
int pre[maxN], id[maxN], vis[maxN], pos;
ll in[maxN];    //最小入边权，pre[]为其前面的点（该边的起点）
ll Dir_MST(int root, int V, int E)  //root是此时的根节点，我们最初的时候将0（万能节点作为根节点进入），V是点的个数（包括之后要收缩之后点的剩余个数），E是边的条数（不会改变）
{
    ll ans = 0;
    while(true)     //如果还是可行的话
    {
        for(int i=0; i<V; i++) in[i] = INF; //给予每个点进行初始化
        /* (1)、最短弧集合E0 */
        for(int i=1; i<=E; i++)     //通过这么多条单向边，确定的是每个点的指向边的最小权值
        {
            int u = edge[i].u, v = edge[i].v;
            if(edge[i].val < in[v] && u!=v)     //顶点v有更小的入边，记录下来    更新操作，u!=v是为了确保缩点之后，我们的环将会变成点的形式
            {
                pre[v] = u;     //节点u指向v
                in[v] = edge[i].val;    //最小入边
                if(u == root) pos = i;  //这个点就是实际的起点
            }
        }
        /* (2)、检查E0 */
        for(int i=0; i<V; i++)     //判断是否存在最小树形图
        {
            if(i == root) continue;     //是根节点，不管
            if(in[i] == INF) return -1;     //除了根节点以外，有点没有入边，则根本无法抵达它，说明是独立的点，一定不能构成树形图
        }
        /* (3)、收缩图中的有向环 */
        int cnt = 0;    //接下来要去求环，用以记录环的个数  找环开始！
        memset(id, -1, sizeof(id));
        memset(vis, -1, sizeof(vis));
        in[root] = 0;
        for(int i=0; i<V; i++)     //标记每个环
        {
            ans += in[i];   //加入每个点的入边（既然是最小入边，所以肯定符合最小树形图的思想）
            int v = i;  //v一开始先从第i个节点进去
            while(vis[v] != i && id[v] == -1 && v != root)  //退出的条件有“形成了一个环，即vis回归”、“到了一个环，此时就不要管了，因为那边已经建好环了”、“到了根节点，就是条链，不用管了”
            {
                vis[v] = i;
                v = pre[v];
            }
            if(v != root && id[v] == -1)    //如果v是root就说明是返回到了根节点，是条链，没环；又或者，它已经是进入了对应环的编号了，不需要再跑一趟了
            {
                for(int u=pre[v]; u!=v; u=pre[u])   //跑这一圈的环
                {
                    id[u] = cnt;    //标记点u是第几个环
                }
                id[v] = cnt++;  //如果再遇到，就是下个点了
            }
        }
        if(cnt == 0) return ans;    //无环的情况，就说明已经取到了最优解，直接返回，或者说是环已经收缩到没有环的情况了
        for(int i=0; i<V; i++) if(id[i] == -1) id[i] = cnt++;   //这些点是环外的点，是链上的点，单独再给他们赋值
        for(int i=1; i<=E; i++)     //准备开始建立新图  缩点，重新标记
        {
            int u = edge[i].u, v = edge[i].v;
            edge[i].u = id[u];  edge[i].v = id[v];  //建立新图，以新的点进入
            if(id[u] != id[v]) edge[i].val -= in[v];    //为了不改变原来的式子，使得展开后还是原来的式子
        }
        V = cnt;    //之后的点的数目
        root = id[root];    //新的根节点的序号，因为id[]的改变，所以根节点的序号也改变了
    }
    return ans;
}
int main()
{
    while(scanf("%d%d", &N, &M)!=EOF)
    {
        sum = 0;
        for(int i=1; i<=M; i++)
        {
            scanf("%d%d%lld", &edge[i].u, &edge[i].v, &edge[i].val);
            edge[i].u++;   edge[i].v++;   //把‘0’号节点空出来，用以做万能节点，留作之后用
            sum += edge[i].val;
        }
        sum++;  //一定要把sum给扩大，这就意味着，除去万能节点以外的点锁构成的图的权值和得在（sum-1）之内（包含）
        for(int i=M+1; i<=M+N; i++)     //这就是万能节点了，就是从0这号万能节点有通往所有其他节点的路，而我们最后的最小树形图就是从这个万能节点出发所能到达的整幅图
        {
            edge[i] = Eddge(0, i-M, sum);   //对于所有的N个其他节点都要建有向边
        }       //此时N+1为总的节点数目，M+N为总的边数
        ll ans = Dir_MST(0, N + 1, M+N);    //ans代表以超级节点0为根的最小树形图的总权值
        if(ans == -1 || ans - sum >= sum) printf("impossible\n");   //从万能节点的出度只能是1，所以最后的和必须是小于sum的，而万能节点的出度就由“ans - sum >= sum”保证
        else printf("%lld %d\n", ans - sum, pos - M - 1);   //pos-M得到的是1～N的情况，所以“-1”的目的就在于这里
        printf("\n");
    }
    return 0;
}