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 = 220;
const double eps = 1e-9;

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

char map[105][105];
int vis[105][105];
int to[4][2]= {1,0,-1,0,0,1,0,-1};
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<0 || x>=n || y<0 || y>=n)
        return 1;
    if(map[x][y]=='#' || vis[x][y])
        return 1;
    return 0;
}

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 = 0;
    vis[a.x][a.y]=1;
    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 + '0'){
                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 = 0; i<4; i++){
            next = a;
            next.x+=to[i][0];
            next.y+=to[i][1];
            if(check(next.x,next.y))    continue;
            next.step=a.step+1;
            if(map[a.x][a.y] == 'S'){
                ++next.step;
            }
            vis[next.x][next.y] = 1;
            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 = 0; i<4; i++){
            int _x = x + to[i][0];
            int _y = y + to[i][1];
            if(check(_x,_y))  continue;
            if(map[_x][_y] != '#'){
                vis[_x][_y] = 1;
                dfs(_x,_y);
            }
    }
}
int main(){
    int i,j,cc,s_flag;
    while(EOF != scanf("%d%d",&n,&m)){
        if(n == 0 && m == 0)    break;
        s_flag = 0;
        node S[6];
        for(i = 0; i<n; i++)
            scanf("%s",map[i]);
        for(i = 0; i<n; i++){
            for(j = 0; 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,0,sizeof(vis));
        vis[sx][sy] = 1;
        dfs(sx,sy);
        int kkk[11];
        bool flag = false;
        memset(kkk, 0, sizeof(kkk));
        for(i = 0; i < n; ++i){
            for(j = 0; j < n; ++j){
                if(map[i][j] >= '1' && map[i][j] <= '9' && vis[i][j]){
                    kkk[map[i][j] - '0'] = 1;
                }
            }
        }
        for(i = 1; i <= m; ++i){
            if(!kkk[i]) break;
        }
        if(i == m + 1)  flag = true;

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