HDU 1072 Nightmare（广搜bfs）

Nightmare
Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 14388 Accepted Submission(s): 7001

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

Author
Ignatius.L
题目网址：(http://acm.hdu.edu.cn/showproblem.php?pid=1072)
翻译：
恶梦
时间限制：2000/1000 MS（Java / Others）内存限制：65536/32768 K（Java / Others）
总提交内容：14388接受提交内容：7001

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

鉴于迷宫和Ignatius的起始位置的布局，请告诉Ignatius他是否可以离开迷宫，如果可以的话，输出他必须用来找到迷宫出口的最短时间，否则输出-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：这个区域什么都没有，Ignatius可以走在上面。
2：Ignatius的开始位置，Ignatius开始逃离这个位置。
3：迷宫的出口，伊格内修斯的目标位置。
4：该区域包含一个Bomb-Reset-Equipment，Ignatius可以通过步行到这些区域来延迟爆炸时间。

输出
对于每个测试用例，如果Ignatius可以离开迷宫，你应该输出他需要的最短时间，否则你应该输出-1。
题意：
这个题也是一个迷宫问题，不过里面要多加一个变量时间，在炸弹爆炸前能出去，每走一步花一分钟，遇到4后时间变为6，求最后出去的最小步数，不能输出-1。
思路：
这个题是个迷宫问题要求输出出去的最小步数，这个题可以用广搜（bfs）来写这个题，但这个题要注意的是走过的还能走，所以不能把走过的标记下来，但是遇到4后要把4变成0，因为4只能走一次。
代码：

#include<iostream>
#include<string>
#include<queue>
#include<algorithm>
using namespace std;
int a[10][10];  //二维数组存图
int dx[4]={0,0,1,-1},dy[4]={1,-1,0,0};  //广搜方向
int N,M,sx,sy,ex,ey;
struct NODE
{
    int x;  //x坐标
    int y;  //y坐标
    int step;   //步数
    int t;  //时间
    friend bool operator < (NODE n1,NODE n2)
    {
        return n1.step > n2.step;   //从小到大排序
    }
};
bool judge(int x,int y) //判断是否能走
{
    if(x<1||y<1||x>N||y>M)
        return 1;
    if(a[x][y]==0)
        return 1;
    return 0;
}
int bfs()   //广搜算法
{
    priority_queue<NODE> q; //优先队列
    NODE cur,next;
    cur.x=sx;
    cur.y=sy;
    cur.step=0;
    cur.t=6;
    q.push(cur);
    while(!q.empty())
    {
        cur=q.top();
        q.pop();
        if(cur.x==ex&&cur.y==ey&&cur.t>0)   //到终点结束并返回
            return cur.step;
        for(int i=0;i<4;i++)    //四个方向遍历
        {
            int nx = cur.x + dx[i];
            int ny = cur.y + dy[i];
            int T=cur.t-1;
            if( judge(nx,ny) || T<=0)   //不能走或者时间到了
                continue;
            next.x = nx;
            next.y = ny;
            if(a[nx][ny]==4)    //如果为4时间变为6并变为0下次遍历时不能走
            {
                next.step = cur.step + 1;
                next.t=6;
                a[nx][ny]=0;
            }
            else
            {
                next.step = cur.step + 1;
                next.t=T;
            }
            q.push(next);
        }
    }
    return -1;
}
int main()
{
    int n;
    cin>>n;
    while(n--)
    {
        cin>>N>>M;
        for(int i=1;i<=N;i++)
        {
            for(int j=1;j<=M;j++)
            {
                cin>>a[i][j];
                if(a[i][j]==3)  //结束位置
                {
                    ex=i;
                    ey=j;
                }
                else if(a[i][j]==2) //开始位置
                {
                    sx=i;
                    sy=j;
                }
            }
        }
        int step=bfs();
        cout<<step<<endl;   //输出最小步数
    }
    return 0;
}

运行结果：

总结：
这个题就是一个广搜（bfs）的问题，不过这个题又不是完全的套用模板，还要进行改进，是一个练习bfs的一个好题。
杭电oj题目分类