zoj 3865

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^thposition; 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^st position 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 ---
4s: press button (robot move left)

---

题目描述：

给定一张图，有一个键盘，通过键盘可以控制机器人的行走方向，

求从@到￥处的最短距离，'.'表示通路，；'*'表示不同，每隔p秒键盘旋转一次。

这题第一反应不知为何是深搜，其实深搜也可以吧，通过不同的行走方式，到达￥处，在@的四个方向处调用

dfs()，维护最小值，不过没写。还是写宽搜吧。

渐渐的感到搜索算法跟dp差不多嘛。状态*选择。

不过之前的想法是按机器人所在位置为状态，进行四个方向的搜索，如果到达p

秒，进行旋转，不过要是在对方向键的移动中，旋转时间到了，怎么办？。

看了别人的代码，就设立状态[i][j][cur][times]表示每秒机器人所在位置，以及光标所处方向键,

此时所用时间，用结构体存储。

有四种选择，1，按着光标方向走 2 光标左移 3 光标右移 4 光标不动 ，至于每隔p秒旋转一次，

如果下一秒要旋转，那么有两种方式，a 这一秒先旋转，再做选择，b 先做选择，下一秒再做旋转。

不知为何b方式代码不能过。设立d[i][j][cur]表示此种状态有没有被选择过；用v[i][j]表示i,j位置有没有走过。

由于是宽搜，先搜到的就是最短距离。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#define  maxn 50
using namespace std;
int N,M,P;
char a[maxn][maxn];
int d[maxn][maxn][];
int v[maxn][maxn];
struct node
{
    int x,y,cur,times;
};
 int walk[][]={,-,,,-,,,};
inline void init()
{
   memset(d,,sizeof(d));
   memset(v,,sizeof(v));
   memset(a,,sizeof(a));
}
int rolate(int des)
{
   switch(des)
   {
     case  :
       return ;
     case :
       return ;
     case :
       return ;
     case :
       return ;
   }
}
void solve()
{
     node sou;
     int ok=;
    for(int i=;i<=N;i++)
    {
          for(int j=;j<=M;j++)
        {
            if(a[i][j]=='@')
            {
              sou.x=i;sou.y=j;sou.cur=;sou.times=;
              ok=;
              break;
            }
        }
        if(ok==)
         break;
    }

    queue <node>  que;
   // v[sou.x][sou.y]=1;
   d[sou.x][sou.y][sou.cur]=;
    que.push(sou);
    while(!que.empty())
    {
        node _current=que.front();
        que.pop();
//printf("%d %d %d当前时间:%d\n",_current.x,_current.y,_current.cur,_current.times);
        node _next;

        _next.x=_current.x+walk[_current.cur][];
        _next.y=_current.y+walk[_current.cur][];
        _next.cur=_current.cur;    //按下光标
        _next.times=_current.times;
        if(_next.x>= && _next.x<=N && _next.y>= && _next.y<=M)
        {
            if(v[_next.x][_next.y]==)
          {
            if(a[_next.x][_next.y]=='.')
             {
               // v[_next.x][_next.y]=1;
                //d[_next.x][_next.y][_next.cur]=1;
                _next.times++;
                if(_next.times%P==)
                {
                 _next.cur=rolate(_next.cur);
                 d[_next.x][_next.y][_next.cur]=;

                }
                // printf("走%d %d %d %d\n",_next.x,_next.y,_next.cur,_next.times);
                que.push(_next);
            }
            else if(a[_next.x][_next.y]=='$')
            {
               _next.times++;
                printf("%d\n",_next.times);
                return ;
            }
           }

        }

        if((_current.times+)%P==)
         _current.cur=rolate(_current.cur);
        _next.x=_current.x;
        _next.y=_current.y;

        _next.cur=(_current.cur+)%; //光标左移
        _next.times=_current.times;
        if(d[_next.x][_next.y][_next.cur]==)
        {
           d[_next.x][_next.y][_next.cur]=;
            _next.times++;
           // if(_next.times%P==0)  //选择此时旋转，为何不行？
               // _next.cur=rolate(_next.cur);
               // printf("左移%d\n",_next.times);
            que.push(_next);
        }

         _next.cur=(_current.cur+)%;  //光标右移
         _next.times=_current.times;
         if(d[_next.x][_next.y][_next.cur]==)
         {
            d[_next.x][_next.y][_next.cur]=;
            _next.times++;
           // if(_next.times%P==0)
               // _next.cur=rolate(_next.cur);
               // printf("右移%d\n",_next.times);
             que.push(_next);
         }

       // if(que.size()==1)
          // break;
        _next.cur=_current.cur;  //光标不动
        _next.times=_current.times;
      if( d[_next.x][_next.y][_next.cur]== )
      {
        d[_next.x][_next.y][_next.cur]=;
            _next.times++;
           //if(_next.times%P==0)
              //  _next.cur=rolate(_next.cur);
               // printf("不动%d\n",_next.times);
            que.push(_next);
      }
    }
    printf("YouBadbad\n");
}
int main()
{
 //freopen("test.txt", "r", stdin);
    int T;
    scanf("%d",&T);
    while(T--)
    {
        init();
        scanf("%d%d%d",&N,&M,&P);
      for(int i=;i<=N;i++)
        scanf("%s",a[i]+);
      solve();
    }

}