从P1605迷宫到迷宫生成：DFS回溯算法实战解析

1. 从一道经典模板题说起：P1605迷宫到底在考察什么

第一次刷到P1605迷宫这道题的时候，很多人都会觉得它“就这”——一个N×M的方格地图，塞几个障碍物，给个起点终点，让你数一数有多少条路能走到终点。但恰恰是这道看似简单的题目，在洛谷上常年保持着极高的话题度，几乎每个学DFS的人都会和它打个照面。

P1605这道题的核心背景其实很朴素：给定一个N行M列的迷宫，里面有T个障碍物，每个格子要么能走，要么不能走。你从给定的起点出发，每次可以往上、下、左、右四个方向移动一格，不能走出迷宫边界，不能走到障碍物上，也不能重复走已经走过的格子。题目问的是：从起点到终点一共有多少条不同的路径。这道题的输入规模通常不大（N和M一般不超过10），所以暴力搜索是完全没有问题的——这也是它被定位为“DFS入门模板题”的根本原因。

用一个被说过无数遍但真的很准确的类比：你站在一座迷宫入口，手里拿了一根很长的线，每走到一个岔路口就选一个方向继续走，走不通就顺着线退回来，换另一个方向再试。这条“线”就是程序里的递归调用栈，而“退回来再换方向”这个动作就是回溯。P1605让你实现的正是一个最朴素的“试错-回溯-计数”过程，只不过地图和规则都被固定好了，你只需要把搜索的过程老老实实写出来。

这篇文章适合以下几类读者：第一次接触深度优先搜索、想在洛谷上AC这道题的新手；刷题刷到DFS回溯但思路总是不够清晰的半新手；以及想从一道模板题出发，把“迷宫类”题目的通用解法整理成一套方法论的人。我会从题目分析、DFS核心逻辑、完整代码逐段讲解、常见错误排查，再到迷宫变体的延伸，把这条线完整讲透。

2. 解题思路拆解：为什么这道题必须用DFS而不是BFS

2.1 题目输入的本质：一张可走/不可走的邻接矩阵

P1605的输入格式非常固定。第一行给出N、M、T，分别代表迷宫的行数、列数和障碍物数量。第二行给出起点坐标(startx, starty)，第三行给出终点坐标(endx, endy)。接下来T行，每行一个障碍物的坐标。特别需要注意：题目的坐标是从1开始计数的，也就是说地图范围是(1,1)到(N,M)，而不是程序里常见的(0,0)到(N-1,M-1)。这个细节是第一道坑，后面会专门展开。

把迷宫抽象成数据结构时，通常用一个二维数组a[N+2][M+2]来存储，其中0表示可通行，1表示障碍物。之所以要开N+2和M+2而不是N和M，是因为在边界判断时，可以在数组四周预留一圈“哨兵位”，这样当坐标越界时，直接判断a[x][y]是否等于1，就能把越界和障碍物统一处理掉，减少一层边界判断代码。当然，如果你习惯用if (x < 1 || x > N || y < 1 || y > M)来显式判断边界，也完全没问题，两种风格各有偏好，但思路是等价的。

这个二维数组的本质，其实就是一张布尔型的邻接矩阵——每个格子是否可通行，直接决定了搜索路径的走向。因为地图规模很小（N和M最大也就是10左右），所以无论是时间还是空间，算法都可以做到非常奢侈。

2.2 DFS的核心思路：一条路走到黑，走不通就回头

深度优先搜索的思想用一句话概括就是“不撞南墙不回头”。从起点开始，选中一个方向（比如先向上）迈出一步，到了新格子后，又继续从四个方向里选一个往前走，直到抵达终点，或者发现自己走进了死胡同——前方四个方向要么是障碍物、要么是边界、要么是已经走过的格子。此时递归函数自然返回，回到上一个格子，再尝试这个格子剩下的方向。

