HDU 1072 Nightmare

Problem 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
  
  
题意：2为起始位置。3为终点位置，1可以走，0不可走。从起始点开始最多走6步，如果遇到4.则重置为6，（每个4只能用一次），如果可以走通，输出最少的步数，如果不可以，则输出-1；
思路：bfs
#include<cstdio>
#include<iostream>
#include<queue>
using namespace std;
struct node
{
    int x,y;
    int step;
    int num;
};
int tx,ty;
int n,m;
int map[10][10];
int flog;
int dir[4][2]={0,1,0,-1,1,0,-1,0};
struct node e,s;
void bfs(int x,int y)
{
    queue<node>q;
    s.x=x;
    s.y=y;
    s.step=0;
    s.num=6;             初始值为6；
    q.push(s);
    while(!q.empty())
    {
        s=q.front();
        q.pop();
        if(s.num<=0)    如果s.num<=0则跳过改点。（即通过此点到达终点是不可能的）
            continue;
        if(map[s.x][s.y]==3&&s.num>0)  //结束条件：
        {
            printf("%d\n",s.step);
            flog=1;               //标记是否可以。
            break;
        }
    
        int i;
        for(i=0;i<4;i++)
        {
            e.x=s.x+dir[i][0];
            e.y=s.y+dir[i][1];
            if(e.x>=1&&e.x<=n&&e.y>=1&&e.y<=m&&map[e.x][e.y]!=0)     //判断边界，和坐标信息。
            {

                e.step=s.step+1;                     //步数+1； 
                if(map[e.x][e.y]==1)           //等于1，则正常加入队列
                {
                e.num=s.num-1;             //相应的num值——1；
                q.push(e);
                }
                if(map[e.x][e.y]==3)             //等于终点数
                {
                    e.num=s.num-1;
                    q.push(e);
                }
                if(map[e.x][e.y]==4)       //等于4 的话num值需要重置为6
                {
                    if(s.num<=1)             如果走到改点时num值恰巧为0，则跳过改点。
                    {
                        continue;
                    }
                    e.num=6;              else  重置为6
                     map[e.x][e.y]=0;         //标记为0 ，因为一个4只能用一次
                    q.push(e);       加入队列
                }
            }
        }

    }
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        flog=0;
        int i,j;
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=m;j++)
            {
                scanf("%d",&map[i][j]);
                if(map[i][j]==2)        //找到起始点
                {
                    tx=i;
                    ty=j;
                }
            }
        }
        bfs(tx,ty);            搜索bfs
        if(flog==0)              判断是否有解
            printf("-1\n");
    }
    return 0;
}