LeetCode 980题解析：DFS回溯解决网格路径问题

1. 题目解析与问题建模

LeetCode 980题"不同的路径III"是一个典型的网格回溯问题，题目给定一个m×n的二维网格，其中：

• 1表示起点
• 2表示终点
• 0表示可通行空地
• -1表示障碍物

我们需要找出从起点到终点的所有路径，且这些路径必须经过所有可通行的空地。换句话说，这是一道要求在特定约束条件下枚举所有可能路径的问题。

1.1 输入输出示例分析

考虑以下典型输入：

java复制int[][] grid = {
    {1, 0, 0, 0},
    {0, 0, 0, 0},
    {0, 0, 2, -1}
};

这个3×4的网格中：

• (0,0)是起点
• (2,2)是终点
• (2,3)是障碍物
• 其余都是可通行空地

正确的输出应该是2，因为有两条满足条件的路径：

1. 右→右→右→下→下→左
2. 下→下→右→右→右→上

1.2 问题约束条件

解决这个问题需要满足三个核心约束：

1. 路径必须从起点出发，到终点结束
2. 路径必须覆盖所有可通行的空地（即所有0）
3. 路径不能重复经过同一个格子（包括起点和终点）

这些约束条件决定了我们需要使用深度优先搜索(DFS)结合回溯的算法策略。

2. 算法设计与核心思路

2.1 DFS回溯算法框架

这类网格路径问题通常采用DFS+回溯的解法，基本框架如下：

1. 找到起点位置，初始化必要参数
2. 从起点开始进行DFS搜索
3. 在每个位置尝试四个方向移动
4. 确保不越界、不重复访问、不碰到障碍物
5. 到达终点时检查是否覆盖所有可通行格子
6. 回溯时恢复访问状态

2.2 关键变量设计

我们需要维护几个关键状态变量：

• empty：记录需要覆盖的可通行格子总数
• count：记录当前已经覆盖的可通行格子数
• res：记录满足条件的路径总数

在Java中实现时，我们可以使用成员变量来维护这些状态：

java复制private int empty = 1; // 初始化为1是因为起点也算一个需要"覆盖"的格子
private int res = 0;

2.3 方向数组的使用

为了代码简洁，我们通常使用方向数组来表示四个可能的移动方向：

java复制private static final int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // 上、下、左、右

这样在DFS中可以通过循环来尝试所有方向，避免重复代码。

3. Java实现详解

3.1 完整解法代码

以下是完整的Java实现方案：

java复制class Solution {
    private int empty = 1; // 初始化为1是因为起点也算一个需要"覆盖"的格子
    private int res = 0;
    private static final int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    public int uniquePathsIII(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        int startX = 0, startY = 0;
        
        // 第一步：预处理，找到起点并统计需要覆盖的格子数
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 1) {
                    startX = i;
                    startY = j;
                } else if (grid[i][j] == 0) {
                    empty++;
                }
            }
        }
        
        // 第二步：从起点开始DFS
        dfs(grid, startX, startY, 0);
        return res;
    }
    
    private void dfs(int[][] grid, int x, int y, int count) {
        // 边界检查
        if (x < 0 || x >= grid.length || y < 0 || y >= grid[0].length || grid[x][y] == -1) {
            return;
        }
        
        // 到达终点检查
        if (grid[x][y] == 2) {
            if (count == empty) {
                res++;
            }
            return;
        }
        
        // 标记当前格子为已访问（障碍物）
        grid[x][y] = -1;
        
        // 尝试四个方向
        for (int[] dir : dirs) {
            dfs(grid, x + dir[0], y + dir[1], count + 1);
        }
        
        // 回溯，恢复格子状态
        grid[x][y] = 0;
    }
}

3.2 代码关键点解析

1. 预处理阶段：

   • 遍历整个网格，定位起点坐标
   • 统计所有可通行格子数（empty），注意起点本身也算一个需要覆盖的格子

2. DFS递归函数：

   • 边界检查：确保不越界且不是障碍物
   • 终止条件：到达终点时检查是否覆盖了所有可通行格子
   • 状态标记：将当前格子临时标记为-1（障碍物）防止重复访问
   • 方向探索：尝试四个方向的移动
   • 状态恢复：回溯时将格子恢复为可通行状态

3. 计数逻辑：

   • count参数记录当前路径已经覆盖的格子数
   • 只有当count == empty时才认为找到了一条有效路径

4. 算法优化与复杂度分析

