Nightmare-BFS

Nightmare

Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u

Submit  Status

Description

Ignatius had a nightmare last night. He found himself in a labyrinth with a time bomb on him. The labyrinth has an exit, Ignatius should get out of the labyrinth before the bomb explodes. The initial exploding time of the bomb is set to 6 minutes. To prevent the bomb from exploding by shake, Ignatius had to move slowly, that is to move from one area to the nearest area(that is, if Ignatius stands on (x,y) now, he could only on (x+1,y), (x-1,y), (x,y+1), or (x,y-1) in the next minute) takes him 1 minute. Some area in the labyrinth contains a Bomb-Reset-Equipment. They could reset the exploding time to 6 minutes. 

Given the layout of the labyrinth and Ignatius' start position, please tell Ignatius whether he could get out of the labyrinth, if he could, output the minimum time that he has to use to find the exit of the labyrinth, else output -1. 

Here are some rules: 
1. We can assume the labyrinth is a 2 array. 
2. Each minute, Ignatius could only get to one of the nearest area, and he should not walk out of the border, of course he could not walk on a wall, too. 
3. If Ignatius get to the exit when the exploding time turns to 0, he can't get out of the labyrinth. 
4. If Ignatius get to the area which contains Bomb-Rest-Equipment when the exploding time turns to 0, he can't use the equipment to reset the bomb. 
5. A Bomb-Reset-Equipment can be used as many times as you wish, if it is needed, Ignatius can get to any areas in the labyrinth as many times as you wish. 
6. The time to reset the exploding time can be ignore, in other words, if Ignatius get to an area which contain Bomb-Rest-Equipment, and the exploding time is larger than 0, the exploding time would be reset to 6. 

  

Input

The input contains several test cases. The first line of the input is a single integer T which is the number of test cases. T test cases follow. 
Each test case starts with two integers N and M(1<=N,Mm=8) which indicate the size of the labyrinth. Then N lines follow, each line contains M integers. The array indicates the layout of the labyrinth. 
There are five integers which indicate the different type of area in the labyrinth: 
0: The area is a wall, Ignatius should not walk on it. 
1: The area contains nothing, Ignatius can walk on it. 
2: Ignatius' start position, Ignatius starts his escape from this position. 
3: The exit of the labyrinth, Ignatius' target position. 
4: The area contains a Bomb-Reset-Equipment, Ignatius can delay the exploding time by walking to these areas. 

  

Output

For each test case, if Ignatius can get out of the labyrinth, you should output the minimum time he needs, else you should just output -1. 

  

Sample Input

        
        
        
        

         
         
         
         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 
        
        
        
        

  

Sample Output

        
        
        
        

         
         
         
         4
-1
13 
        
        
        
        

  

题目中描述的是走过的路径还可以重新再走，也就是说走过的路径不需要标记。但是当遇到重设爆炸时间的点需要标记，不能再从这里经过。如果遇到爆炸点不标记的话，那么这个点就可以无限次数的走，剩余时间会被重设为6，那么剩余时间永远都不会消耗完，那么这个程序也就成了一个死循环。

#include <queue>
#include <string.h>
#include <iostream>
using namespace std;

#define MAXN 10
//定义方向，顶部开始，顺时针
int dir[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
int n, m;
int a[MAXN][MAXN];
int vis[MAXN][MAXN];
int startX, startY; //开始位置
int endX, endY;     //结束位置

struct Node
{
    int x;
    int y;
    int leftTime; //剩余时间
    int cnt;      //走到当前位置共走了多少步
}now, nextStep;

//判断结点能否通过
bool isPracticable(Node node)
{
    //当超出边界，或者剩余时间为0，或者遇到障碍物都不能再通过
    if (node.x < 0 || node.x > n || node.y < 0 || node.y > m || node.leftTime <= 0 || a[node.x][node.y] == 0 || vis[node.x][node.y]) {
        return 0;
    }
    return 1;
}

int BFS()
{
    memset(vis, 0, sizeof(vis));
    queue<Node> Q;
    now.x = startX;
    now.y = startY;
    now.leftTime = 6;
    now.cnt = 0;
    
    Q.push(now);
    
    while (!Q.empty()) {
        //获取队列首部元素
        now = Q.front();
        
        if (now.x == endX && now.y == endY) {
            return now.cnt;
        }
        
        for (int i = 0; i < 4; i++) {   //按照上、右、下、左的方向搜索，搜索方向可随意，但是要保证四个方向都被搜索一遍
            nextStep.x = now.x + dir[i][0];
            nextStep.y = now.y + dir[i][1];
            nextStep.cnt = now.cnt + 1;
            nextStep.leftTime = now.leftTime - 1;
            
            if (isPracticable(nextStep)) {
                if (a[nextStep.x][nextStep.y] == 4) {
                    nextStep.leftTime = 6;             //当走到重设爆炸时间点的时候，把剩余时间重新设置为6
                    vis[nextStep.x][nextStep.y] = 1;   //把能够重新设置爆炸时间的位置标记为1，此处只能走一次
                }
                Q.push(nextStep);
            }
        }
        //把对首元素排出队列
        Q.pop();
    }
    return -1;
}


int main(int argc, const char * argv[]) {
    
    int T;
   
    cin >> T;
    while (T--) {
        
        cin >> n >> m;
        memset(a, 0, sizeof(a));
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                cin >> a[i][j];
                if (a[i][j] == 2) { //记录开始点
                    startX = i;
                    startY = j;
                } else if (a[i][j] == 3) {  //记住结束点
                    endX = i;
                    endY = j;
                }
            }
        }
        cout << BFS() << endl;
    }
    return 0;
}