LeetCode 第63题：不同路径 II

LeetCode 第63题：不同路径 II

题目描述

一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为 "Start" ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 "Finish"）。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

网格中的障碍物和空位置分别用 1 和 0 来表示。

难度

中等

题目链接

点击在LeetCode中查看题目

示例

示例 1：

输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]] 输出：2 解释：3x3 网格的正中间有一个障碍物。 从左上角到右下角一共有 2 条不同的路径：

1. 向右 -> 向右 -> 向下 -> 向下
2. 向下 -> 向下 -> 向右 -> 向右

示例 2：

输入：obstacleGrid = [[0,1],[0,0]] 输出：1

提示

• m == obstacleGrid.length
• n == obstacleGrid[i].length
• 1 <= m, n <= 100
• obstacleGrid[i][j] 为 0 或 1

解题思路

动态规划

这是"不同路径"的变体，需要考虑障碍物的影响。我们仍然可以使用动态规划，但需要特别处理障碍物的情况。

关键点：

1. 如果起点或终点有障碍物，直接返回0
2. 遇到障碍物时，该位置的路径数为0
3. 第一行和第一列的处理需要特别注意
4. 可以复用输入数组来节省空间

具体步骤：

1. 检查起点是否有障碍物
2. 初始化第一行和第一列
3. 动态规划计算每个位置的路径数
4. 注意处理障碍物的特殊情况

图解思路

算法步骤分析表

步骤	操作	状态	说明
初始	检查	[[0,0,0],[0,1,0],[0,0,0]]	原始网格
第1步	初始化	[[1,1,1],[0,0,0],[0,0,0]]	处理第一行
第2步	计算	[[1,1,1],[1,0,1],[0,0,0]]	处理第二行
最终	完成	[[1,1,1],[1,0,1],[1,1,2]]	得到结果

状态/情况分析表

情况	输入	输出	说明
起点障碍	[[1,0]]	0	无法开始
终点障碍	[[0,1]]	0	无法到达
中间障碍	[[0,0],[0,1]]	0	被阻断

代码实现

C# 实现

public class Solution {
    public int UniquePathsWithObstacles(int[][] obstacleGrid) {
        if (obstacleGrid == null || obstacleGrid.Length == 0) return 0;
        
        int m = obstacleGrid.Length;
        int n = obstacleGrid[0].Length;
        
        // 如果起点或终点有障碍，直接返回0
        if (obstacleGrid[0][0] == 1 || obstacleGrid[m-1][n-1] == 1) return 0;
        
        // 使用long避免整数溢出
        long[] dp = new long[n];
        
        // 初始化第一个位置
        dp[0] = 1;
        
        // 处理每一行
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (obstacleGrid[i][j] == 1) {
                    dp[j] = 0;
                } else if (j > 0) {
                    dp[j] += dp[j-1];
                }
            }
        }
        
        return (int)dp[n-1];
    }
}

Python 实现

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        if not obstacleGrid or not obstacleGrid[0]:
            return 0
        
        m, n = len(obstacleGrid), len(obstacleGrid[0])
        
        # 如果起点或终点有障碍，直接返回0
        if obstacleGrid[0][0] == 1 or obstacleGrid[m-1][n-1] == 1:
            return 0
        
        # 使用一维数组优化空间复杂度
        dp = [0] * n
        dp[0] = 1
        
        # 处理每一行
        for i in range(m):
            for j in range(n):
                if obstacleGrid[i][j] == 1:
                    dp[j] = 0
                elif j > 0:
                    dp[j] += dp[j-1]
        
        return dp[n-1]

C++ 实现

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        if (obstacleGrid.empty() || obstacleGrid[0].empty()) return 0;
        
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        
        // 如果起点或终点有障碍，直接返回0
        if (obstacleGrid[0][0] == 1 || obstacleGrid[m-1][n-1] == 1) return 0;
        
        // 使用long避免整数溢出
        vector<long> dp(n, 0);
        dp[0] = 1;
        
        // 处理每一行
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (obstacleGrid[i][j] == 1) {
                    dp[j] = 0;
                } else if (j > 0) {
                    dp[j] += dp[j-1];
                }
            }
        }
        
        return dp[n-1];
    }
};

执行结果

• 执行用时：80 ms
• 内存消耗：37.5 MB

代码亮点

1. 🎯 使用一维数组优化空间复杂度
2. 💡 使用long类型避免溢出
3. 🔍 巧妙处理障碍物情况
4. 🎨 代码结构清晰简洁

常见错误分析

1. 🚫 没有检查起点和终点的障碍物
2. 🚫 整数溢出问题
3. 🚫 边界条件处理不当
4. 🚫 障碍物处理逻辑错误

解法对比

解法	时间复杂度	空间复杂度	优点	缺点
DFS递归	O(2^(m+n))	O(m+n)	直观易懂	超时
二维DP	O(mn)	O(mn)	容易理解	空间消耗大
一维DP	O(mn)	O(n)	最优解法	不够直观
原地修改	O(mn)	O(1)	空间最优	修改输入

相关题目

• 不同路径 - 中等
• 最小路径和 - 中等
• 地下城游戏 - 困难