最小树形图*

最小生成树、次小生成树是基于无向图的，而最小树形图是基于有向图的。

最小树形图：以固定一点为根生成的树的所有边权和最小称为最小树形图。

1、找到除了root以为其他点的权值最小的入边。用In[i]记录

2、如果出现除了root以为存在其他孤立的点，则不存在最小树形图。

3、找到图中所有的环，并对环进行缩点，重新编号。
4、更新其他点到环上的点的距离，如：

环中的点有（Vk1，Vk2，… ，Vki）总共i个，用缩成的点叫Vk替代，则在压缩后的图中，其他所有不在环中点v到Vk的距离定义如下：
gh[v][Vk]=min { gh[v][Vkj] - in[Vkj] } (1<=j<=i)  //我们已经知道 in[Vkj] 是环中的边

而Vk到v的距离为
gh[Vk][v]=min { gh[Vkj][v] }              (1<=j<=i)

5、重复3，4直到没有环为止。

 

kuangbin模板代码，没有计算路径，只是计算了最小权值：

int zhuliu(int root,int n,int m,Edge edge[])
{
    int res = 0,u,v;
    while(1)
    {
        for(int i = 0; i < n; i++)   in[i] = INF;
        for(int i = 0; i < m; i++)

            //（1）为除根以外的每个点选定一条入边，这条入边一定要是所有入边中最小的。

            //可以认为每个点选了一个父亲
            if(edge[i].u != edge[i].v && edge[i].cost < in[edge[i].v])
            {
                pre[edge[i].v] = edge[i].u;
                in[edge[i].v] = edge[i].cost;
            }

 

        //（2）如果存在点没有入边，那么一定不存在最小树形图，退出算法
        for(int i = 0; i < n; i++)
            if(i != root && in[i] == INF)
                return -1;//不存在最小树形图
        int tn = 0;
        memset(id,-1,sizeof(id));
        memset(visit,-1,sizeof(visit));
        in[root] = 0;
        for(int i = 0; i < n; i++)
        {
            res += in[i]; //加上这条边的权值
            v = i;
            while( visit[v] != i && id[v] == -1 && v != root)
            {
                visit[v] = i; //点 i 的祖先的 visit 值都设为 i
                v = pre[v];
            }
            if( v != root&& id[v] == -1 ) // 说明 visit[v] == i  ，说明找到了环 
            {
                for(int u = pre[v]; u != v ; u = pre[u]) //（3）收缩环中的点：遍历环中的点，更新他们的 id ,id 是他们收缩后的编号
                    id[u] = tn;
                id[v] = tn++;
            }
        }
        if(tn == 0) break;//没有有向环，成功找到最小树形图，算法结束
        for(int i = 0; i < n; i++)  //对剩下的所有点进行 id 标记(上面已经对所有环中的点进行了标记，在同一环中都具有相同 id 值)
            if(id[i] == -1)
                id[i] = tn++;
        for(int i = 0; i < m;)
        {
            v = edge[i].v;

            //（4）将边两端指向对应点的 id 编号
            edge[i].u = id[edge[i].u];
            edge[i].v = id[edge[i].v];
            if(edge[i].u != edge[i].v)  //（4）如果两端点指向不同 id 编号，该边的权值减去 v 的入边权值
                edge[i++].cost -= in[v];
            else
                swap(edge[i],edge[--m]);  //（4）如果两端点指向相同的 id 编号，删除该边 
        }
        n = tn;
        root = id[root];
    }
    return res;
}

 

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
using namespace std;
/*
* 最小树形图
* int型
* 复杂度O(NM)
* 点从0开始
*/
const int INF = 0x3f3f3f3f;
const int MAXN = 1010;
const int MAXM = 40010;
struct Edge
{
    int u,v,cost;
};
Edge edge[MAXM];
int pre[MAXN],id[MAXN],visit[MAXN],in[MAXN];
int zhuliu(int root,int n,int m,Edge edge[])
{
    int res = 0,u,v;
    while(1)
    {
        for(int i = 0; i < n; i++)
            in[i] = INF;
        for(int i = 0; i < m; i++)
            if(edge[i].u != edge[i].v && edge[i].cost < in[edge[i].v])
            {
                pre[edge[i].v] = edge[i].u;
                in[edge[i].v] = edge[i].cost;
            }
        for(int i = 0; i < n; i++)
            if(i != root && in[i] == INF)
                return -1;//不存在最小树形图
        int tn = 0;
        memset(id,-1,sizeof(id));
        memset(visit,-1,sizeof(visit));
        in[root] = 0;
        for(int i = 0; i < n; i++)
        {
            res += in[i];
            v = i;
            while( visit[v] != i && id[v] == -1 && v != root)
            {
                visit[v] = i;
                v = pre[v];
            }
            if( v != root && id[v] == -1 )
            {
                for(int u = pre[v]; u != v ; u = pre[u])
                    id[u] = tn;
                id[v] = tn++;
            }
        }
        if(tn == 0)break;//没有有向环
        for(int i = 0; i < n; i++)
            if(id[i] == -1)
                id[i] = tn++;
        for(int i = 0; i < m;)
        {
            v = edge[i].v;
            edge[i].u = id[edge[i].u];
            edge[i].v = id[edge[i].v];
            if(edge[i].u != edge[i].v)
                edge[i++].cost -= in[v];
            else
                swap(edge[i],edge[--m]);
        }
        n = tn;
        root = id[root];
    }
    return res;
}
int g[MAXN][MAXN];
int main()
{
    int n,m;
    int iCase = 0;
    int T;
    scanf("%d",&T);
    while( T-- )
    {
        iCase ++;
        scanf("%d%d",&n,&m);
        for(int i = 0; i < n; i++)
            for(int j = 0; j < n; j++)
                g[i][j] = INF;
        int u,v,cost;
        while(m--)
        {
            scanf("%d%d%d",&u,&v,&cost);
            if(u == v)continue;
            g[u][v] = min(g[u][v],cost);
        }
        int L = 0;
        for(int i = 0; i < n; i++)
            for(int j = 0; j < n; j++)
                if(g[i][j] < INF)
                {
                    edge[L].u = i;
                    edge[L].v = j;
                    edge[L++].cost = g[i][j];
                }
        int ans = zhuliu(0,n,L,edge);
        printf("Case #%d: ",iCase);
        if(ans == -1)printf("Possums!\n");
        else printf("%d\n",ans);
    }
    return 0;
}