POJ 1639 Picnic Planning（最小度限制生成树）

Description

The Contortion Brothers are a famous set of circus clowns, known worldwide for their incredible ability to cram an unlimited number of themselves into even the smallest vehicle. During the off-season, the brothers like to get together for an Annual Contortionists Meeting at a local park. However, the brothers are not only tight with regard to cramped quarters, but with money as well, so they try to find the way to get everyone to the party which minimizes the number of miles put on everyone's cars (thus saving gas, wear and tear, etc.). To this end they are willing to cram themselves into as few cars as necessary to minimize the total number of miles put on all their cars together. This often results in many brothers driving to one brother's house, leaving all but one car there and piling into the remaining one. There is a constraint at the park, however: the parking lot at the picnic site can only hold a limited number of cars, so that must be factored into the overall miserly calculation. Also, due to an entrance fee to the park, once any brother's car arrives at the park it is there to stay; he will not drop off his passengers and then leave to pick up other brothers. Now for your average circus clan, solving this problem is a challenge, so it is left to you to write a program to solve their milage minimization problem.

Input

Input will consist of one problem instance. The first line will contain a single integer n indicating the number of highway connections between brothers or between brothers and the park. The next n lines will contain one connection per line, of the form name1 name2 dist, where name1 and name2 are either the names of two brothers or the word Park and a brother's name (in either order), and dist is the integer distance between them. These roads will all be 2-way roads, and dist will always be positive.The maximum number of brothers will be 20 and the maximumlength of any name will be 10 characters.Following these n lines will be one final line containing an integer s which specifies the number of cars which can fit in the parking lot of the picnic site. You may assume that there is a path from every brother's house to the park and that a solution exists for each problem instance.

Output

Output should consist of one line of the form 
Total miles driven: xxx 
where xxx is the total number of miles driven by all the brothers' cars.

 

题目大意：有一群人开车到某地，但是某地的停车场又只能停k部车。不过呢，这群人可以先开车到另外一个人的家里，然后搭别人的便车（车没有坐人的上限噢，开挂的民族……）到某地。然后呢，他们又很省钱，希望花的钱最少（也就是车驶过的路径最小，因为开车要油嘛等等），问最短距离是多少。（又不告诉你边数上限，也不告诉你有几个人，慢慢算吧……）

思路：最小生成树。如果一个人开车到了另外一个人的地方，肯定会坐别人的车，省钱嘛，所以很容易能看出总路径就是最小生成树，而对某个点的度数有所限制，则对最小度限制生成树稍作修改即可（这题可不一定要停满别人的停车场啊……）。更详细的可以去看2004年 汪汀 的论文《最小生成树问题的拓展》

 

PS：V好小啊只有20是要闹哪样啊……

PS：没事翻博客的时候发现这代码有BUG，虽然AC了，不过我懒得改了就这样吧……

 

代码写得有点挫……

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

 const int MAXN = ;
 const int INF = 0x7f7f7f7f;

 struct Node {
     int u, v, c, use;
     Node() {}
     Node(int uu, int vv, int cc): u(uu), v(vv), c(cc), use(false) {}
     bool operator < (const Node &rhs) const {
         return c < rhs.c;
     }
 };

 map<string, int> mymap;
 string s1, s2;
 int n, m, k, ecnt, ans, cnt;
 Node *p;
 int fa[MAXN], head[MAXN], *next;
 int mat[MAXN][MAXN];

 void init() {
     ecnt = n = ;
     p = new Node[ * m + ];
     next = new int[ * m + ];
     mymap.clear();
     mymap["Park"] = n++;
     memset(mat, , sizeof(mat));
 }

 int get_set(int x) {
     return fa[x] == x ? x : get_set(fa[x]);
 }

 void add_edge(int u, int v, int c) {
     p[ecnt++] = Node(u, v, c);
     p[ecnt++] = Node(v, u, c);
     if(mat[u][v] ==  || c < mat[u][v])
         mat[u][v] = mat[v][u] = c;
 }

 void build_link() {
     memset(head, -, sizeof(head));
     for(int i = ecnt - ; i >= ; --i) {
         next[i] = head[p[i].u];
         head[p[i].u] = i;
     }
 }

 void kruskal_del0() {
     ans = cnt = ;
     for(int i = ; i < ecnt; ++i) {
         if(p[i].u ==  || p[i].v == ) continue;
         int x = get_set(p[i].u), y = get_set(p[i].v);
         if(x == y) continue;
         fa[x] = y;
         p[i].use = p[i ^ ].use = true;
         ans += p[i].c;
         ++cnt;
     }
     m = n -  - cnt;
     build_link();
     for(int i = head[]; i != -; i = next[i]) {
         if(p[i].u && p[i].v) continue;
         int x = get_set(p[i].u), y = get_set(p[i].v);
         if(x == y) continue;
         fa[x] = fa[y] = ;
         p[i].use = p[i ^ ].use = true;
         ans += p[i].c;
         if(++cnt == n - ) break;
     }
 }

 void dfs(int x) {
     for(int i = head[x]; i != -; i = next[i]) {
         if(p[i].use) {
             fa[p[i].v] = x;
             p[i].use = p[i ^ ].use = false;
             dfs(p[i].v);
         }
     }
 }

 int best[MAXN];

 int get_best(int x) {
     if(fa[x] == ) return -;
     if(best[x] != -) return best[x];
     return best[x] = max(mat[x][fa[x]], get_best(fa[x]));
 }

 void exchange_edge() {
     while(m++ < k) {
         memset(best, -, sizeof(best));
         for(int i = ; i < n; ++i) get_best(i);
         int a = INF, y = ;
         for(int i = head[]; i != -; i = next[i]) {
             if(best[p[i].v] != - && a > p[i].c - best[p[i].v]) {
                 a = p[i].c - best[p[i].v];
                 y = p[i].v;
             }
         }
         if(a >= ) return ;
         ans += a; fa[y] = ;
     }
 }

 int main() {
     int c;
     while(scanf("%d", &m) != EOF) {
         init();
         while(m--) {
             cin>>s1>>s2>>c;
             if(mymap.find(s1) == mymap.end()) mymap[s1] = n++;
             if(mymap.find(s2) == mymap.end()) mymap[s2] = n++;
             add_edge(mymap[s1], mymap[s2], c);
         }
         scanf("%d", &k);
         for(int i = ; i < n; ++i) fa[i] = i;
         sort(p, p + ecnt);
         kruskal_del0();
         dfs();
         exchange_edge();
         printf("Total miles driven: %d\n", ans);
         delete [] p;
         delete [] next;
     }
 }