POJ 1639 Picnic Planning【度限制最小生成树】

 

POJ 1639 Picnic Planning【度限制最小生成树】

分类： 【图论专辑】2010-08-02 03:47 706人阅读 评论(3) 收藏 举报

treestringinput算法

/*  第一道度限制生成树，写的比较崩溃@@
 *  度限制生成树是指对生成树中某些点限制度的生成树，如果是要求权值最小的话
 *  便是度限制最小生成树。一般题目也就是对某一个点进行度限制，因为所有点进行
 *  度限制是NP问题。
 *  解法：1)先去掉有度限制的点和与它相邻的边，对求剩下的点求最小生成树。由于剩下的点可能不连同，所以
 *                 要对每一个连通分量求最小生成树。
 *              2)然后对每一个连通分量，从中找出一条距原点（有度限制的点）最短的一条边加进去。如果有M个连通分量，
 *                 那么现在求得的便是一个M度最小生成树。
 *              3)设度限制为K > M,那么再进行 K-M 次循环,每次进行如下操作：对每一个不在生成树中的点，连一条到原点的
 *                  边，那么现在一定构成了一个环。然后找出这个环中除了新连的边外最长的边，和新添加的边作差。
 *                 如果结果是负值，找到最小的这个值，更新，如此进行K-M 次操作。
 *                 由于该题求的是不超过K度的生成树，所以如果无法更新便可直接跳出循环
 *             PS：以上便是度限制生成树的基本算法，个人感觉其中关键部分一个是对每一个连通分量求最小生成树，另一个便是添边然后找环
 *                      操作，网上的大部分解法都很复杂，代码动辄200+  今天请教了Ych，他教了我一个好方法，可以这样：由于去掉原点后图可能
 *                      不连通，而对每一个连通分量求最小生成树又很烦，所以可以初始化时将所有边初始化为无穷大，然后对去掉原点的图只进行一次
 *                      求最小生成树的操作。这样如果图不连通的话那么会自动加一条无穷大的边，但是没关系。接下来在从生成树中找到一个距原点
 *                      最近的点加到生成树中，此时是一棵1度生成树（不是最小生成树），然后进行K-1次上述的更新。其中找环可以用DFS，也可以用
 *                      BFS。我选择了BFS，因为更直观。
 *            最后有一点一定要注意就是对某些变量赋值时的无穷大一定要比边初始化的那个无穷大还要大，否则会出错。今天因为这个错误调试
 *            了近两个小时。。。崩溃。。。
 */

[cpp] view plaincopy

1. #include <cstdio>  
2. #include <iostream>  
3. #include <cstring>  
4. #include <algorithm>  
5. #include <map>  
6. #include <queue>  
7. #include <string>  
8. #define min(a,b)  ((a)<(b)?(a):(b))  
9. #define INF (1<<30)  
10. #define MAXN 25  
11. using namespace std;  
12. int cost[MAXN][MAXN],pre[MAXN],dis[MAXN];  
13. bool vis[MAXN],tree[MAXN][MAXN];    
14. int M,N,K,ans;  
15. inline bool Input(){  
16.     char s[20],e[20];  
17.     int w,cont = 1;  
18.     map<string,int>f;  
19.     f.clear();  
20.     f["Park"] = 0;  
21.     memset(cost,0x3f,sizeof(cost));  
22.     while(M--){  
23.         scanf("%s %s %d",s,e,&w);  
24.         if(f.find((string)s) == f.end())  
25.             f[(string)s] = cont++;  
26.         if(f.find((string)e) == f.end())  
27.             f[(string)e] = cont++;  
28.         int u = f[(string)s],v = f[(string)e];  
29.         cost[u][v] = cost[v][u] = w;  
30.     }  
31.     N = cont;  
32.     scanf("%d",&K);  
33.     return true;  
34. }  
35. inline int Find_max(int s,int e,int &st,int &ed){ // BFS找到环上边权最大的边  
36.     int que[MAXN+10];  
37.     memset(vis,false,sizeof(vis));  
38.     vis[s] = true;  
39.     int head = 0,tail = 0;  
40.     pre[s] = -1;  
41.     que[tail++] = s;  
42.     while(tail > head){  
43.         int tep = que[head++];  
44.         for(int i = 1;i < N; ++i){  
45.             if(!vis[i] && tree[tep][i]){  
46.                 vis[i] = true;  
47.                 pre[i] = tep;     
48.                 que[tail++] = i;  
49.             }  
50.         }     
51.     }  
52.     int re = -1;  
53.     while(s != e){  
54.         if(re < cost[e][pre[e]]){  
55.             re = cost[e][pre[e]];  
56.             st = e;  
57.             ed = pre[e];  
58.         }  
59.         e = pre[e];  
60.     }  
61.     return re;  
62. }  
63. inline int prim(){  
64.     memset(vis,false,sizeof(vis));  
65.     memset(tree,false,sizeof(tree));  
66.     for(int i = 1;i < N; ++i){  
67.         pre[i] = 1;  
68.         dis[i] = cost[1][i];  
69.     }  
70.     vis[1] = true;  
71.     int sum = 0;  
72.     for(int i = 1;i < N-1; ++i){  
73.         int md = INF,idex = -1;  
74.         for(int j = 1;j < N ; ++j){  
75.             if(!vis[j] && dis[j] < md){  
76.                 md = dis[j];  
77.                 idex = j;     
78.             }  
79.         }  
80.         if(idex == -1) break;  
81.         vis[idex] = true;  
82.         tree[idex][pre[idex]] = tree[pre[idex]][idex] = true;  
83.         sum += md;  
84.         for(int j = 1;j < N; ++j)  
85.             if(!vis[j] && dis[j] > cost[idex][j]){  
86.                 dis[j] = cost[idex][j];  
87.                 pre[j] = idex;  
88.             }  
89.     }  
90.     return sum;  
91. }  
92. inline void solve(){  
93.     ans = prim();          //先对剩余点求最小生成树  
94.     int m = INF,idex = -1;  
95.     for(int i = 1;i < N; ++i){    // 然后从生成树中找一个距度限制点最近的点加进来  
96.         if(cost[i][0] < m){  
97.             m = cost[i][0];  
98.             idex = i;  
99.         }  
100.     }  
101.     ans += m;  
102.     tree[idex][0] = tree[0][idex] = true;  
103.     for(int i = 1;i < K; ++i){     //然后进行K-1次循环每次进行树的更新  
104.         int st,ed,s,e;  
105.         idex = -1; m = 0;  
106.         for(int j = 1,k;j < N; ++j){  
107.             if(!tree[j][0]){      
108.                 k = Find_max(0,j,st,ed);  
109.                 if(m > cost[j][0] - k){  
110.                     m = cost[j][0] - k;  
111.                     idex = j;  
112.                     s = st;  
113.                     e = ed;  
114.                 }  
115.             }  
116.         }  
117.         if(idex == -1) break;  
118.         ans += m;  
119.         tree[idex][0] = tree[0][idex] = true;  
120.         tree[s][e] = tree[e][s] = false;  
121.     }  
122.     printf("Total miles driven: %d/n",ans);  
123. }  
124. int main()  
125. {  
126.     while(scanf("%d",&M) != EOF){  
127.         Input();  
128.         solve();  
129.     }  
130.     return 0;  
131. }