4.1 时间复杂度分析

在最坏情况下，算法需要尝试所有可能的路径。对于m×n的网格：

• 每个格子有4个可能的移动方向
• 但实际移动受限于已访问格子和障碍物
• 时间复杂度约为O(4^(m*n))，但在实际中由于障碍物和访问限制，实际运行时间会小很多

4.2 空间复杂度分析

• 主要空间消耗来自递归调用栈
• 最坏情况下递归深度为网格中所有可通行格子的数量
• 空间复杂度为O(m*n)

4.3 优化思路

虽然这道题的约束条件通常不会导致性能问题，但对于更大的网格可以考虑以下优化：

1. 提前终止：

   • 如果剩余未访问的可通行格子数大于剩余步数，可以提前终止当前路径的搜索

2. 记忆化搜索：

   • 对于某些变种问题，可以缓存部分结果避免重复计算
   • 但本题由于路径必须覆盖所有格子，记忆化的效果有限

3. 位图优化：

   • 对于小网格，可以用位图表示访问状态
   • 可以压缩状态表示，减少内存使用

5. 常见错误与调试技巧

5.1 新手常见错误

1. 忘记统计起点：

   • 起点(1)也是一个需要"覆盖"的格子，empty初始值应为1

2. 回溯时状态恢复错误：

   • 必须将临时标记为-1的格子恢复为0
   • 否则会影响其他路径的搜索

3. 终止条件顺序错误：

   • 必须先检查边界条件，再检查是否到达终点
   • 否则可能导致数组越界异常

5.2 调试技巧

1. 打印路径：
   • 可以添加一个path变量记录当前路径
   • 找到有效路径时打印出来，便于验证

java复制private void dfs(int[][] grid, int x, int y, int count, List<String> path) {
    // ...
    path.add("(" + x + "," + y + ")");
    if (grid[x][y] == 2) {
        if (count == empty) {
            System.out.println("Found path: " + path);
            res++;
        }
        path.remove(path.size() - 1);
        return;
    }
    // ...
    path.remove(path.size() - 1);
}

2. 可视化网格状态：

   • 在关键位置打印当前网格状态
   • 帮助理解算法的执行过程

3. 使用小规模测试用例：

   • 先用2×2或3×3的小网格测试
   • 确保基本逻辑正确后再测试更大网格

6. 相似题目与扩展思考

6.1 LeetCode相似题目

1. 不同路径I(LeetCode 62)：

   • 更简单的版本，只需要计算从左上到右下的路径数
   • 可以用动态规划解决

2. 不同路径II(LeetCode 63)：

   • 加入了障碍物，但不需要覆盖所有格子
   • 仍然是动态规划思路

3. 单词搜索(LeetCode 79)：

   • 类似的网格DFS问题
   • 需要在网格中查找单词

6.2 算法扩展应用

这种DFS+回溯的算法模式可以应用于许多类似场景：

1. 迷宫求解：

   • 寻找从入口到出口的所有路径
   • 可以加入各种约束条件

2. 棋盘游戏：

   • 如数独求解、八皇后问题等
   • 都需要回溯尝试各种可能性

3. 排列组合问题：

   • 当问题可以建模为状态空间搜索时
   • 回溯算法是通用解决方案

6.3 变种问题思考

可以尝试解决这道题的几个变种：

1. 允许重复经过某些格子：

   • 修改访问标记逻辑
   • 可能需要限制最大重复次数

2. 寻找最短覆盖路径：

   • 在满足覆盖所有格子的条件下
   • 寻找步数最少的路径

3. 三维网格版本：

   • 将网格扩展到三维
   • 需要处理6个移动方向

7. 工程实践中的注意事项

在实际工程中实现这类算法时，有几个重要考虑因素：

1. 网格规模限制：

   • 对于大网格，DFS回溯可能不够高效
   • 需要考虑更优化的算法或启发式方法

2. 并发安全问题：

   • 如果并行处理，需要注意网格状态的同步
   • 每个线程应该有自己的网格状态副本

3. 内存使用优化：

   • 对于大网格，可以用位操作压缩状态
   • 或者使用更高效的数据结构表示网格

4. 算法选择策略：

   • 根据具体约束条件选择合适算法
   • 有时BFS可能比DFS更适合

提示：在面试中遇到这类问题时，建议先清楚地陈述你的思路，包括如何建模问题、选择算法的理由以及可能的优化方向。面试官通常更关注你的解题过程而不仅仅是最终代码。