这就是“回溯”的本质：在递归返回后，需要把当前格子的状态恢复原样，否则其他路径在搜索时会被“已访问”标记挡住，导致漏算路径。用一个生活化的场景来理解：你在迷宫里每走一步，都在地上放一个标记，防止自己绕圈。但当你从死胡同退回上一个岔路口时，必须把这条分支上的标记全部收起来，否则你走另一条路时，这些标记会误导你，让你以为这条路也走不通。DFS里的“标记”就是visited数组或直接在原地修改地图，而“收起标记”就是回溯时的反向操作。

为什么这道题选DFS而不是BFS（广度优先搜索）？因为题目问的是“路径方案数”。BFS擅长找最短路径，它在逐层扩展时，第一次到达终点的层数就是最短距离，但BFS并不天然适合统计所有路径的数量——你需要在BFS过程中维护很多状态，复杂度会上升。而DFS天然就是“一条路径走完再走下一条”的遍历方式，每到达一次终点就计一次数，方案数统计非常自然。也就是说，遇到“求方案数”“求所有可能路径”的题目，优先想DFS；遇到“求最短步数”“最少代价”的题目，优先想BFS。这个选择依据在迷宫类题目中几乎是铁律。

2.3 搜索状态如何定义：坐标+已访问标记

在P1605中，一次完整的搜索状态可以用一个三元组(x, y, step)来描述，其中(x, y)是当前坐标，step是已经走过的步数。不过因为题目只关心方案数而不关心步数，所以实际代码中step这个维度可以被省略。真正关键的状态是“当前站在哪个格子”以及“哪些格子已经被走过”。

这里有一个很多人一开始会忽略的细节：起点在出发时就要标记为已访问。如果漏掉这一步，DFS会先从起点走一步，然后又可以走回起点，导致路径中出现“原地绕圈”的非法情况，甚至可能让方案数变得异常大。很多人在调试时发现自己的答案比标准答案大，多半就是这个原因。

另一个细节是：搜索方向的选择顺序对结果没有影响，但会影响搜索路径的先后顺序。通常我们会按上、下、左、右的顺序来写方向数组，或者按你的书写习惯来定。只要四个方向都覆盖到，最终方案数就是一样的，方向顺序不影响正确性，只影响递归的调用顺序。

2.4 递归终止条件：什么时候计数，什么时候返回

DFS函数的终止条件通常有两类。第一类是“到达终点”，也就是当前坐标(x, y)等于终点坐标(endx, endy)时，方案数加1，然后直接return，不需要继续往下走。第二类是“此路不通”，也就是当前格子没有可走的下一步时，函数自然执行完毕，返回上一层。

在代码实现上，终止条件要写得简洁明了。到达终点的判断要放在四个方向遍历之前，因为一旦到达终点，这条路径就已经完整了，不需要再从终点往外扩展。如果终点本身就是障碍物，那答案一定是0，这种情况不需要特判，因为DFS根本不会走到终点位置——障碍物格子在初始标记时就已经是1了，搜索过程中不会进入。

3. 完整代码实现与逐段讲解

3.1 全局变量与数据结构定义

P1605的代码量不大，通常20到30行就能写完核心逻辑。但正因为代码短，很多人容易在细节上翻车。下面给出一个完整的、带注释的参考实现，先看整体结构，再做逐段讲解。

cpp复制#include <bits/stdc++.h>
using namespace std;

int N, M, T;             // 行数、列数、障碍物数量
int startx, starty;      // 起点坐标
int endx, endy;          // 终点坐标
int grid[15][15];        // 地图，0表示可走，1表示障碍物/已访问
int dx[4] = {-1, 1, 0, 0};  // 上、下、左、右 的行偏移
int dy[4] = {0, 0, -1, 1};  // 上、下、左、右 的列偏移
int ans = 0;             // 方案数

