HDU 3681 Prison Break（状态压缩dp + BFS）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3681

前些天花时间看到的题目，但写出不来，弱弱的放弃了。没想到现在学弟居然写出这种代码来，大吃一惊附加敬仰之情。这里借用下他的成果，好好学习吧，骚年***

Sample Input

5 5

GDDSS

SSSFS

SYGYS

SGSYS

SSYSS

0 0

 

Sample Output

4

题意：给出矩阵（作为监狱）和在监狱中的一个装有电池的机器人,其中

• F为出发点，图中只有一个，且初始状态下机器人在此处电池为满电量；
• D为障碍物，不可走；
• S为空格子，机器可自由通过；
• G为充电点，只能充电一次，且一次能充满电池，经过G可作为S不充电，充电后G变为S；
• Y点为电闸，机器人可通过，且通过后变为S。

机器人通过所有Y后才能飞出监狱够逃走。在此之前他只能一个格子一个格子(向上、向下、向左、向右)地走动，而且每走一格消耗一格电池的电量，如果电池没电他就不能移动。问他的电池满电量状态下至少有几格电量才能使他逃出监狱？

该题的思路来源于它的数据，Y+G的数量小于15。所以从这里就可以考虑状态压缩DP。

电量求法采用的是二分查找。

整幅图显然要进行处理，Y,F都是必须要互相连通的，若不连通，显然是无解，反之必然有解。将Y,F,G对应的编号，起点F定位0，Y,G依次编号，将Y和G分成两块编号，那么接下来对于电闸Y和充电点G的判断就会比较容易，只要直接判断编号范围即可。

接下来就是求对于每个点的最短路了，再求完最短路后，如发现Y,F间某2点无法连通，则无解，否则有解。

若有解，则进行状态压缩DP，对于每一个maxt（当前的电池满格电量），途中大于maxt的，则不能更新，反正则可以进行判断并更新。若每个Y点都已经遍历过，则判断该状态下是否可行,可行则返回TRUE。

代码如下：

 #include<algorithm>
 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<queue>
 using namespace std;
 const int INF=<<;
 int as[];
 void st()
 {
     int i, k=;
     for(i=; i<; i*=)
     {
         as[i]=++k;
     }
 }
 struct Node
 {
     int x, y;
 } nod[];
 struct POS
 {
     POS() {}
     POS(int a,int b,int c)
     {
         x=a,y=b,now=c;
     }
     int x, y, now;
 } pos;
 int n, m, p, q, sx, sy;
 int dis[][], dp[][], the[][], num, ll;
 char map[][];
 bool ans;
 void init()            //对每个Y,F,G编号
 {
     int i, j;
     memset(the,-,sizeof(the));
     p=;
     for(i=; i<n; i++)
     {
         for(j=; j<m; j++)
         {
             if(map[i][j]=='F')
                 sx=i, sy=j;
             if(map[i][j]=='Y')
             {
                 nod[p].x=i, nod[p].y=j;
                 the[i][j]=p;   //该数组可用于判断某个坐标的点的编号
                 p++;
             }
         }
     }
     q=p;
     for(i=; i<n; i++)
         for(j=; j<m; j++)
         {
             if(map[i][j]=='G')
             {
                 nod[q].x=i, nod[q].y=j;
                 the[i][j]=q;
                 q++;
             }
         }
     nod[].x=sx, nod[].y=sy;
     the[sx][sy]=;
     for(i=; i<q; i++)
         for(j=; j<q; j++)
         {
             if(i==j)
                 dis[i][j]=;
             else dis[i][j]=INF;
         }
 }
 int dx[]= {,,-,};
 int dy[]= {,,,-};
 bool can(int x,int y)
 {
     if(x<||x>=n||y<||y>=m||map[x][y]=='D')
         return false;
     return true;
 }
 void bfs()        //BFS求Y,F,G之间的最短路
 {
     int i, j, nx, ny, x, y, now;
     POS tmp;
     bool vis[][];
     for(i=; i<q; i++)
     {
         memset(vis,,sizeof(vis));
         queue<POS> qq;
         qq.push(POS(nod[i].x,nod[i].y,));
         while(!qq.empty())
         {
             tmp=qq.front();
             qq.pop();
             x=tmp.x, y=tmp.y, now=tmp.now;
             for(j=; j<; j++)
             {
                 nx=x+dx[j], ny=y+dy[j];
                 if(can(nx,ny)&&!vis[nx][ny])
                 {
                     if(the[nx][ny]!=-)
                         dis[i][the[nx][ny]]=now+;
                     vis[nx][ny]=true;
                     qq.push(POS(nx,ny,now+));
                 }
             }
         }
     }
     for(i=; i<p; i++)
         for(j=; j<p; j++)
             if(dis[i][j]==INF) ans=false;
 }
 bool deal(int maxt)        //状态压缩DP判断是否可行
 {
     int i, j, k, tmp;
     for(i=; i<num; i++)
         for(j=; j<q; j++)
             dp[i][j]=INF;
     dp[][]=;
     int ed;
     for(i=; i<num; i++)
     {
         for(j=i; j>; j-=j&(-j))
         {
             tmp=j&(-j);
             ed=as[tmp];
             for(k=; k<q; k++)
                 if(dp[i^tmp][k]+dis[k][ed]<=maxt)
                     dp[i][ed]=min(dp[i^tmp][k]+dis[k][ed],dp[i][ed]);
             if(ed>=p&&dp[i][ed]!=INF)
                 dp[i][ed]=;
             if(dp[i][ed]!=INF)
             {
                 for(k=; k<p; k++)
                 {
                     if(dp[i][ed]+dis[ed][k]<=maxt)
                         dp[i|(<<(k-))][k]=min(dp[i|(<<(k-))][k],dp[i][ed]+dis[ed][k]);
                 }
                 for(; k<q; k++)
                 {
                     if((<<(k-))&i) continue;
                     if(dp[i][ed]+dis[ed][k]<=maxt)
                         dp[i|(<<(k-))][k]=;
                 }
             }
         }
         if(i%ll==ll-)
         {
             for(j=; j<q; j++)
                 if(dp[i][j]<=maxt) return true;
         }
     }
     return false;
 }
 int main()
 {
     int i, j, tmp, l, r;
     st();
     while(scanf("%d%d",&n,&m)!=EOF)
     {
         if(n==&&m==) break;
         for(i=; i<n; i++)
             scanf("%s",map[i]);
         init();
         ans=true;
         bfs();
         num=<<(q-);    //所有状态个数
         l=, r=;
         ll=<<(p-);
         if(ans)            //ans为true表示，Y和F间两两都是连通的
         {
             while(l<r)            //二分求解
             {
                 m=(l+r)>>;
                 if(deal(m))
                     r=m;
                 else l=m+;
             }
         }
         if(ans) printf("%d\n",r);
         else puts("-1");
     }
     return ;
 }