HDU 5025Saving Tang Monk BFS + 二进制枚举状态

3A的题目，第一次TLE，是因为一次BFS起点到终点状态太多爆掉了时间。

第二次WA，是因为没有枚举蛇的状态。

解体思路：

因为蛇的数目是小于5只的，那就首先枚举是否杀死每只蛇即可。

然后多次BFS，先从起点到第一把钥匙，不能往回走，要用VIS数组标记。

第二次从第一把钥匙走到第二把钥匙。

最后一次从最后一把钥匙走到终点即可。

Tips 1: 在每次BFS过程中使用优先队列保证每次是最小步长的状态。

Tips2 :使用二进制枚举蛇的状态

Tips3:首先使用DFS判断是否绝对有解，如果无解输出"impossible"，如果有解则继续。

Tips4:多次 BFS,而不是一次BFS，否则会导致状态太多TLE

代码如下：

 //#pragma comment(linker, "/STACK:16777216") //for c++ Compiler
 #include <stdio.h>
 #include <iostream>
 #include <cstring>
 #include <cmath>
 #include <stack>
 #include <queue>
 #include <vector>
 #include <algorithm>
 #define ll long long
 #define Max(a,b) (((a) > (b)) ? (a) : (b))
 #define Min(a,b) (((a) < (b)) ? (a) : (b))
 #define Abs(x) (((x) > 0) ? (x) : (-(x)))
 using namespace std;

 const int INF = 0x3f3f3f3f;
 const int MAXN = ;
 const double eps = 1e-;

 struct node{
     int x,y,step;
 };

 char map[][];
 int vis[][];
 int to[][]= {,,-,,,,,-};
 int n,m,sx,sy,ex,ey,ans;

 bool operator < (node a, node b){
     return a.step > b.step;
 }

 int check(int x,int y){
     if(x< || x>=n || y< || y>=n)
         return ;
     if(map[x][y]=='#' || vis[x][y])
         return ;
     return ;
 }

 void bfs(int sx, int sy, int k){
     int i;
     priority_queue <node> Q;
     node a,next;
     a.x = sx;
     a.y = sy;
     a.step = ;
     vis[a.x][a.y]=;
     Q.push(a);
     while(!Q.empty()){
         a = Q.top();
         //printf("x = %d y = %d step = %d\n",a.x,a.y,a.step);
         Q.pop();
         if(k <= m){
             if(map[a.x][a.y] == k + ''){
                 ans += a.step;
                 ex = a.x;
                 ey = a.y;
                 //printf("%d %d cur _ ans = %d\n",ex, ey,ans);
                 return;
             }
         } else{
             if(map[a.x][a.y] == 'T'){
                 ans += a.step;
                 ex = a.x;
                 ey = a.y;
                 //printf("%d %d cur _ ans = %d\n",ex, ey,ans);
                 return;
             }
         }
         for(i = ; i<; i++){
             next = a;
             next.x+=to[i][];
             next.y+=to[i][];
             if(check(next.x,next.y))    continue;
             next.step=a.step+;
             if(map[a.x][a.y] == 'S'){
                 ++next.step;
             }
             vis[next.x][next.y] = ;
             Q.push(next);
         }
         if(map[a.x][a.y] == 'S'){
             map[a.x][a.y] = '.';
         }
     }
     ans =INF;
     return ;
 }

 void dfs(int x, int y){
     for(int i = ; i<; i++){
             int _x = x + to[i][];
             int _y = y + to[i][];
             if(check(_x,_y))  continue;
             if(map[_x][_y] != '#'){
                 vis[_x][_y] = ;
                 dfs(_x,_y);
             }
     }
 }
 int main(){
     int i,j,cc,s_flag;
     while(EOF != scanf("%d%d",&n,&m)){
         if(n ==  && m == )    break;
         s_flag = ;
         node S[];
         for(i = ; i<n; i++)
             scanf("%s",map[i]);
         for(i = ; i<n; i++){
             for(j = ; j<n; j++){
                 if(map[i][j]=='K'){
                     sx = i;
                     sy = j;
                 }else if(map[i][j] == 'T'){
                     ex = i,ey = j;
                 }else if(map[i][j] == 'S'){
                     S[s_flag].x = i, S[s_flag++].y = j;
                 }
             }
         }
         memset(vis,,sizeof(vis));
         vis[sx][sy] = ;
         dfs(sx,sy);
         int kkk[];
         bool flag = false;
         memset(kkk, , sizeof(kkk));
         for(i = ; i < n; ++i){
             for(j = ; j < n; ++j){
                 if(map[i][j] >= '' && map[i][j] <= '' && vis[i][j]){
                     kkk[map[i][j] - ''] = ;
                 }
             }
         }
         for(i = ; i <= m; ++i){
             if(!kkk[i]) break;
         }
         if(i == m + )  flag = true;

         if(vis[ex][ey] ==  || !flag){
              printf("impossible\n");
              continue;
         }
         s_flag = ;
         for(i = ; i<n; i++){
                 for(j = ; j<n; j++){
                     if(map[i][j] == 'S'){
                         S[s_flag].x = i, S[s_flag++].y = j;
                     }
                 }
         }
         int minans=INF;
         for(cc = ; cc < ( << s_flag); ++cc){
             ans = ;
             for(i = ; i <s_flag; ++i){
                 if(( << i) & cc){
                     map[S[i].x][S[i].y] = '.';
                     ans++;
                 }
                 else {
                     map[S[i].x][S[i].y] = '#';
                 }
             }
             for(i = ; i < n; ++i){
                 for(j = ; j < n; ++j){
                     if(map[i][j] == 'K'){
                         ex = i;
                         ey = j;
                     }
                 }
             }
             for(int k = ; k <= m + ; ++k){
                 memset(vis, , sizeof(vis));
                 sx = ex;
                 sy = ey;
                 bfs(sx, sy, k);
             }
             minans=min(minans,ans);
         }
         printf("%d\n",minans);
     }
     return ;
 }