void dfs(int x, int y) {
    // 到达终点，方案数+1，返回
    if (x == endx && y == endy) {
        ans++;
        return;
    }
    
    // 遍历四个方向
    for (int i = 0; i < 4; i++) {
        int nx = x + dx[i];
        int ny = y + dy[i];
        
        // 如果下一个格子越界，跳过
        if (nx < 1 || nx > N || ny < 1 || ny > M) {
            continue;
        }
        // 如果下一个格子是障碍物或已访问，跳过
        if (grid[nx][ny] == 1) {
            continue;
        }
        
        // 标记为已访问，递归进入新格子
        grid[nx][ny] = 1;
        dfs(nx, ny);
        // 回溯，撤销标记
        grid[nx][ny] = 0;
    }
}

int main() {
    cin >> N >> M >> T;
    cin >> startx >> starty;
    cin >> endx >> endy;
    
    // 读入障碍物，标记为1
    for (int i = 1; i <= T; i++) {
        int x, y;
        cin >> x >> y;
        grid[x][y] = 1;
    }
    
    // 起点标记为已访问
    grid[startx][starty] = 1;
    
    // 从起点开始DFS
    dfs(startx, starty);
    
    // 输出方案数
    cout << ans << endl;
    
    return 0;
}

3.2 逐段讲解：从输入读到DFS入口

第一块是全局变量和方向数组。很多新手喜欢把所有变量都写在main函数里，然后在dfs函数里通过传参传递坐标。这样写不是不行，但对于这类“全局状态贯穿整个搜索过程”的题目，全局变量会让代码简洁很多，也不需要每次递归都复制一堆参数。尤其方向数组dx和dy，把它定义成全局常量后，在dfs里直接使用非常方便。这里的dx和dy是配对的，dx[0]=-1, dy[0]=0表示向上走一格，dx[1]=1, dy[1]=0表示向下走一格，其余以此类推。

main函数里有两处标记非常关键。第一处是读入障碍物后赋值grid[x][y] = 1，第二处是dfs调用前执行grid[startx][starty] = 1。为什么终点不需要预先标记？因为终点的语义是“到达即可计数”，它和障碍物不同。如果预先标记终点为1，那么dfs在终点前一步时，会判断终点格子不可走，从而导致永远无法到达终点，答案变成0。这是一个很容易踩的思维误区。

dfs函数的开头就是终点判断。有的同学会问：如果终点周围四个方向都走不通怎么办？没关系，递归会在终点判断处直接计数返回，不会再往下扩展。路径的合法性在进入终点前就已经被保证了——你走到终点时，说明终点这个格子没有被标记为已访问，也没有被标记为障碍物，它是可通行的。

3.3 为什么用grid[x][y]=1既可以表示障碍物又可以表示已访问

细心的读者可能已经发现，上面的代码里障碍物和已访问格子都使用了grid[x][y] = 1来标记，这会不会造成冲突？不会，原因是两者的语义是互斥的。搜索过程中，如果一个格子是障碍物，它在输入阶段就被设为1，且在搜索过程中永远不会被置回0。如果一个格子是普通格子，在搜索路径上被访问过后，它会被暂时设为1，但在回溯阶段会被置回0。也就是说，1这个标记在“搜索期间”同时表示“不可走”，无论这个不可走是因为障碍物还是因为已访问。这种设计省去了单独的visited数组，是这类迷宫DFS问题的常用技巧。

但这个技巧有个前提：你不允许在搜索过程中通过某个格子把障碍物“解开”。在代码里，回溯时只有那些被当前递归分支标记的格子才会被置回0，而障碍物格子永远不会被当作“当前路径上的下一步”进入，因此永远不会被递归函数标记，也永远不会被回溯解除。这个逻辑是自洽的。

