POJ 1639 k度限制生成树

地址：http://blog.csdn.net/sdj222555/article/details/7697776

题意就是求最小生成树  但是有一个顶点的度必须不大于k

具体的方法网上都有，但是代码写起来之复杂难以令人想象，我由于代码能力还太弱，导致只能看着别人的代码重写一遍，优化了一些部分。

1.求出除去K度点的最小生成森林，设森林数为m

2.将这m棵树与K度点用每棵树中与K度点距离最短的点相连，生成一个m度最小生成树，总答案为这个生成树的所有边长之和

3.迭代k-m次，尝试将m度生成树扩展为K度生成树，并求出最小生成树的长度

    (1)扫描k度点的所有邻接点，（注意，这是扫描的原图） 找到一个点使得(新的生成树中该点到K度点最大边的长度)与（原图中K度点到该点的距离)之差最大。 (注意，该点不能是生成树中直接与K度点相连的点)

   (2) 若（1）找出的差值不大于0，则无须继续往下找，否则，在新的生成树中连接该点到K度点，并将最大边替换掉，然后从该点开始更新最大边。此时，m度生成树变为m+1度生成树，总答案减去该差值。

   (3)循环以上步骤，直到变为K度生成树或者跳出

   

4.打印答案

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <map>  
3. #include <cstdio>  
4. #include <cstring>  
5. #include <algorithm>  
6. #define MAXN 105  
7. #define MAXM 100005  
8. #define INF 1000000000  
9. using namespace std;  
10. struct node  
11. {  
12.     int v, w, next;  
13. }edge[MAXM];  
14. struct Edge  
15. {  
16.     int u, v, w;  
17.     Edge(){}  
18.     Edge(int a, int b, int c){u = a; v = b; w = c;}  
19.     void init(){w = 0;}  
20.     bool operator >(const Edge &a) const{  
21.         return w > a.w;  
22.     }  
23. }mx[MAXN];//用于存储每个点到park点的最大边  
24. int n, m, k, sum;//sum为结果  
25. int e, head[MAXN], vis[MAXN], dis[MAXN], use[MAXN][MAXN];//head用于邻接表 vis是标记数组 dis用于求最小生成树  
26. //use用来标记两点之间是否有边  
27. int blocks, size[MAXN], belong[MAXN], nearvex[MAXN];//blocks表示去除park后有几个连通块  size是每个连通块的个数  
28. //belong表示该点属于哪个连通块  nearvex用于在生成树中记录边  
29. int point[MAXN], link[MAXN]; //point表示每个连通块中与park点最近的点  link则是该点与park点的距离  
30. map<string, int>mp; //用于映射名字  
31. void init()  
32. {  
33.     e = 0, n = 1;  
34.     blocks = 0, sum = 0;  
35.     memset(head, -1, sizeof(head));  
36.     memset(vis, 0, sizeof(vis));  
37.     memset(size, 0, sizeof(size));  
38.     memset(use, 0, sizeof(use));  
39.     for(int i = 1; i < MAXN; i++) mx[i].init();  
40.     memset(nearvex, 0, sizeof(nearvex));  
41.     mp.clear();  
42. }  
43. void insert(int x, int y, int w)  
44. {  
45.     edge[e].v = y;  
46.     edge[e].w = w;  
47.     edge[e].next = head[x];  
48.     head[x] = e++;  
49. }  
50. int getId(char s[])  
51. {  
52.     if(mp.find(s) == mp.end()) mp[s] = ++n;  
53.     else return mp[s];  
54.     return n;  
55. }  
56. void dfs(int v) //该dfs将图分成了一些连通块  
57. {  
58.     vis[v] = 1;  
59.     size[blocks]++;  
60.     belong[v] = blocks;  
61.     for(int i = head[v]; i != -1; i = edge[i].next)  
62.         if(!vis[edge[i].v]) dfs(edge[i].v);  
63. }  
64. void prim(int cur) //对某个连通块求最小生成树  
65. {  
66.     for(int i = 1; i <= n; i++) dis[i] = INF;  
67.     for(int i = 1; i <= n; i++) //设置块内某点为起点来求生成树  
68.         if(belong[i] == cur)  
69.         {  
70.             dis[i] = 0;  
71.             break;  
72.         }  
73.     for(int i = 1; i <= size[cur]; i++)  //循环次数为该块的顶点数，因为这与一般的求MST略微不同  
74.     {  
75.         int mi = INF, pos = -1;  
76.         for(int j = 1; j <= n; j++)  
77.             if(nearvex[j] != -1 && mi > dis[j])  
78.                 mi = dis[j], pos = j;  
79.         if(pos != -1)  
80.         {  
81.             sum += mi;  
82.             use[pos][nearvex[pos]] = use[nearvex[pos]][pos] = 1; //标记生成树中所用的边  
83.             nearvex[pos] = -1;  
84.             for(int j = head[pos]; j != -1; j = edge[j].next)  
85.                 if(nearvex[edge[j].v] != -1 && dis[edge[j].v] > edge[j].w)  
86.                 {  
87.                     dis[edge[j].v] = edge[j].w;  
88.                     nearvex[edge[j].v] = pos;  
89.                 }  
90.         }  
91.     }  
92. }  
93. void getMax(int v, int fa, int w) //该函数用于更新新的生成树中点到park点的最大边  
94. {  
95.     nearvex[v] = fa;  
96.     Edge t(v, fa, w);  
97.     if(mx[fa] > t) mx[v] = mx[fa];  
98.     else mx[v] = t;  
99.     for(int i = head[v]; i != -1; i = edge[i].next)  
100.         if(use[v][edge[i].v] && edge[i].v != fa) getMax(edge[i].v, v, edge[i].w); //必须是生成树中的边并且不是回边才往下搜  
101. }  
102. void GetMdegreeMST()  
103. {  
104.     vis[1] = 1;  
105.     for(int i = 2; i <= n; i++) //求连通块  
106.         if(!vis[i])  
107.         {  
108.             blocks++;  
109.             dfs(i);  
110.         }  
111.     nearvex[1] = -1;  
112.     for(int i = 1; i <= blocks; i++) prim(i);  
113.     for(int i = 1; i <= n; i++) link[i] = INF;  
114.     for(int i = head[1]; i != -1; i = edge[i].next)  //生成一棵m度的生成树  
115.         if(link[belong[edge[i].v]] > edge[i].w)  
116.         {  
117.             link[belong[edge[i].v]] = edge[i].w;  
118.             point[belong[edge[i].v]] = edge[i].v;  
119.         }  
120.     for(int i = 1; i <= blocks; i++) //将park点与每个连通块中与其最近的点相连，并且标记边  
121.     {  
122.         sum += link[i];  
123.         use[1][point[i]] = use[point[i]][1] = 1;  
124.     }  
125. }  
126. void slove()  
127. {  
128.     int degree = blocks;  
129.     getMax(1, 0, 0); //首先从park点出发求一遍最大边  
130.     while(degree < k) //尝试迭代 k - degree次  
131.     {  
132.         int maxval = 0, pos = 0, w;  
133.         for(int i = head[1]; i != -1; i = edge[i].next) //用于找到差值最大的点  
134.             if(!use[1][edge[i].v] && mx[edge[i].v].w - edge[i].w > maxval)  
135.             {  
136.                 maxval = mx[edge[i].v].w - edge[i].w, pos = edge[i].v;  
137.                 w = edge[i].w;  
138.             }  
139.         if(!pos) break;  
140.         sum -= maxval;//更新答案  
141.         degree++;  
142.         use[mx[pos].u][mx[pos].v] = use[mx[pos].v][mx[pos].u] = 0;//将最大边删除  
143.         use[1][pos] = use[pos][1] = 1;  
144.         getMax(pos, 1, w);//更新最大边  
145.     }  
146. }  
147. int main()  
148. {  
149.     char s1[55], s2[55];  
150.     int w;  
151.     scanf("%d", &m);  
152.     init();  
153.     mp["Park"] = 1;  
154.     for(int i = 0; i < m; i++)  
155.     {  
156.         scanf("%s%s%d", s1, s2, &w);  
157.         insert(getId(s1), getId(s2), w);  
158.         insert(getId(s2), getId(s1), w);  
159.     }  
160.     scanf("%d", &k);  
161.     GetMdegreeMST();  
162.     slove();  
163.     printf("Total miles driven: %d\n", sum);  
164.     return 0;  
165. }