BFS--DFS or BFS?

题目描述
说好了，题目不黑人。

给你一个8*8的矩阵，你的初始位置是左下角方格（用’U’表示），你的目标位置是右上角的方格(用’A’表示），其余的62个方格，如果是’.’，表示这个方格为空，如果是’S’，表示这个方格有一块大石头。好了现在你开始从左下角出发，每次可以往上，下，左，右，左上，右上，左下，右下移动一个方格，或者你可以原地不动，一共九个动作方式，在你做完一个动作后，所有的大石头会往下掉一个方格（如果一个大石头的位置是（x，y）,那下一秒是（x+1，y）,不过如果它已经在最下面的一排了，那它就会掉出矩阵，不再出现），请注意，任一时刻，你不能和某一个大石头处在同一个方格，否则石头会把你XX掉。

现在的问题就是：你能从左下角安全抵达右上角么？如果能，输出“Yes”，反之，“No”。

输入
T->测试数据组数(T)。

对于每组数据，输入一个8*8的矩阵，其后有一空行。描述如上。

输出
对于第i组数据，请输出

Case #i: s(s是一个字符串，如果可以到达，则s为“Yes”，反之“No”)

样例输入
2
…A
…
…
…
…
…
…
U…

…A
…
…
…
…
.S…
S…
US…

样例输出
Case #1: Yes
Case #2: No

#include <iostream>
#include <algorithm>
#include <queue>
#include <cstdio>
using namespace std;
struct node
{
    int x, y;
    int step;
};
char a[20][20];
int dir[9][2] = {{0, 0}, {0, 1}, {0, -1}, {1, 0}, {1, -1}, {1, 1}, {-1, -1}, {-1, 0}, {-1, 1}};
bool flag = false;
bool judge(int x, int y)
{
    if (x < 0 || x >= 8 || y < 0 || y >= 8)
    {
        return false;
    }
    return true;
}

void BFS()
{
    queue<node> Q;
    node temp;
    temp.x = 7;
    temp.y = 0;
    temp.step = 0;
    Q.push(temp);
    while (!Q.empty())
    {
        node top = Q.front();
        Q.pop();
        for (int i = 0; i < 9; i++)
        {
            int nx = top.x + dir[i][0];
            int ny = top.y + dir[i][1];
            temp.x = nx;
            temp.y = ny;
            temp.step = top.step + 1;
            if (judge(nx, ny) && a[temp.x - temp.step][temp.y] != 'S' && a[temp.x - temp.step + 1][temp.y] != 'S')
            {
                if (a[nx][ny] == 'A' || temp.step >= 8) //步数大于8，此时所有大石头都不在了
                {
                    flag = true;
                    return;
                }
                Q.push(temp);
            }
        }
    }
}
int main()
{
    int t;
    cin >> t;
    int count = 1;
    while (t--)
    {
        for (int i = 0; i < 8; i++)
        {
            for (int j = 0; j < 8; j++)
            {
                cin >> a[i][j];
            }
        }
        BFS();
        if (flag)
        {
            cout << "Case #" << count << ": Yes" << endl;
        }
        else
        {
            cout << "Case #" << count << ": No" << endl;
        }
        count++;
        flag = false;
        fill(a[0], a[0] + 400, '0');
    }
    return 0;
}

思路：本题借鉴了大神的做法。虽然每走一步大石头会下落。但是这次我并没有选择存储矩阵的状态(在每一步转台转换改变矩阵的状态，让大石头下落)。因为对于本题来说，只需要判断能不能到达终点：只要宽搜的下一步到达的位置上没有大石头(a[temp.x-temp.step+1][temp.y]!=‘S’)或者宽搜的下一步到达的位置的上方(a[temp.x-temp.step][temp.y]!=‘S’)没有大石头即可避免死亡(这个状态可以到达)。

注意:本题判断结束的条件有两个：

此时的横纵坐标为(0,7)

此时的step>=8,因为只需要8步大石头就可以全部下落了，那么无论怎么走都可以到达终点。

猜你喜欢