如果你觉得这种技巧容易混淆，有一个更稳妥的替代方案：额外开一个bool visited[15][15]数组，专门记录访问状态，grid只负责记录障碍物。这样在做判断时用if (grid[nx][ny] == 1 || visited[nx][ny])来拦截，回溯时只要修改visited即可。两种写法的结果完全一致，只是前者更省空间，后者语义更清晰。我在给初学者讲解时，会更推荐后者，因为“可读性优先”在刷题阶段比省那一点点内存更重要。

3.4 复杂度分析：为什么数据范围小是DFS的护身符

P1605的数据范围通常是N、M不超过10，T不超过N×M，也就是说总格子数最多100个。DFS在最坏情况下的时间复杂度与分析树的分支数有关。每个格子最多有4个方向的分支，搜索深度最多为格子总数，因此最粗略的估计是O(4^(N×M))，这是指数级别。但实际运行时，由于障碍物和已访问标记的约束，搜索空间远小于这个上限，在100个格子的范围内，DFS的递归次数通常不会超过几万到几十万次，在1秒时限内完全跑得完。

这就是为什么我能放心地说“不要对这道题做过度优化”。有的同学一看到“深度优先搜索”就想着上记忆化、剪枝，结果把代码搞得复杂无比，反而降低了可读性。对于N×M≤100的规模，暴力DFS就是最优解。真正的剪枝和优化是在数据规模扩大时才需要考虑的，比如当N、M超过30时，纯DFS可能就会超时，那时才需要考虑状态压缩DP或其他算法。在P1605上，你唯一的“优化”就是把代码写对。

4. 新手必看：5个高频错误与排查技巧

4.1 坐标从1开始，数组却开小了

这是P1605最容易犯的错误。题目给的坐标是从1开始的，如果你开一个int grid[N][M]的数组（假设N和M是全局常量），那么访问grid[10][10]时可能会越界——因为合法下标是0到9。正确的做法是开大一点的数组，比如grid[15][15]，甚至grid[20][20]，保证即使坐标是(N, M)也能装得下。很多老手习惯性地把地图四周留一圈空白，用grid[N+2][M+2]来定义，就是为了让边界判断和数组访问都安全。

如果你在本地测试时发现程序在输入数据后就崩溃，或者输出一个莫名其妙的大数，优先检查数组大小。C++的数组越界是未定义行为，它不一定会直接崩溃，但可能会悄悄改动其他变量的值，导致答案错误。这种bug用肉眼很难察觉，建议在写代码时养成“数组多开一点”的习惯。

4.2 起点和终点的边界情况没有处理

这道题有一个特殊情况：如果起点和终点重合，答案应该是什么？按照定义，从起点出发，步数为0，就已经在终点了，所以方案数应该是1。但很多人的代码在起点等于终点时会输出0，原因是起点被标记为已访问后，dfs函数一开始就到终点，理论上应该能进入终点判断。只要你的代码在dfs开头写了if (x == endx && y == endy)，这个情况自然会被正确处理。

另一个常见错误是：终点有一个障碍物。有的同学为了“保险”，在读入障碍物时把终点的grid标记为1，然后dfs永远无法到达终点，答案输出0。这个结果碰巧是正确的——终点有障碍物确实意味着没有合法路径。但如果你的代码在main函数里额外加了grid[endx][endy] = 1，那么当终点没有障碍物时，这行代码会让所有路径都被堵死，答案恒为0。所以千万不要预先标记终点，除非题目明确说明终点有障碍物。

4.3 回溯时忘记撤销标记，导致路径数偏少

这是DFS回溯题最经典的问题。如果你在递归进入新格子前标记grid[nx][ny] = 1，但递归返回后没有把它置回0，那么这条路径上的格子会一直保持“已访问”状态，其他路径一旦走到这个格子就会被拦截，导致搜索空间被严重缩小，最终答案偏少。

建议在写代码时，严格按照“标记-递归-撤销”三步走的格式来组织for循环内的代码，不要随意调整顺序。在实际调试时，如果发现答案比预期小很多，先检查回溯是否完整。你可以在dfs函数里加一个计数器，打印每次到达终点的访问路径，肉眼观察路径是否重叠。

