FZU1019 猫捉老鼠 (BFS)

Problem 1019 猫捉老鼠

Time Limit: 1000 mSec    Memory Limit : 32768 KB

 Problem Description

一只猫和一只老鼠在10*10的迷宫中。迷宫中的每个方格可以是空的，或者含有障碍。猫和老鼠可以进入任意一个空的方格中。当他们相遇时，猫和老鼠在同一个方格中。但是，无论猫或老鼠都不能进入有障碍的方格。我们可以用字符组成的二维数组表示迷宫，如下图所示。

老鼠在迷宫中按照一种固定的方式行走：每个时刻，老鼠都向它所面对的方向前进一格，这需要花费１秒时间。如果前方是一个障碍或者是迷宫的边界，它将花１秒的时间按顺时针方向转90度。

为了抓到老鼠，这只猫决定也按照与老鼠相同的行走方式行进。

猫和老鼠在每个单位时间内是同时行动的。因此，如果猫和老鼠在行进过程中“擦肩而过”，猫是无法捉到老鼠的。只有当猫和老鼠同时到达一个相同的格子时，猫才能捉住老鼠。 
初始时，猫和老鼠不会在同一个方格中。并且它们都面向北方。
你的任务是编一个程序，求出猫捉到老鼠的所花时间。

 Input

输入数据的第一行n，表示输入数据的组数。
每组数据由10行组成，每行10个字符，表示迷宫的地图以及猫和老鼠的初始位置。输入数据保证只有一只猫和一只老鼠。
每组输入数据之后均有一个空行作为间隔。 

 Output

对于每组给定的输入，输出一行仅含一个数，即猫捉到老鼠所花的时间。如果猫永远都无法抓到老鼠，则输出0。

 Sample Input

1
*...*.....
......*...
...*...*..
..........
...*.c....
*.....*...
...*......
..m......*
...*.*....
.*.*......

 Sample Output

49

/*
解题思路：cat和mouse同时移动，
如果cat遇到边界或者障碍的话，则cat要在这里消耗1s，来进行转弯，但是mouse不受影响，可以继续移动。
mouse同上。
每一次移动之前记录两者移动的方向，下次移动的初试方向即为当前的移动方向。
注意标记：在标记的时候，不能单纯的标记cat或者mouse，要同时把cat和mouse当前的方向，位置都给标记上，
因为二者在移动的时候可能会出现死循环，无论怎么移动都不会出现。
注意边界：在写代码过程中发现处理边界的时候特别麻烦，但是通过把边界预处理，转化为障碍的话，在BFS过程中
就不需要对边界进行判断，只需要判断障碍即可。
*/
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
char Map[22][22];
struct data
{
    // cat
    int c_x, c_y, c_pos;
    // mouse
    int m_x, m_y, m_pos;
    int step;
} st, pre;
// 四个方向：北-->东-->南-->西，注意，往四个方向移动的时候是哪个坐标轴的变化
int dir[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
bool vis[22][22][22][22][11][11];
int c_x, c_y, m_x, m_y;

int BFS()
{
    queue<data> que;
    st.c_x = c_x;
    st.c_y = c_y;
    st.c_pos = 0;
    st.m_x = m_x;
    st.m_y = m_y;
    st.m_pos = 0;
    st.step = 0;
    vis[st.c_x][st.c_y][st.m_x][st.m_y][st.c_pos][st.m_pos] = 1;
    que.push(st);

    while (!que.empty())
    {
        st = que.front();
        que.pop();
        // 找到了
        if (st.c_x == st.m_x && st.c_y == st.m_y)
            return st.step;

        int c_x = st.c_x;
        int c_y = st.c_y;
        int c_pos = st.c_pos;
        int m_x = st.m_x;
        int m_y = st.m_y;
        int m_pos = st.m_pos;

        // cat 和 mouse 同时在自己方向上移动
        c_x += dir[c_pos][0];
        c_y += dir[c_pos][1];
        m_x += dir[m_pos][0];
        m_y += dir[m_pos][1];

        // cat
        if (Map[c_x][c_y] == '*')
        {
            // 障碍，不能走，回退
            c_x -= dir[c_pos][0];
            c_y -= dir[c_pos][1];
            c_pos = (c_pos + 1) % 4;
        }
        // mouse
        if (Map[m_x][m_y] == '*')
        {
            m_x -= dir[m_pos][0];
            m_y -= dir[m_pos][1];
            m_pos = (m_pos + 1) % 4;
        }

        // 当前这种状态之前出现过，出现循环，两者永远不能相遇，终止
        if (vis[c_x][c_y][m_x][m_y][c_pos][m_pos] == 1)
            return 0;
        vis[c_x][c_y][m_x][m_y][c_pos][m_pos] = 1;

        pre.c_x = c_x;
        pre.c_y = c_y;
        pre.c_pos = c_pos;
        pre.m_x = m_x;
        pre.m_y = m_y;
        pre.m_pos = m_pos;
        pre.step = st.step + 1;
        que.push(pre);
    }
    return 0;
}

void Init()
{
    // Map 边界预处理
    for (int i = 0; i <= 11; i ++)
        Map[0][i] = Map[i][0] = Map[11][i] = Map[i][11] = '*';
}

int main()
{
    int T;
    Init();
    scanf("%d", &T);
    while (T --)
    {
        for (int i = 1; i <= 10; i ++)
            for (int j = 1; j <= 10; j ++)
            {
                cin >> Map[i][j];
                if (Map[i][j] == 'c')
                {
                    c_x = i;
                    c_y = j;
                }
                else if (Map[i][j] == 'm')
                {
                    m_x = i;
                    m_y = j;
                }
            }
        memset(vis, 0, sizeof(vis));
        printf("%d\n", BFS());
    }
    return 0;
}