HDU1072 Nightmare【可重复入队型BFS】

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

题目大意：某个人绑着炸弹，只能向4个方向走5步 ，5步没有走到终点就会爆炸，路途中有炸弹重置计时器，可以重新再走5步。
0：该区域是一堵墙，伊格纳修斯不应该在其上行走。
1：该区域不包含任何内容，伊格内修斯可以在上面行走。
2：依纳爵（Ignatius）的开始位置，依纳爵（Ignatius）从该位置开始逃跑。
3：迷宫的出口，依纳爵的目标位置。
4：该区域包含炸弹重置设备，伊格纳修斯可以步行到这些区域，以延迟爆炸时间。

解题思路:这道题呢，不同之处在于，每个格子都可以重复入队，炸弹重置器最多使用一次就失效，如果多次走到重置器处是无意义的。

#include <iostream>
#include <queue>
#include <string.h>
using namespace std;
int map[8][8]; //记录地图
int t,n,m; //测试总数，行，列
struct node{
	int x,y,step,limit; //limit为限制步数 
}S,T,Node;
int cz[8][8];
int x[4]={-1,1,0,0}; //上下左右 
int y[4]={0,0,-1,1};
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

bool judge(int x,int y){
	if(x < 0 || x >= n || y<0 || y >= m)  return false;
	if(map[x][y] == 0)  return false;
	return true;
}



int bfs(){
	queue <node> q;
	q.push(S);
	while(!q.empty())
	{
		node top= q.front();
		q.pop();
		if( top.x == T.x && top.y == T.y && top.limit >= 0)
		return top.step;
		if( map[top.x][top.y] == 4 && cz[top.x][top.y] >0)
		{
		    top.limit=5;
		    cz[top.x][top.y]--;
		}
		for(int i=0; i< 4;i++)
		{
			int newX=top.x+x[i];
			int newY=top.y+y[i];
			if(judge(newX,newY)== true && top.limit>=1)
			{
				Node.x=newX;
				Node.y=newY;
				Node.step=top.step+1;
				Node.limit=top.limit-1;
				q.push(Node);
			 } 
		}
	}	
	return -1;	
}

int main(int argc, char** argv) {
	cin >> t;
	while(t--)
	{
		cin >> n >> m;
		memset(map,0,sizeof(map));
		memset(cz,0,sizeof(cz));
		for(int i=0;i<n;i++)
		{
			for(int j=0;j<m;j++)
			{
				cin >> map[i][j];
				if(map[i][j] == 2)
				{
					S.x=i,S.y=j;
					S.step=0;
					S.limit=5;
				}
				if(map[i][j] == 4)
				{
					cz[i][j]=1; //最大可重置次数为1; 
				}
				if(map[i][j] == 3)
				{
					T.x=i,T.y=j;
				}
			}
		}
		cout << bfs() << endl;
	}
	return 0;
}