4.4 方向数组写错导致搜索方向覆盖不全

dx和dy的配对是另一个高频出错点。比如有人把dx写成{-1, 1, 0, 0}，dy写成{0, 0, -1, 1}，这没问题；但如果把dx写成{-1, 0, 1, 0}，dy写成{0, 1, 0, -1}，那表示的是“上、右、下、左”，只要四个方向都在，其实也是对的。真正的错误是配对的数字不对，比如dx[0]=-1, dy[0]=-1，这表示斜向移动，不符合题目要求；或者某个方向重复，另一个方向缺失，导致搜索不完整。

如果你发现自己提交后有一部分测试点超时，或者答案明显少于预期，可以手动画一个3×3的小迷宫，走一遍你的方向数组，看每个方向是否都被覆盖到。也可以用printf在进入新格子时打印坐标，观察路径是否正确。

4.5 递归可能导致栈溢出吗

对于N×M≤100的地图，最大递归深度也就是100层，远不会触发C++默认的栈空间限制（通常为8MB），所以不用担心栈溢出。但如果你把这道题的思路带到更大的地图（比如1000×1000），递归深度可能就会变成100万层，那时候栈就会爆掉。这种情况需要改成显式栈实现DFS，或者换BFS。作为入门期，你只需要知道这个边界在哪里，不需要立刻实现。

5. 从P1605延伸出去：方格迷宫生成器与迷宫题目的通解套路

5.1 不只是遍历迷宫，还要会生成迷宫

热搜词里出现了“方格迷宫生成器”，这一点都不奇怪。因为当你刷完P1605这类DFS遍历迷宫后，下一个自然会遇到的问题就是：怎么生成一个迷宫？这里介绍两种最常见的算法：递归回溯生成器和随机Prim算法。

递归回溯生成迷宫的思路其实和P1605的DFS一模一样：把地图看成一个个小格子，从某个格子出发，随机选择一个方向，打通相邻的墙，进入新格子，继续递归。当所有方向都被访问过时，回溯。这个过程保证了任意两个格子之间都存在唯一路径，生成的迷宫天然是有解的，而且不会出现环路。

随机Prim算法的思路则是：维护一个“候选墙列表”，每次从列表里随机取一堵墙，判断墙另一侧的格子是否未被访问，如果未被访问，就把墙打通，把新格子的其他墙加入列表。这个算法生成的迷宫更均衡，分支更多。我在做游戏关卡设计时经常用这个思路，它能生成视觉上“更散开”的迷宫，而不是一条长链到底。

这里给一个简单的递归回溯生成器伪代码，它和P1605的DFS结构几乎一一对应：

text复制把初始地图全部设置为墙
选一个起始格子(比如(2,2))，标记为通路
dfs_生成迷宫(x, y):
    随机打乱四个方向
    for each 方向 in 四个方向:
        nx = x + dx * 2   // 步长2，因为要跨过一堵墙
        ny = y + dy * 2
        if (nx, ny) 在地图内且是墙:
            打通(x,y)到(nx,ny)之间的墙
            标记(nx,ny)为通路
            dfs_生成迷宫(nx, ny)

注意这里和P1605的差别：生成迷宫时步长是2，因为要跳过两格之间的那堵墙；而P1605走迷宫时步长是1，因为每格都是一个合法的位置。这个“步长”的差异是我在教迷宫生成时最想重点强调的，它决定了这两种DFS在代码上的核心区别。

5.2 迷宫最短路径问题：什么时候要换BFS

P1605求的是方案数，但如果你遇到的问题是“从起点到终点最少需要多少步”，那就要把DFS换成BFS。BFS天然按层扩展，第一次到达终点的层数一定是最短步数。这也是迷宫算法里最经典的“最短路径”题目，在各类在线评测系统中出镜率极高。

