【BZOJ 2595】2595: [Wc2008]游览计划 （状压DP+spfa，斯坦纳树？）

2595: [Wc2008]游览计划

Time Limit: 10 Sec  Memory Limit: 256 MBSec  Special Judge
Submit: 1572  Solved: 739

Description

Input

第一行有两个整数，N和 M，描述方块的数目。 
接下来 N行， 每行有 M 个非负整数， 如果该整数为 0， 则该方块为一个景点；
否则表示控制该方块至少需要的志愿者数目。 相邻的整数用 （若干个） 空格隔开，
行首行末也可能有多余的空格。

Output

由 N + 1行组成。第一行为一个整数，表示你所给出的方案
中安排的志愿者总数目。 
接下来 N行，每行M 个字符，描述方案中相应方块的情况： 
z  ‘_’（下划线）表示该方块没有安排志愿者； 
z  ‘o’（小写英文字母o）表示该方块安排了志愿者； 
z  ‘x’（小写英文字母x）表示该方块是一个景点； 
注：请注意输出格式要求，如果缺少某一行或者某一行的字符数目和要求不
一致（任何一行中，多余的空格都不允许出现） ，都可能导致该测试点不得分。

Sample Input

4 4
0 1 1 0
2 5 5 1
1 5 5 1
0 1 1 0

Sample Output

6
xoox
___o
___o
xoox

HINT

对于100%的数据，N,M,K≤10，其中K为景点的数目。输入的所有整数均在[0,2^16]的范围内

Source

Ljcc930提供SPJ

【分析】

　　又是不会的一题啦~

　　斯坦纳树？smg？

　　刚开始看题可能觉得是最小生成树吧？但是并不是的。

　　

　　一个条路径可能在最小生成树上面算几次，但是在这题上只算一次。

　　然后就是斯坦纳树？？【长姿势？？

　　反正就是，要覆盖的点很少<=10,可以状压这个，f[i][j][t]表示和(i,j)这个格子联通的需覆盖点集合为t的最小代价。

　　两个方程：

　　$f[i][j][t]=min(f[i][j][s]+f[i][j][t-ss])$ s是t的子集。

　　$f[i][j][t]=min(f[x][y][t]+a[i][j])$ (i,j)与(x,y)相邻

　　第二个式子啊不是普通的dp啊，转移状态的有环的！！但是，不怕，肯定是小的转到大的，然后一脸最短路的样子，就可以用spfa解决的。

 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 #include<queue>
 using namespace std;
 #define INF 0xfffffff

 int a[][],num[][],f[][][];

 struct node {int x,y,d;};
 node g[][][];
 queue<node > q;
 bool inq[][];

 int bx[]={,,,-,},
     by[]={,,,,-};

 void dfs(int x,int y,int k)
 {
     if(!k) return;inq[x][y]=;
     dfs(g[x][y][k].x,g[x][y][k].y,g[x][y][k].d);
     if(g[x][y][k].x==x&&g[x][y][k].y==y) dfs(x,y,k-g[x][y][k].d);
 }

 int main()
 {
     int n,m,cnt=;
     scanf("%d%d",&n,&m);
     memset(f,,sizeof(f));
     for(int i=;i<=n;i++)
      for(int j=;j<=m;j++)
      {
          scanf("%d",&a[i][j]);
          if(a[i][j]==)
          {
              num[i][j]=++cnt;
              f[i][j][<<cnt-]=;
              g[i][j][<<cnt-].x=g[i][j][<<cnt-].y=g[i][j][<<cnt-].d=;
          }
      }
     for(int i=;i<=n;i++)
      for(int j=;j<=m;j++) f[i][j][]=;
     for(int k=;k<=(<<cnt)-;k++)
     {
         memset(inq,,sizeof(inq));
         for(int ss=k;ss;ss=(ss-)&k)
         {
             for(int i=;i<=n;i++)
              for(int j=;j<=m;j++) //if(a[i][j]==0)
              {
                  if(f[i][j][k]>f[i][j][ss]+f[i][j][k-ss]-a[i][j])
                 {
                     f[i][j][k]=f[i][j][ss]+f[i][j][k-ss]-a[i][j];
                     node nw;
                     nw.x=i;nw.y=j;nw.d=ss;
                     g[i][j][k]=nw;
                 }
                 if(f[i][j][k]<INF) {node nw;nw.x=i;nw.y=j;nw.d=f[i][j][k];inq[i][j]=;q.push(nw);}
              }

         }
         while(!q.empty())
         {
             node x=q.front();
             for(int i=;i<=;i++)
             {
                 int nx=x.x+bx[i],ny=x.y+by[i];
                 if(nx<||nx>n||ny<||ny>m) continue;
                 if(f[nx][ny][k]>f[x.x][x.y][k]+a[nx][ny])
                 {
                     f[nx][ny][k]=f[x.x][x.y][k]+a[nx][ny];
                     node nw;
                     nw.x=nx;nw.y=ny;//nw.d=f[nx][ny][k];
                     // g[nx][ny][k]=g[x.x][x.y][k];
                     g[nx][ny][k].x=x.x;g[nx][ny][k].y=x.y;g[nx][ny][k].d=k;
                     if(!inq[nx][ny])
                     {
                         inq[nx][ny]=;
                         q.push(nw);
                     }
                 }
             }
             q.pop();inq[x.x][x.y]=;
         }
     }
     memset(inq,,sizeof(inq));
     bool ok=;
     for(int i=;i<=n;i++)
     {
         for(int j=;j<=m;j++) if(a[i][j]==)
         {
             printf("%d\n",f[i][j][(<<cnt)-]);
             dfs(i,j,(<<cnt)-);
             ok=;break;
         }
         if(ok) break;
     }

     for(int i=;i<=n;i++)
     {
         for(int j=;j<=m;j++)
         {
             if(a[i][j]==) printf("x");
             else if(inq[i][j]) printf("o");
             else printf("_");
         }
         printf("\n");
     }
     return ;
 }

2017-04-05 19:28:31