C++代码：迷宫中两人相遇路径及最短时间计算,-CSDN博客

题号：NC23486
时间限制：C/C++ 1秒，其他语言2秒
空间限制：C/C++ 262144K，其他语言524288K
64bit IO Format: %lld

题目描述

小A与小B这次两个人都被困在了迷宫里面的两个不同的位置，而他们希望能够迅速找到对方，然后再考虑如何逃离迷宫的事情。小A每次可以移动一个位置，而小B每次可以移动两次位置，小A移动的方向是上下左右左上左下右上右下8个方向，小B移动的方向是上下左右4个方向，请问他们最早什么时候能够找到对方，如果他们最终无法相遇，那么就输出”NO"。

输入描述:

第一行两个整数N，M分别表示迷宫的行和列。接下来一个N×M的矩阵其中"C"表示小A的位置,"D"表示小B的的位置，"＃"表示不可通过的障碍，"."则是可以正常通过的位置。字符用空格隔开第一行两个整数N，M分别表示迷宫的行和列。\\
接下来一个N\times M 的矩阵\\其中"C"表示小A的位置,"D"表示小B的的位置，\\
"＃"表示不可通过的障碍，"."则是可以正常通过的位置。\\字符用空格隔开\\第一行两个整数N，M分别表示迷宫的行和列。接下来一个N×M的矩阵其中"C"表示小A的位置,"D"表示小B的的位置，"＃"表示不可通过的障碍，"."则是可以正常通过的位置。字符用空格隔开

输出描述:

如果可以相遇，第一行输出一个YES，第二行一个整数输出最短的相遇时间。
否则就输出一个NO表示不能相遇。

示例1

输入

4 5 . . . . . . # # # . . . . # D . . C # .

4 5
. . . . .
. # # # .
. . . # D
. . C # .

输出

YES 3

YES
3

备注:

1≤n,m≤10001 \leq n,m \leq 10001≤n,m≤1000

#include <iostream>
#include <queue>
#include <vector>
#include <string>
#include <utility>

using namespace std;

const int MAXN = 1005;
int n, m;
char maze[MAXN][MAXN];
int distA[MAXN][MAXN], distB[MAXN][MAXN];

struct Node {
    int x, y, step;
};

bool isValid(int x, int y) {
    return (x >= 0 && x < n && y >= 0 && y < m && maze[x][y] != '#');
}

void bfs(int x, int y, vector<pair<int, int>> directions, int &dist[MAXN][MAXN]) {
    queue<Node> q;
    q.push({x, y, 0});
    dist[x][y] = 0;

    while (!q.empty()) {
        Node cur = q.front(); q.pop();
        for (auto &[dx, dy] : directions) {
            int newX = cur.x + dx, newY = cur.y + dy;
            if (isValid(newX, newY)) {
                if (maze[newX][newY] == 'D' || maze[newX][newY] == 'C') {
                    cout << "YES\n" << cur.step + 1 << endl;
                    exit(0); // 如果找到对方，则输出结果并提前结束程序
                }
                if (dist[newX][newY] == -1) {
                    dist[newX][newY] = cur.step + 1;
                    q.push({newX, newY, cur.step + 1});
                }
            }
        }
    }
}

int main() {
    cin >> n >> m;
    memset(distA, -1, sizeof(distA));
    memset(distB, -1, sizeof(distB));

    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cin >> maze[i][j];
            if (maze[i][j] == 'C') {
                bfs(i, j, {{-1, 0}, {1, 0}, {0, -1}, {0, 1}, {-1, -1}, {-1, 1}, {1, -1}, {1, 1}}, distA);
            } else if (maze[i][j] == 'D') {
                bfs(i, j, {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}, distB);
            }
        }
    }

    // 检查是否可以相遇
    bool canMeet = false;
    for (int i = 0; i < n && !canMeet; ++i) {
        for (int j = 0; j < m; ++j) {
            if (distA[i][j] != -1 && distB[i][j] != -1) {
                cout << "YES\n" << distA[i][j] + distB[i][j] << endl;
                canMeet = true;
                break;
            }
        }
    }

    if (!canMeet) {
        cout << "NO\n";
    }

    return 0;
}

请注意，此代码尚未进行优化，例如，在实际实现中，你可能需要对宽度优先搜索进行修改以同时考虑两个人的位置和步数，并且在他们相遇时立即停止搜索。另外，如果迷宫规模很大，为了降低时间复杂度，可能还需要引入剪枝策略或使用其他算法。