BFS的核心数据结构是队列，每访问一个新格子，就把它入队，并从队头取出格子继续扩展。因为BFS不需要回溯，所以每个格子只需访问一次——用一个dist数组记录步数，初始化为-1，起点为0，当访问到终点时直接输出dist值。这里有一个练习建议：你在AC了P1605之后，可以尝试把同一张地图上的“最短步数”问题用BFS实现一遍，再把“方案数”用DFS实现一遍，这样能直观体会到两种搜索策略的差异。

5.3 更高级的变体：记忆化搜索与状态压缩

如果迷宫地图变大，比如N、M都到50，纯DFS的方案数统计可能会超时，因为路径数量可能呈指数爆炸。这时可以引入记忆化：用dp[x][y]表示从(x, y)走到终点的方案数。递归时，如果dp[x][y]已经计算过，直接返回，避免重复搜索。这本质上就是带备忘录的动态规划。

有的迷宫题还会在格子里加“传送门”“钥匙”“血包”等道具，这时候搜索状态就不能只是坐标了，还要额外记录道具状态。当道具种类很多时，可以用状态压缩（bitmask）来表示，比如用整数state的第i位表示第i把钥匙是否已获得。这是进阶玩法，但它的底层依然是DFS/回溯的状态扩展逻辑。如果你能把P1605吃透，再往这些方向延伸时会发现很多思路是共通的。

6. 我的一些实际操作心得与建议

关于P1605，最后说几条我个人在实际操作中的体会。这些感悟代码写不出来，但对刷题思路的养成很有帮助。

第一，不要小看模板题。我见过太多学生一上来就刷图论、刷网络流，结果遇到“求方案数”的题目反而卡住，原因就是DFS回溯的基本功不扎实。P1605这道题我认为值得反复刷，甚至可以在不同时间写三遍：第一遍照抄理解，第二遍脱离题解默写，第三遍尝试改进成记忆化或改成BFS版的最短路径。每刷一遍，你对递归的理解都会加深一层。

第二，递归函数里“参数越少越好”并不绝对。这道题用全局变量确实方便，但在理解递归时，我建议你用带参数的方式重新实现一遍，比如dfs(x, y, step)或dfs(x, y, path)，这样你能更直观地看到每一层递归携带了哪些信息。不要害怕改代码，多写几个版本对理解状态传递非常有帮助。

第三，调试DFS时，可视化输出是神技。在dfs函数里临时加一个打印函数，把当前地图状态打印出来，或者把路径坐标序列打印出来，你会清晰地看到“走到死胡同、回溯、换方向”的全过程。我自己调试迷宫类算法时，经常用printf打印当前坐标和已访问标记，这比用调试器设断点更直观。打印信息虽然让代码变慢，但在小数据量下完全不影响验证，调试完再删掉即可。

第四，想清楚再动手。有的同学拿到P1605就直接开始写for循环套方向数组，结果写到一半发现边界条件没想清楚。我的建议是先在草稿纸上画一个4×4的迷宫，手动模拟一遍DFS的递归过程——这比在编辑器里反复尝试高效得多。当你真正理解了一棵“搜索树”长什么样，DFS的代码就只是把树的遍历翻译了一遍，套路感会瞬间清晰。

第五，如果你想要更大的挑战，尝试把这道题的输入规模改成N=M=20，然后用记忆化搜索重新实现，看看方案数是否会溢出int范围。这个练习会让你意识到：方案数统计问题在数据放大后，答案本身就可能超过2^31-1，需要考虑用long long甚至大数。这是从“入门”走向“进阶”的必经一步。

P1605是一道值得认真对待的题目。它不只是一道OJ上的习题，更是理解DFS回溯、搜索树、状态标记、递归边界这些核心概念的绝佳载体。希望这篇讲透了的文章能帮你在迷宫里找到自己的路，也找到正确的递归路径。