郑轻ACM 1726: 迷宫(BFS)

Description

在很多 RPG (Role-playing Games) 游戏中，迷宫往往是非常复杂的游戏环节。通常来说，我们在走迷宫的时候都需要花非常多的时间来尝试不同的路径。但如果有了算法和计算机的帮助，我们能不能有更快的方式来解决这个问题？我们可以进行一些尝试。

现在我们有一个 N 行 M 列的迷宫。迷宫的每个格子如果是空地则可以站人，如果是障碍则不行。在一个格子上，我们可以一步移动到它相邻的 8 个空地上，但不能离开地图的边界或者跨过两个障碍的夹缝。下图是一个移动规则的示例。

为了离开迷宫，我们还需要触发迷宫中所有的机关。迷宫里总共有 K 个机关，每个机关都落在一个不同的空地上。如果我们到达了某个机关所在的格子时，这个机关就会被自动触发，并在触发之后立即消失。我们的目标是按顺序触发所有的 K             个机关，而当最后一个机关被触发时，我们就可以离开迷宫了。

现在我们已经拿到了迷宫地图，并且知道所有障碍、机关的位置。初始时我们位于迷宫的某个非障碍格子上，请你计算我们最少需要移动多少步才能离开迷宫？

Input

输入的第一行是测试数据的组数 T (T ≤ 20)。

对于每组测试数据：第一行包含地图的行数 N (2 ≤ N  ≤ 100)，列数 M(2 ≤ M  ≤ 100) 和机关的数量 K(1 ≤ K ≤10)。接下来 N 行，每行包含 M 个字符，其中字符 ‘#’ 表示障碍，而 ‘.’ 表示空地。接下来一行描述了我们的初始位置 (x, y)，表示我们一开始在第 x 行第 y 列的格子上。这个格子保证是个空地。接下来 K 行，每行给出了一个机关的位置。所有的机关都不会出现在障碍上，并且任意两个机关不会出现在同一个空地上。我们需要按输入给定的顺序触发所有的 K 个机关。

Output

对于每组测试数据，输出离开迷宫所需要的最少步数。如果无论如何都不能离开迷宫，输出 -1。

Sample Input

33 3 2.........1 11 32 23 3 1....#....1 13 32 3 1..#.#.1 12 3

Sample Output

33-1

思路：从起点开始走，每走到一个机关以后，则记录到这个机关的距离，然后以此机关的点作为起点，继续往下走，依次循环，直到所有的机关都已经走过。如果中间过程中出现有的点不能到达的话，则不能每一个机关的点都走到，直接输出-1即可。

注意，虽然机关的点不能使障碍，但是机关的点也可能是起点，如果是起点的时候，则输出-1。

#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <cstdio>
#include <cstring>
#define mem(_, __) memset(_, __, sizeof(_));
const int maxn = 111;
const int INF = 0x3f3f3f3f;
using namespace std;

vector<int> v;
int n, m, k, sx, sy, tx, ty;
int dir[8][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}, {-1, -1}, {-1, 1}, {1, -1}, {1, 1}};
char Map[maxn][maxn];
bool vis[maxn][maxn];
struct data
{
    int x;
    int y;
    int step;
}st, pre;

int BFS()
{
    if (Map[sx][sy] == '*')// 如果起点是机关，则不能走
        return INF;

    mem(vis, 0)
    queue<data> que;
    st.x = sx;
    st.y = sy;
    st.step = 0;
    vis[st.x][st.y] = 1;
    que.push(st);

    while (!que.empty())
    {
        st = que.front();
        que.pop();

        // 到达了机关的位置
        if (st.x == tx && st.y == ty)
            return st.step;

        for (int i = 0;i < 8;i ++)
        {
            int x = st.x + dir[i][0];
            int y = st.y + dir[i][1];

            // Map中指明只能走 . ，不能走别的点
            if (x < 1 || x > n || y < 1 || y > m || vis[x][y] || Map[x][y] != '.')
                continue;

            // 此处为判断是否能走对角线
            int num = 0;
            // 当 abs(x - st.x) + abs(y - st.y) 等于 2的时候，表明走的是对角线
            if (abs(x - st.x) + abs(y - st.y) == 2)
            {
                int min_x = min(x, st.x);
                int min_y = min(y, st.y);
                int max_x = max(x, st.x);
                int max_y = max(y, st.y);

                if (Map[min_x][min_y] == '#')
                    ++ num;
                if (Map[min_x][max_y] == '#')
                    ++ num;
                if (Map[max_x][min_y] == '#')
                    ++ num;
                if (Map[max_x][max_y] == '#')
                    ++ num;
            }
            // 如果一个2*2的小矩阵中有任意两个点是障碍，则不能走到之前点的对角线，
            // 因为之前已经判断过Map[x][y]是否是点，是点才能走到这，所以只是判断点(x, y) 相邻的两点以及对角线上面的点是否是障碍
            if (num >= 2)
                continue;

            vis[x][y] = 1;
            pre.x = x;
            pre.y = y;
            pre.step = st.step + 1;
            que.push(pre);
        }
    }
    return INF;
}

void solve()
{
    int ret = 0;
    for (int i = 0;i < v.size(); )
    {
        tx = v[i ++];
        ty = v[i ++];

        // 只修改当前的机关，其他机关不做修改，因为不能从一个机关走到另一个机关
        Map[tx][ty] = '.';
        int num = BFS();
        if (num == INF) // 当前机关不能到达
        {
            ret = -1;
            break;
        }
        ret += num;

        // 修改起点，起点变为当前的机关所在位置
        sx = tx;
        sy = ty;
    }
    printf("%d\n", ret);
}

int main()
{
    int T, x, y;
    scanf("%d", &T);
    while (T --)
    {
        scanf("%d%d%d", &n, &m, &k);
        for (int i = 1;i <= n;i ++)
            scanf("%s", Map[i] + 1);
        // 起点
        scanf("%d%d", &sx, &sy);
        v.clear();
        for (int i = 0;i < k;i ++)
        {
            scanf("%d%d", &x, &y);
            // 记录机关的点
            Map[x][y] = '*';
            // 把机关的点放入向量中
            v.push_back(x);
            v.push_back(y);
        }

        solve();
    }
    return 0;
}