UVA11183 Teen Girl Squad —— 最小树形图

题目链接：https://vjudge.net/problem/UVA-11183

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

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

Sample Output

Case #1: 10

Case #2: Possums!

Case #3: 40

Case #4: 130

题解：

最小树形图，即有向图的最小生成树。因为题目要求可以有重边，所以对于两个点，如果之间有多条边（有向边，u-->v），选取权值最小的那条边。

代码如下：

 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 #include <cmath>
 using namespace std;
 typedef long long LL;
 const double EPS = 1e-;
 const int INF = 2e9;
 const LL LNF = 9e18;
 const int MOD = 1e9+;
 const int MAXN = 1e3+;

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

 int pre[MAXN], id[MAXN], vis[MAXN], in[MAXN];

 int zhuliu(int root, int n, int m)
 {
     int res = ;
     while()
     {
         for(int i = ; i<n; i++)    //初始化
             in[i] = INF;
         for(int i = ; i<m; i++)   //为每个结点选择一条最小入边， 并记录它的上一个点。
         if(edge[i].u!=edge[i].v && edge[i].w<in[edge[i].v]) //第一个判断防止自环
         {
             pre[edge[i].v] = edge[i].u;
             in[edge[i].v] = edge[i].w;
         }

         for(int i = ; i<n; i++)    //如果非根结点找不到至少一条入边，则建树失败
             if(i!=root && in[i]==INF)
                 return -;

         int tn = ; //tn为重建图后的结点个数，过程中为结点重新编号
         memset(id, -, sizeof(id));
         memset(vis, -, sizeof(vis));
         in[root] = ;   //根节点的入度必须为0
         for(int i = ; i<n; i++)    //将环缩成点
         {
             res += in[i];
             int v = i;
             //当vis[v]==i时,找到了环中第一个被访问的结点
             while(vis[v]!=i && id[v]==- && v!=root)
             {
                 vis[v] = i;
                 v = pre[v];
             }
             if(v!=root && id[v]==-)
             {
                 for(int u = pre[v]; u!=v; u = pre[u])   //为整个换编上号
                     id[u] = tn;
                 id[v] = tn++;
             }
         }
         if(tn==) break;    //如果不存在环， 则建树成功
         for(int i = ; i<n; i++)    //为不在环内的结点编号
             if(id[i]==-)
                 id[i] = tn++;

         for(int i = ;  i<m; )  //重新建图
         {
             int 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++].w -= in[v];
             else
                 swap(edge[i], edge[--m]);
         }
         n = tn; //更新结点个数及根节点
         root = id[root];
     }
     return res;
 }

 int g[MAXN][MAXN];
 int main()
 {
     int T, n, m;
     scanf("%d", &T);
     for(int kase = ; kase<=T; kase++)
     {
         scanf("%d%d",&n,&m);
         for(int i = ; i<n; i++)
         for(int j = ; j<n; j++)
             g[i][j] = INF;

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

         int tot = ;
         for(int i = ; i<n; i++)
         for(int j = ; j<n; j++)
         {
             if(i!=j && g[i][j]!=INF)
                 edge[tot].u = i, edge[tot].v = j, edge[tot++].w = g[i][j];
         }

         int ans = zhuliu(, n, tot);
         if(ans<) printf("Case #%d: Possums!\n", kase);
         else printf("Case #%d: %d\n", kase, ans);
     }
 }