Nightmare

3
3 3
2 1 1
1 1 0
1 1 3
4 8
2 1 1 0 1 1 1 0
1 0 4 1 1 0 4 1
1 0 0 0 0 0 0 1
1 1 1 4 1 1 1 3
5 8
1 2 1 1 1 1 1 4 
1 0 0 0 1 0 0 1 
1 4 1 0 1 1 0 1 
1 0 0 0 0 3 0 1 
1 1 4 1 1 1 1 1 

4
-1
13

这道题判重方法比较特殊，因为一格可以反复的走，所以不能用bool判断，而是要根据炸弹剩余爆炸时间来判重，当走到一格的时候如果剩余时间小于等于之前在这个格子上的最大值，那么就不用把这个节点入队扩展状态了，因为这样做没有意义，除非剩余时间比原先的最大值要大，我们才会去将这个点加入队列然后更新改点剩余时间最大值。

#include<iostream>  
#include<cstring>  
#include<ctime>  
#include<algorithm>  
#include<cstdio>  
#include<queue>  
  
using namespace std;  
  
struct node  
{  
    int x,y;  
    int t;  
    int res;  
};  
  
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};  
int sx, sy;  
int rest[10][10];  
int g[10][10];  
int n,m;  
  
bool jud(node &k)  
{  
    if(k.x<0 || k.x>=n) return false;  
    if(k.y<0 || k.y>=m) return false;  
    if(g[k.x][k.y]==0) return false;  
    if(k.res==0) return false;  
    if(g[k.x][k.y]==4) k.res=6;  
    if(k.res<=rest[k.x][k.y]) return false;  
    rest[k.x][k.y]=k.res;  
    return true;  
}  
  
int bfs()  
{  
    queue<node> q;  
    node a,k;  
    int x,y;  
    a.x=sx,a.y=sy,a.t=0,a.res=6;  
    q.push(a);  
    while(!q.empty())  
    {  
        a=q.front();  
        q.pop();  
        for(int i=0; i<4; i++)  
        {  
            k.x = a.x + dir[i][0];  
            k.y = a.y + dir[i][1];  
            k.t = a.t + 1;  
            k.res = a.res - 1;  
            if(jud(k))  
            {  
                if(g[k.x][k.y]==3)  
                    return k.t;  
                q.push(k);  
            }  
        }  
    }  
    return -1;  
}  
  
int main()  
{  
    int t;  
    scanf("%d",&t);  
    while(~scanf("%d%d",&n,&m))  
    {  
        for(int i=0; i<n; i++)  
        {  
            for(int j=0; j<m; j++)  
            {  
                scanf("%d", &g[i][j]);  
                if(g[i][j]==2)  
                    sx=i, sy=j;  
            }  
        }  
        memset(rest,0,sizeof(rest));  
        rest[sx][sy]=6;  
        printf("%d\n",bfs());  
    }  
    return 0;  
}