ZOJ - 3865 Superbot （广搜）

Superbot

---

Time Limit: 2 Seconds       Memory Limit: 65536 KB

---

Superbot is an interesting game which you need to control the robot on an N*M grid map.

As you see, it's just a simple game: there is a control panel with four direction left (1^st position), right (2^nd), up (3^rd) and down (4^th). For each second, you can do exact one of the following operations:

• Move the cursor to left or right for one position. If the cursor is on the 1^st position and moves to left, it will move to 4^th position; vice versa.
• Press the button. It will make the robot move in the specific direction.
• Drink a cup of hot coffee and relax. (Do nothing)

However, it's too easy to play. So there is a little trick: Every P seconds the panel will rotate its buttons right. More specifically, the 1^stposition moves to the 2^nd position; the 2^nd moves to 3^rd; 3^rd moves to 4^th and 4^th moves to 1^st. The rotating starts at the beginning of the second.

Please calculate the minimum time that the robot can get the diamond on the map.

At the beginning, the buttons on the panel are "left", "right", "up", "down" respectively from left to right as the picture above, and the cursor is pointing to "left".

Input

There are multiple test cases. The first line of input contains an integer T indicating the number of test cases. For each test case:

The first line contains three integers N, M (2 <= N, M <= 10) and P (1 <= P <= 50), which represent the height of the map, the width of the map and the period that the panel changes, respectively.

The following lines of input contains N lines with M chars for each line. In the map, "." means the empty cell, "*" means the trap which the robot cannot get in, "@" means the initial position of the robot and "$" means the diamond. There is exact one robot and one diamond on the map.

Output

For each test case, output minimum time that the robot can get the diamond. Output "YouBadbad" (without quotes) if it's impossible to get the diamond.

Sample Input

4
3 4 50
@...
***.
$...
5 5 2
.....
..@..
.*...
$.*..
.....
2 3 1
*.@
$.*
5 5 2
*****
..@..
*****
$....
.....

Sample Output

12
4
4
YouBadbad

Hint

For the first example: 
0s: start
1s: cursor move right (cursor is at "right")
2s: press button (robot move right)
3s: press button (robot move right)
4s: press button (robot move right)
5s: cursor move right (cursor is at "up")
6s: cursor move right (cursor is at "down")
7s: press button (robot move down)
8s: press button (robot move down)
9s: cursor move right (cursor is at "left")
10s: press button (robot move left)
11s: press button (robot move left)
12s: press button (robot move left)

For the second example:
0s: start
1s: press button (robot move left)
2s: press button (robot move left)
--- panel rotated ---
3s: press button (robot move down, without changing cursor)
4s: press button (robot move down)

For the third example:
0s: start
1s: press button (robot move left)
--- panel rotated ---
2s: press button (robot move down)
--- panel rotated ---
3s: cursor move left (cursor is at "right")

--- panel rotated ---

题意：机器人从起点走到终点，不能走陷阱，每一秒机器人有三种操作

1 把游标向右或向左移动一个格子，如果游标在第一个位置，向左移动则到第四个位置

2 按下游标，按照游标此时的方向走一个格子

3 休息

每经过P秒，控制面板整体向右旋转一次

思路：很容易想到广搜，但是判断是否走过某一个点的时候不能只根据坐标来判断了，再加两个状态，在这一点游标所指的方向和p%t，再用一个pos变量来记录游标在控制面板的哪一个位置

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <queue>
#include <string.h>

using namespace std;

char mp[15][15];
bool vis[15][15][10][55];
int sx,sy,ex,ey;
int n,m,p;
//控制面板上4种方向的顺序 
int to[4][4][2] = {0, -1, 0, 1, -1, 0, 1, 0,  
    1, 0, 0, -1, 0, 1, -1, 0,  
    -1, 0, 1, 0, 0, -1, 0, 1,  
    0, 1, -1, 0, 1, 0, 0, -1
};  

struct node{
	int x,y,dir,pos,step;
	node(){};
	node(int _x,int _y,int _dir,int _pos,int _step){
		this -> x = _x;
		this -> y = _y;
		this -> dir = _dir;
		this -> pos = _pos;
		this -> step = _step;
	}
};
//判断方向 
int judge(int x,int y){
	if(x == 0 && y == -1){
		return 0;
	}
	else if(x == 0 && y == 1){
		return 1;
	}
	else if(x == -1 && y == 0){
		return 2;
	}
	else if(x == 1 && y == 0){
		return 3;
	}
} 
bool check(int x,int y){
	if(x < 0 || y < 0 || x >= n || y >= m || mp[x][y] == '*'){
		return false;
	}
	return true;
}
void bfs(){
	queue<node> q;
	int nx,ny,ndir,npos,nstep;
	int ax,ay;
	q.push(node(sx,sy,0,0,0));
	vis[sx][sy][0][0] = 1;
	struct node temp;
	
	while(!q.empty()){
		temp = q.front();
		q.pop();
		
		if(temp.x == ex && temp.y == ey){
			printf("%d\n",temp.step);
			return;
		}
		
		//机器人走一个格子
		ax = to[(temp.step / p) % 4][temp.pos][0];
		ay = to[(temp.step / p) % 4][temp.pos][1];
		ndir = judge(ax,ay);
		nx = temp.x + ax;
		ny = temp.y + ay;
		npos = temp.pos;	
		nstep = temp.step + 1;	
		if(check(nx,ny) && !vis[nx][ny][ndir][nstep % p]){
			q.push(node(nx,ny,ndir,npos,nstep));
			vis[nx][ny][ndir][nstep % p] = 1;
		}
		
		//左移
		npos = (temp.pos - 1 + 4) % 4;
		ax = to[(temp.step / p) % 4][npos][0];
		ay = to[(temp.step / p) % 4][npos][1];
		ndir = judge(ax,ay);
		nx = temp.x;
		ny = temp.y;
		nstep = temp.step + 1;
		if(!vis[nx][ny][ndir][nstep % p]){
			q.push(node(nx,ny,ndir,npos,nstep));
			vis[nx][ny][ndir][nstep % p] = 1;
		}
		
		//右移
		npos = (temp.pos + 1 + 4) % 4;
		ax = to[(temp.step / p) % 4][npos][0];
		ay = to[(temp.step / p) % 4][npos][1];
		ndir = judge(ax,ay);
		nx = temp.x;
		ny = temp.y;
		nstep = temp.step + 1;
		if(!vis[nx][ny][ndir][nstep % p]){
			q.push(node(nx,ny,ndir,npos,nstep));
			vis[nx][ny][ndir][nstep % p] = 1;
		}
		
		//原地不动
		npos = temp.pos; 
		ax = to[(temp.step / p) % 4][npos][0];
		ay = to[(temp.step / p) % 4][npos][1];
		ndir = judge(ax,ay);
		nx = temp.x;
		ny = temp.y;
		nstep = temp.step + 1;
		if(!vis[nx][ny][ndir][nstep % p]){
			q.push(node(nx,ny,ndir,npos,nstep));
			vis[nx][ny][ndir][nstep % p] = 1;
		}

	}
	printf("YouBadbad\n");
}
int main(void){
	int t;
	scanf("%d",&t);
	
	while(t--){
		scanf("%d%d%d",&n,&m,&p);
		for(int i = 0; i < n; i++){
			scanf("%s",mp[i]);
			for(int j = 0; j < m; j++){
				if(mp[i][j] == '@'){
					sx = i;
					sy = j;
				}
				if(mp[i][j] == '$'){
					ex = i;
					ey = j;
				}
			}
		}
		memset(vis,false,sizeof(vis));
		bfs();
	}
}