POJ 3164Command Network && UVA 11183 Teen Girl Squad 最小树形图

最小树形图：简单来说，求一个图的G0的最小树形图，先求出最短弧集合E0。若E0不存在，则图G0的最小树形图不存在。若存在且不含有向环，则E0就是T0中的所有的边。如果E0存在且含有有向环，则收缩有向环为一个点u，并形成图G1，继续且G1的最小树形图直至图Gi，若图Gi无最小树形图，则图G0也不存在最小树形图，若Gi有最小树形图Ti.则逐层展开得到T0
具体可以参考这位大牛写的过程：http://www.cnblogs.com/vongang/archive/2012/07/18/2596851.html（我是看书的，书上看了半天才懂..）
UVA 11183 Teen Girl Squad
Input: Standard Input
Output: Standard Output

– 3 spring rolls please.
– MSG’D!!
– Oh! My stomach lining!
Strong Bad
You are part of a group of n teenage girls armed with cellphones. You have some news you want to tell everyone in the group. The problem is that no two of you are in the same room, and you must communicate using only cellphones. What’s worse is that due to excessive usage, your parents have refused to pay your cellphone bills, so you must distribute the news by calling each other in the cheapest possible way. You will call several of your friends, they will call some of their friends, and so on until everyone in the group hears the news.
Each of you is using a different phone service provider, and you know the price of girl A calling girl B for all possible A and B. Not all of your friends like each other, and some of them will never call people they don’t like. Your job is to find the cheapest possible sequence of calls so that the news spreads from you to all n-1 other members of the group.
Input
The first line of input gives the number of cases, N (N<150). N test cases follow. Each one starts with two lines containing n (0<= n<=1000) and m (0 <= m <= 40,000) . Girls are numbered from 0 to n-1 , and you are girl 0. The next m lines will each contain 3 integers, u, v and w, meaning that a call from girl u to girl v costs w cents (0 <= w <= 1000) . No other calls are possible because of grudges, rivalries and because they are, like, lame. The input file size is around 1200 KB.

Output
For each test case, output one line containing “Case #x:” followed by the cost of the cheapest method of distributing the news. If there is no solution, print “Possums!” instead.

Sample Input Output for Sample Input
4
2
1
0 1 10
2
1
1 0 10
4
4
0 1 10
0 2 10
1 3 20
2 3 30
4
4
0 1 10
1 2 20
2 0 30
2 3 100
Case #1: 10
Case #2: Possums!
Case #3: 40
Case #4: 130

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

const int maxn=1010;
const int INF = 0x3f3f3f3f;
const int maxm =40010;

struct Edge
{
    int u,v,cost;
}edge[maxm];

int pre[maxn],id[maxn],vis[maxn],in[maxn];
int zhuliu(int root,int n,int m,Edge edge[])
{
    int u,v;
    int res=0;
    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(vis,-1,sizeof(vis));
        in[root]=0;
        for(int i=0;i<n;i++)
        {
            res+=in[i];
            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]=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 t;
    int n,m;
    int Case=0;
    scanf("%d",&t);
    while(t--)
    {
        Case++;
        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;

        for(int i=1;i<=m;i++)
        {
            scanf("%d %d %d",&u,&v,&cost);
            if(u==v)continue;
            //printf("%lf\n",dis(p[u],p[v]));
            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: ",Case);
        if(ans==-1)
            printf("Possums!\n");
        else
            printf("%d\n",ans);
    }
    return 0;
}
POJ 3164 Command Network
Time Limit: 1000MS      Memory Limit: 131072K
Total Submissions: 14340        Accepted: 4118
Description

After a long lasting war on words, a war on arms finally breaks out between littleken’s and KnuthOcean’s kingdoms. A sudden and violent assault by KnuthOcean’s force has rendered a total failure of littleken’s command network. A provisional network must be built immediately. littleken orders snoopy to take charge of the project.

With the situation studied to every detail, snoopy believes that the most urgent point is to enable littenken’s commands to reach every disconnected node in the destroyed network and decides on a plan to build a unidirectional communication network. The nodes are distributed on a plane. If littleken’s commands are to be able to be delivered directly from a node A to another node B, a wire will have to be built along the straight line segment connecting the two nodes. Since it’s in wartime, not between all pairs of nodes can wires be built. snoopy wants the plan to require the shortest total length of wires so that the construction can be done very soon.

Input

The input contains several test cases. Each test case starts with a line containing two integer N (N ≤ 100), the number of nodes in the destroyed network, and M (M ≤ 104), the number of pairs of nodes between which a wire can be built. The next N lines each contain an ordered pair xi and yi, giving the Cartesian coordinates of the nodes. Then follow M lines each containing two integers i and j between 1 and N (inclusive) meaning a wire can be built between node i and node j for unidirectional command delivery from the former to the latter. littleken’s headquarter is always located at node 1. Process to end of file.

Output

For each test case, output exactly one line containing the shortest total length of wires to two digits past the decimal point. In the cases that such a network does not exist, just output ‘poor snoopy’.

Sample Input

4 6
0 6
4 6
0 0
7 20
1 2
1 3
2 3
3 4
3 1
3 2
4 3
0 0
1 0
0 1
1 2
1 3
4 1
2 3
Sample Output

31.19
poor snoopy

前面一道题会了这道题就很好想了，代码自己练习一下吧！