1000 Nightmare（搜索）

1000 Nightmare       

Problem A

Time Limit : 2000/1000ms (Java/Other)   Memory Limit : 65536/32768K (Java/Other)

Total Submission(s) : 24   Accepted Submission(s) : 14

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

 

译文：

问题描述

伊格纳修斯昨晚做了一场噩梦。他发现自己处于一个迷宫中，并对他进行定时炸弹袭击。迷宫有一个出口，伊格纳修斯应该在炸弹爆炸之前离开迷宫。炸弹的最初爆炸时间设定为6分钟。为了防止炸弹爆炸，Ignatius必须缓慢移动，即从一个区域移动到最近的区域（也就是说，如果Ignatius现在站在（x，y），他只能在（x + 1， y），（x-1，y），（x，y + 1）或（x，y-1）在下一分钟）他需要1分钟。迷宫中的某些区域包含一个Bomb-Reset-Equipment。他们可以将爆炸时间重置为6分钟。

鉴于迷宫和伊格纳修斯的起始位置的布局，请告诉伊格内修斯他是否可以离开迷宫，如果可以的话，输出他必须用来找到迷宫出口的最短时间，否则输出-1。

以下是一些规则：
1。我们可以假设迷宫是一个2阵列。
每一分钟，伊格纳修斯只能到达最近的一个区域，他不应该走出边境，当然他也不能走在墙上。
3.如果伊格纳修斯在爆炸时间变为0时到达出口，他就无法走出迷宫。
4.当爆炸时间变为0时，如果伊格纳修斯到达包含炸弹 - 休息设备的区域，他就无法使用该设备重置炸弹。
5.炸弹重置设备可以根据需要多次使用，如果需要，Ignatius可以根据需要多次到达迷宫中的任何区域。
6.重置爆炸时间的时间可以忽略，换句话说，如果Ignatius到达包含Bomb-Rest-Equipment的区域，并且爆炸时间大于0，则爆炸时间将重置为6。

 

 

输入

输入包含几个测试用例。输入的第一行是单个整数T，它是测试用例的数量。T测试案例如下。每个测试用例以两个整数N和M（1 <= N，Mm = 8）开始，表示迷宫的大小。然后是N行，每行包含M个整数。该阵列表示迷宫的布局。有五个整数表示迷宫中不同类型的区域：0：该区域是一堵墙，Ignatius不应该在它上面行走。1：该地区什么都没有，伊格内修斯可以走在上面。2：Ignatius的开始位置，Ignatius开始逃离这个位置。3：迷宫的出口，伊格内修斯的目标位置。4：该区域包含一个Bomb-Reset-Equipment，Ignatius可以通过步行到这些区域来延迟爆炸时间。

 

 

产量

对于每个测试用例，如果Ignatius可以离开迷宫，你应该输出他需要的最短时间，否则你应该输出-1。

 

思路：

这是一道搜索题，对于题中给出的条件要一一列举，用队列的方法。

代码：

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue> //队列的头文件
using namespace std;
int sx,sy,ex,ey;//起始坐标和终点坐标
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};//可以移动的四个位置
int map[10][10];
int n,m;
struct node
{
    int x,y;
    int step;
    int time;
};
bool judge(node s)
{
    if(s.x<0||s.y<0||s.x>=n||s.y>=m||map[s.x][s.y]==0)
    {
        return false;
    }
    if(s.time<2)
    {
        return false;
    }
    return true;
}
void bfs()
{
    node p,q;
    p.x=sx;
    p.y=sy;
    p.step=0;
    p.time=6;
    queue<node>Q;//定义node队列
    Q.push(p);   //将p压入队列尾部 
    while(!Q.empty())//队列不为空
    {
        q=Q.front();//返回队首元素，但不删除
        Q.pop();//删除队首元素，但不返回
        if(q.x==ex&&q.y==ey)
        {
            cout<<q.step<<endl;
            return ;
        }
        for(int i=0;i<4;i++)
        {
            p.x=q.x+dir[i][0];
            p.y=q.y+dir[i][1];
            p.time=q.time;
            if(judge(p))//判断p是否满足条件
            {
                if(map[p.x][p.y]==4)
                {
                    p.step=q.step+1;
                    p.time=6;
                    map[p.x][p.y]=0;
                }
                else
                {
                    p.step=q.step+1;
                    p.time=p.time-1;
                }
                Q.push(p);
            }
        }
    }
    cout<<"-1"<<endl;
    return ;
}
int main()
{
   int t;
   cin>>t;
   while(t--)
   {
       cin>>n>>m;
       for(int i=0;i<n;i++)
       {
           for(int j=0;j<m;j++)
           {
               cin>>map[i][j];
               if(map[i][j]==2)
               {
                   sx=i;sy=j;
               }
               if(map[i][j]==3)
               {
                   ex=i;
                   ey=j;
               }
           }
       }
       bfs();
   }
   return 0;
}