Nightmare之BFS解题报告

Nightmare

Time Limit: 2000/1000 MS(Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 5191    Accepted Submission(s): 2589

Problem Description

Ignatius had a nightmare last night. He found himself ina labyrinth with a time bomb on him. The labyrinth has an exit, Ignatius shouldget out of the labyrinth before the bomb explodes. The initial exploding timeof 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 nearestarea(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 areain the labyrinth contains a Bomb-Reset-Equipment. They could reset the explodingtime to 6 minutes.

Given the layout of the labyrinth and Ignatius' start position, please tellIgnatius whether he could get out of the labyrinth, if he could, output theminimum 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 heshould 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 getout of the labyrinth.
4. If Ignatius get to the area which contains Bomb-Rest-Equipment when theexploding 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 isneeded, Ignatius can get to any areas in the labyrinth as many times as youwish.
6. The time to reset the exploding time can be ignore, in other words, ifIgnatius get to an area which contain Bomb-Rest-Equipment, and the explodingtime is larger than 0, the exploding time would be reset to 6.

 

 

Input

The input contains several test cases. The first line ofthe input is a single integer T which is the number of test cases. T test casesfollow.
Each test case starts with two integers N and M(1<=N,Mm=8) which indicatethe 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 explodingtime by walking to these areas.

 

 

Output

For each test case, if Ignatius can get out of thelabyrinth, you should output the minimum time he needs, else you should justoutput -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个：

1， 迷宫用二维数组来表示；

2， 人走动时不能越界，不能在墙上走；

3， 当走到出口时，若剩余时间恰好为0，则失败；

4， 找到炸弹复位装置，若剩余时间恰好为0，则不能使用；

5， 炸弹复位装置可以使用若干次；

6， 只要走到复位装置所在位置，时间自动复置为6；

其中，数组中，0表示墙，1表示通道，2表示初始位置，3表示出口，4表示炸弹复位装置；

求走出迷宫所需要的最少步数，若不能在炸弹爆炸前走出来，输出-1.

大概思路：

       迷宫问题是经典的BFS问题，首先获取初始位置，调用队列，使其入队，定义方向数组，分别用（0，-1）、（-1,0）、（0,1）、（1,0）表示下上左右四个方向，对当前位置的四个方向进行判定，若能走得通，则使其入队。

代码如下：

#include <iostream>

#include <stdio.h>

#include <queue>

#define N 9

using namespace std;

 

intdir[4][2]={{0,-1},{-1,0},{0,1},{1,0}};   //定义方向下，左，上，右

int map[N][N];                  //输入迷宫布局

 

struct node                     //定义位置属性，当前坐标以及剩余时间和步数

{

   int x,y;

   int time,step;

};

node start;

 

int BFS(node start,int m,int n)

{

   int i;

   queue<node>q;

   node cur,next;

   start.time=6;

   start.step=0;

   q.push(start);

   while(!q.empty())

    {

       cur=q.front();

       q.pop();

       for(i=0;i<4;i++)               //广度优先遍历，对当前位置的四个方向分别遍历

       {

           next.x=cur.x+dir[i][0];

           next.y=cur.y+dir[i][1];

           next.time=cur.time-1;

           next.step=cur.step+1;

           if(next.x>=0&&next.x<n&&next.y>=0&&next.y<m&&map[next.x][next.y]!=0&&next.time>0)       //当前位置的下一步应该满足的条件

           {

               if(map[next.x][next.y]==3&&next.time>0) //如果是出口，返回步数

                    return cur.step+1;

                if(map[next.x][next.y]==4)              //如果位置值为4，表示复位装置，时间置为6

                {

                    next.time=6;

                    map[next.x][next.y]=0;

                }

                q.push(next);

           }

       }

    }

   return -1;

}

 

int main()

{

   int t,m,n,i,j,sum;

   cin>>t;

   while(t--)

    {

       cin>>n>>m;

       for(i=0;i<n;i++)

           for(j=0;j<m;j++)

           {

                cin>>map[i][j];

                if(map[i][j]==2)        //如果值为2，表示初始位置，用start来保存

                {

                    start.x=i;

                    start.y=j;

                }

           }

        sum=BFS(start,m,n);

        cout<<sum<<endl;

    }

   return 0;

}