HDU-2121-无根（不定根）最小树形图模板

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2121

题目大意：给你N个城市，选择一个城市建首都，城市编号为0~N-1，给你M条路，每条路包括u，v，w，即从u到v的花费为w，现在问你那个城市建首都的话，从这个城市到其余城市的花费最小，最小花费是多少，如果有多个适合的城市，输出编号小的城市。无法到达输出impossible。

解题思路：这是无根最小树形图的题，我们可以先假定一个虚根，即源点，并设源点到每个城市的权值为   全图所有权值之和大一点，然后就是树形图模板，细节在代码中。

代码如下：

[cpp] view plain copy

print ?

1. //本题边长都为__int64,其实int型也可以过，但长整型应该更广，所以本题都为__int64  
2. #include <cstdio>  
3. #include<iostream>  
4. #include <cstring>  
5. #include <cstdlib>  
6. #include<cmath>  
7. using namespace std;  
8. typedef double type;  
9. #define INF 2000000000  
10. #define N 1005  
11.   
12. struct edge //图的结构体  
13. {  
14.     int u,v;__int64 w;  
15. }e[10005];  
16.   
17. int m,n,pre[N],id[N],visit[N],xroot;  
18. __int64 in[N],sum;  
19. //eCnt为图中的边数  
20. //n为图中的顶点数  
21. //pre[i]为顶点i的前驱节点  
22. //id[i]为缩环，形成新图的中间量  
23. //in[i]为点i的最小入边  
24. //visit[i]遍历图时记录顶点是否被访问过  
25. __int64 directedMST(int root,int nv,int ne)  
26. {  
27.     __int64 ans=0;  
28.     while(1)  
29.     {  
30.         //1.找最小入边  
31.         for(int i=0;i<nv;i++) in[i]=INF;  
32.         for(int i=0;i<ne;i++)  
33.         {  
34.             int u=e[i].u;  
35.             int v=e[i].v;  
36.             if(u!=v&&e[i].w<in[v])  
37.             {  
38.                 if(u==root)  //此处标记与源点相连的最小边  
39.                     xroot=i;  
40.                 in[v]=e[i].w;  
41.                 pre[v]=u;  
42.             }  
43.         }  
44.         for(int i=0;i<nv;i++)                          //判断图是否连通  
45.             if(i!=root&&in[i]==INF) return -1;  //除了跟以外有点没有入边,则根无法到达它  
46.          //2.找环  
47.         int nodeCnt=0;          //图中环的数目  
48.         memset(id, -1, sizeof(id));  
49.         memset(visit, -1, sizeof(visit));  
50.         in[root]=0;  
51.         for(int i=0;i<nv;i++)  
52.         {  
53.             ans+=in[i];  
54.             int v=i;  
55.             while(visit[v]!=i&&id[v]==-1&&v!=root)//每个点寻找其前序点，要么最终寻找至根部，要么找到一个环  
56.             {  
57.                 visit[v]=i;  
58.                 v=pre[v];  
59.             }  
60.             if(v!=root&&id[v]==-1)//缩点  
61.             {  
62.                 for(int u=pre[v];u!=v;u=pre[u])  
63.                     id[u]=nodeCnt;  
64.                 id[v]=nodeCnt++;  
65.             }  
66.         }  
67.         if(nodeCnt==0) break;//如果无环，跳出循环  
68.         for(int i=0; i<nv; i++)  
69.             if(id[i]==-1)  
70.                 id[i]=nodeCnt++;  
71.         //3.缩点，重新标记  
72.         for(int i=0;i<ne;i++)  
73.         {  
74.             int v=e[i].v;  
75.             e[i].u=id[e[i].u];  
76.             e[i].v=id[e[i].v];  
77.             if(e[i].u!=e[i].v)  
78.                 e[i].w-=in[v];  
79.         }  
80.         nv=nodeCnt;  
81.         root=id[root];  
82.     }  
83.     return ans;  
84. }  
85.   
86. int main()  
87. {  
88.     int m;  
89.     while(scanf(“%d%d”,&n,&m)!=EOF)  
90.     {  
91.         sum=0;  
92.         for(int i=0;i<m;i++)  
93.         {  
94.             scanf(”%d%d%I64d”,&e[i].u,&e[i].v,&e[i].w);  
95.             e[i].u++;e[i].v++;     //都++之后，把0设为超级源点，联通各点  
96.             sum+=e[i].w;  
97.             if(e[i].u==e[i].v)  
98.                 e[i].w=INF;//消除自环  
99.         }  
100.         sum++;      //此处必须++，因为需要权值比总权值大，因为这个w几次，，，  
101.         for(int i=m;i<n+m;i++)  
102.         {  
103.             e[i].u=0;  
104.             e[i].v=i-m+1;  
105.             e[i].w=sum;  
106.         }  
107.         __int64 ans=directedMST(0,n+1,m+n);  
108.         if(ans==-1 || ans-sum>=sum) printf(“impossible\n”);//ans-sum是除去虚根的最小树形图的最短路径，如果这个距离比所有的边权值和sum还大，说明还有另外的边由虚点发出，故说明此图不连通  
109.         else printf(“%I64d %d\n”, ans-sum, xroot-m);  
110.         printf(”\n”);  
111.     }  
112.     return 0;  
113. }