B3625 迷宫寻路(BFS)

B3625 迷宫寻路

题目描述

机器猫被困在一个矩形迷宫里。

迷宫可以视为一个 n×m 矩阵，每个位置要么是空地，要么是墙。机器猫只能从一个空地走到其上、下、左、右的空地。

机器猫初始时位于 (1,1) 的位置，问能否走到 (n,m) 位置。

输入格式

第一行，两个正整数 n,m。

接下来 n 行，输入这个迷宫。每行输入一个长为 m 的字符串，# 表示墙，. 表示空地。

输出格式

仅一行，一个字符串。如果机器猫能走到 (n,m)，则输出 Yes；否则输出 No。

输入输出样例

输入

3 5
.##.#
.#...
...#.

输出

Yes

说明/提示

样例解释

路线如下：(1,1)→(2,1)→(3,1)→(3,2)→(3,3)→(2,3)→(2,4)→(2,5)→(3,5)

数据规模与约定

对于 100% 的数据，保证 1≤n,m≤100，且 (1,1) 和 (n,m) 均为空地。

代码：

#include <bits/stdc++.h>
#define N 110              // 定义最大迷宫尺寸为 110（题目给出 n,m 最大为 100，留有边界缓冲）
using namespace std;
typedef pair<int,int> PII; // 定义一个 pair 类型，存储二维坐标 (行, 列)

// 全局变量声明
int dist[N][N];   // dist[i][j] 用于记录从起点 (1,1) 到 (i,j) 的最短步数（初始化为 -1 表示未访问）
char b[N][N];     // 二维字符数组表示迷宫，'.' 表示空地，'#' 表示墙
int nn, mm;       // 迷宫的行数和列数

// 定义四个方向的偏移量：右、左、上、下
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};

// 广度优先搜索函数，从起点 (x1, y1) 开始搜索可到达的空地
void bfs(int x1, int y1) {
    // 将 dist 数组全部初始化为 -1（表示未访问）
    memset(dist, -1, sizeof(dist));
    
    // 使用队列来实现 BFS 算法，队列中存放坐标对
    queue<PII> q;
    q.push({x1, y1});       // 将起点入队
    dist[x1][y1] = 0;       // 起点到自身的距离为 0

    // 当队列不为空时，继续搜索
    while(!q.empty()){
        // 取出队首元素（当前正在扩展的点）
        auto t = q.front();
        q.pop();

        // 遍历四个可能的移动方向
        for(int i = 0; i < 4; i++){
            // 计算新位置的坐标
            int a = t.first + dx[i];
            int c = t.second + dy[i];

            // 判断新位置是否越界（注意：迷宫坐标从 1 开始，到 nn,mm 结束）
            if(a < 1 || a > nn || c < 1 || c > mm)
                continue; // 超出迷宫边界，跳过此方向

            // 判断新位置是否为墙（只有空地才能通行）
            if(b[a][c] != '.')
                continue;

            // 判断新位置是否已经被访问过（dist 不为 -1 说明已访问）
            if(dist[a][c] != -1)
                continue;

            // 更新新位置的步数（当前点步数 + 1）
            dist[a][c] = dist[t.first][t.second] + 1;
            // 将新位置加入队列，等待后续扩展
            q.push({a, c});
        }
    }
}

int main(){
    // 读入迷宫的行数和列数
    cin >> nn >> mm;
    // 读入迷宫地图，每个字符表示一个格子
    // 注意：这里循环下标从 1 到 nn 和 1 到 mm（为了方便处理边界问题）
    for(int i = 1; i <= nn; i++){
        for(int j = 1; j <= mm; j++){
            cin >> b[i][j];
        }
    }

    // 从起点 (1,1) 开始进行广度优先搜索
    bfs(1, 1);

    // 如果 (nn,mm) 被访问过（dist[nn][mm] != -1），则说明有路径可达，输出 "Yes"，否则输出 "No"
    cout << (dist[nn][mm] != -1 ? "Yes" : "No");

    return 0;
}

详细思路与步骤分析

1. 问题建模
   • 迷宫被看作一个 n×mn \times mn×m 的矩阵，其中每个格子可以是“空地”（.）或“墙”（#）。
   • 题目要求判断从起点 (1,1)(1,1)(1,1) 能否走到终点 (n,m)(n, m)(n,m)。
   • 机器猫只能沿上下左右四个方向移动，且必须走在空地上。
2. 使用广度优先搜索 (BFS)
   • 原因： BFS 非常适合用于求解无权图（这里每一步的代价均为 1）的最短路径问题，并且可以判断是否能从起点到达终点。
   • 原理： 从起点开始，依次访问所有相邻的空地，并记录每个点到起点的步数。由于 BFS 的层次遍历特性，第一次访问到的点保证是最短路径。
3. 数据结构与变量说明
   • 队列 (queue)： 用于存储当前待扩展的坐标点，保证按照层次进行遍历。
   • 二维数组 dist： 用于记录从起点到每个点的最短步数。初始化为 -1 表示未访问。
   • 二维数组 b： 存储迷宫地图，字符为 '.' 表示空地，'#' 表示墙。
   • 方向数组 dx 和 dy： 分别对应上下左右的偏移量，便于遍历四个相邻位置。
4. BFS 过程详解
   • 初始化：
     • 将起点 (1,1)(1,1)(1,1) 的步数设为 0，并将其加入队列。
   • 循环过程：
     • 从队列中取出当前节点，检查其四个方向的相邻位置。
     • 边界检查： 确保新坐标不超出迷宫范围。
     • 墙体检查： 只有遇到空地才可以继续搜索。
     • 重复访问检查： 如果一个位置已经访问过，则跳过，避免重复计算。
     • 更新新位置的步数为当前点步数加一，并将其加入队列。
   • 结束条件： 队列为空时说明所有可达的空地均已访问。
5. 结果输出
   • 最终检查终点 (n,m)(n, m)(n,m) 是否被访问（即 dist[nn][mm] != -1）。如果被访问过则说明存在一条路径，否则不存在路径。