最小树形图

//来自kuangbin的最小树形图模版：
//UVA - 11183 
//最小树形图 求有向图的最小生成树
//复杂度 O（VE）

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 1000+10;
const int MAXM = 40000+10;

struct Edge{
    //分别为起点，终点，花费 
    int u,v,cost;
};
Edge edge[MAXM];
//pre[i]表示i节点的入边的起点，in[i]表示该边的权值 
int pre[MAXN],id[MAXN],visit[MAXN],in[MAXN];

//root为根节点，n为节点数量，m为边数量 
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++)
            //如果该边不是自环边，该边的终点v顶点的入边边权比这条边大，那么这条边作为v顶点的入边 
            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;
            //寻找v节点所在的环
            //visit保证不会无限循环，并且用i标记了该环是那个所有的顶点 
            while(visit[v]!=i && id[v]==-1 && v!=root){
                visit[v]=i;
                v=pre[v];
            }
            //标记环上的顶点是属于第tn个环 
            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];
            //i边的权值要减去v所在环的入边权值 
            if(edge[i].u!=edge[i].v)
                edge[i++].cost-=in[v];
            //i边在连接的是同一个环里面的连个节点，该边舍去 
            else
                swap(edge[i],edge[--m]);
        }
        //对新图求最小树形图
        //新图的节点数量 
        n=tn;
        //新图的根节点位置，缩点所在的位置 
        root=id[root];
    }
    //最小树形图的权值 
    return res;
}

int g[MAXN][MAXN];
int main(){
    int n,m;
    int t;
    scanf("%d",&t);
    for(int casei=1;casei<=t;casei++){
        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: ",casei);
        if(ans==-1)
            printf("Possums!\n");
        else
            printf("%d\n",ans);
    }
}