poj 1639 Picnic Planning

点击打开链接poj1639

思路：最小k度限制生成树

解题步骤：
1. 先求出最小 m 度限制生成树：
    原图中去掉和 V0 相连的所有边，得到 m 个连通分量，则这 m  个连通分量必须通过 v0 来连接，所以，在图 G  的所有生成树中 dT(v0)≥m 。也就是说，当 k<m 时，问题无解。对每个连通分量求一次最小生成树，对于每个连通分量 V’ ，用一条与 V0 直接连接的最小的边把它与 V0 点连接起来，使其整体成为一个生成树。于是，我们就得到了一个 m 度限制生成树，不难证明，这就是最小 m 度限制生成树。

2. 由最小 m 度限制生成树得到最小 m+1 度限制生成树：
    连接和 V0 相邻的点 v ，则可以知道一定会有一个环出现（因为原来是一个生成树），只要找到这个环上的最大权边（不能与 v0 点直接相连）并删除，就可以得到一个 m+1 度限制生成树，枚举所有和 V0 相邻点 v ，找到替换后，增加权值最小的一次替换 (当然，找不到这样的边时，就说明已经求出) ，就可以求得 m+1 度限制生成树。如果每添加一条边，都需要对环上的边一一枚举，时间复杂度将比较高（但这个题数据比较小，所以这样也没问题，事实上，直接枚举都能过这个题），这里，用动态规划解决。设   Best(v)
为路径 v0—v 上与 v0 无关联且权值最大的边。定义 father(v) 为 v 的父结点，由此可以得到动态转移方程： Best(v)=max(Best(father(v)),ω(father(v),v)) ，边界条件为 Best[v0]=-∞ (因为我们每次寻找的是最大边，所以 -∞ 不会被考虑) ，Best[v’]=-∞| (v0,v’)∈E(T) 。这个可以用dfs做到

3. 当 dT(v0)=k 时停止(即当 V0 的度为 k 的时候停止)，但不一定 k 的时候最优。

代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<string>
#include<map>
using namespace std;
#define MAXN 30
#define INF 0x7FFFFFFF

int n , k , ans , cnt;/*边的长度n和k度 , cnt表示有几个点*/
int vis[MAXN];/*标记点i是否加入了生成树*/
int mark[MAXN];/*在prime算法里面会用到*/
int pre[MAXN];/*点i的前驱节点*/
int father[MAXN];/*生成树中父节点的编号*/
int best[MAXN];/*记录点i到限制点并且和限制点没有关联的最大边的点的编号*/
int edge[MAXN][MAXN];/*用来表示边是否已在生成树中*/
int G[MAXN][MAXN];/*保存两点之间的权值*/
int lowcost[MAXN];
map<string , int>m;

/*初始化G*/
void init(){
   for(int i = 0 ; i < MAXN ; i++){
      for(int j = 0 ; j < MAXN ; j++)
         G[i][j] = INF;
   }
}

/*dfs把一个连通分支里面的点全部指向s*/
void dfs(int s){
   for(int i = 1 ; i <= cnt ; i++){
      if(mark[i] && edge[i][s]){
        father[i] = s;
        mark[i] = 0;
        dfs(i);
      }
   }
}

/*prime算法*/
int prime(int s){
   int sum , pos;
   memset(mark , 0 ,sizeof(mark));
   vis[s] = mark[s] = 1;
   sum = 0;
   for(int i = 1 ; i <= cnt ; i++){
      lowcost[i] = G[s][i];
      pre[i] = s;
   }
   for(int i = 1 ; i <= cnt ; i++){
      pos = -1;
      for(int j = 1 ; j <= cnt ; j++){
         if(!vis[j] && !mark[j]){
           if(pos == -1 || lowcost[j] < lowcost[pos])
             pos = j;
         }
      }
      if(pos == -1)
        break;
      vis[pos] = mark[pos] = 1;
      edge[pre[pos]][pos] = edge[pos][pre[pos]] = 1;
      sum += G[pre[pos]][pos];
      for(int j = 1 ; j <= cnt ; j++){
         if(!vis[j] && !mark[j]){
           if(lowcost[j] > G[pos][j]){
             lowcost[j] = G[pos][j];
             pre[j] = pos;
           }
         }
      }
   }
   /*一下是找到一条最小权值的边把该连通分量连接到限制点1*/
   int min = INF;
   int root = -1;/*要和1点连接的点*/
   for(int i = 1 ; i <= cnt ; i++){
      if(mark[i] && G[i][1] < min){
        min = G[i][1];
        root = i;
      }
   }
   /*把当前的连通*/
   mark[root] = 0;
   dfs(root);
   father[root] = 1;
   return sum+min;
}

/*求best数组函数,求解s-1路径上权值最大的边的终点*/
int Best(int s){
    if(father[s] == 1)
      return -1;
    if(best[s] != -1)
      return best[s];
    int tmp = Best(father[s]);
    if(tmp != -1 && G[father[tmp]][tmp] > G[father[s]][s])
      best[s] = tmp;
    else
      best[s] = s;
    return best[s];
}

void solve(){
    memset(father , -1 , sizeof(father));
    memset(vis , 0 , sizeof(vis));
    memset(edge , 0 , sizeof(edge));
    vis[1] = 1;/*把1这个点当成限制点*/
    int num = 0;/*把1限制点去掉以后的连通分支的个数*/
    ans = 0;

    /*先求最小num度限制树*/
    for(int i = 1 ; i <= cnt ; i++){
       if(!vis[i]){
         num++;
         ans += prime(i);
       }
    }

    /*再由m度限制生成树->k度生成树*/
    int minAdd;/*增加一条边改变的权值大小*/
    int change;/*记录回路上要删除的边的终点*/
    /*循环k-num次*/
    for(int i = num+1 ; i <= k && i <= cnt ; i++){
       memset(best , -1 , sizeof(best));/*初始化为-1*/
       /*求出best数组*/
       for(int j =1 ; j <= cnt ; j++){
          if(best[j] == -1 && father[j] != 1)
            Best(j);
       }
       minAdd = INF;/*初始化为INF*/
       for(int j = 1 ; j <= cnt ; j++){
          if(G[1][j] != INF && father[j] != 1){
            int a = best[j];
            int b = father[best[j]];
            int tmp = G[1][j]-G[a][b];
            if(tmp < minAdd){
              minAdd = tmp;
              change = j;
            }
          }
       }
       if(minAdd >= 0)/*要加上这一句*/
         break;
       ans += minAdd;
       int a = best[change];
       int b = father[change];
       G[a][b] = G[b][a] = INF;/*把这一条边去掉就是赋值为INF*/
       father[a] = 1;/*把a的父亲节点指向为限制点1*/
       G[a][1] = G[1][a] = G[change][1];/*新增加的一条边的权值*/
       G[1][change] = G[change][1] = INF;
    }
}

int main(){
   int v;
   string str1 , str2;
   m.clear();
   m["Park"] = 1;
   cnt = 1;/*初始化有一个点*/
   init();/*初始化*/
   scanf("%d" , &n);
   for(int i = 0 ; i < n ; i++){
      cin>>str1>>str2>>v;
      int a = m[str1];
      int b = m[str2];
      if(!a)
        m[str1] = a = ++cnt;
      if(!b)
        m[str2] = b = ++cnt;
      if(G[a][b] > v)/*a b 为点的编号，所以上面不能直接把m[str1] = 1*/
        G[a][b] = G[b][a] = v;
   }
   scanf("%d" , &k);
   solve();
   printf("Total miles driven: %d\n" , ans);
   return 0;
}