力扣第63题 不同路径 || c++ 动态规划 + 优化代码

题目

63. 不同路径 II

中等

相关标签

数组   动态规划   矩阵

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

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

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

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

示例 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. 首先，获取网格的行数和列数，分别存储在变量m和n中。
2. 然后，通过判断起点和终点是否有障碍物来确定是否可以到达终点。如果起点或终点有障碍物，直接返回0，因为无法到达终点。
3. 接下来，创建一个大小为m×n的二维数组dp，用于保存到达每个位置的唯一路径数量。
4. 然后，初始化第一行和第一列的路径数量。如果当前位置没有障碍物，则到达当前位置的路径数量为1；如果当前位置有障碍物，则后面的位置都无法到达，将其路径数量设置为0。
5. 最后，使用动态规划的思想计算除第一行和第一列之外的其他位置的唯一路径数量。对于每个位置(i, j)，如果当前位置有障碍物，则跳过当前位置，不计算到达该位置的路径数量；否则，到达当前位置的唯一路径数量等于到达上方位置和左边位置的唯一路径数量之和。
6. 最终，返回到达右下角位置的唯一路径数量。

复杂度

        时间复杂度:

                O(mn)

时间复杂度为O(mn)，其中m和n分别为网格的行数和列数。这是因为在计算到达每个位置的唯一路径数量时，每个位置最多只需要访问一次，并且每次访问需要常数时间。

        空间复杂度

                O(mn)

空间复杂度也为O(mn)，因为需要创建一个大小为m×n的二维数组dp，用于保存到达每个位置的唯一路径数量。

c++ 代码

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();    // 获取网格的行数
        int n = obstacleGrid[0].size(); // 获取网格的列数
        
        if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1) {
            // 如果在起点或终点出现了障碍，直接返回0，因为无法到达终点
            return 0;
        }
        
        vector<vector<int>> dp(m, vector<int>(n, 0)); // 创建一个大小为m×n的二维数组，用于保存到达每个位置的唯一路径数量
        
        // 初始化第一行和第一列的路径数量
        for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) {
            // 如果当前位置没有障碍，则到达当前位置的路径数量为1
            dp[i][0] = 1;
        }
        
        for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) {
            // 如果当前位置没有障碍，则到达当前位置的路径数量为1
            dp[0][j] = 1;
        }
        
        // 使用动态规划的思想计算除第一行和第一列之外的其他位置的唯一路径数量
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (obstacleGrid[i][j] == 1) {
                    // 如果当前位置有障碍，则跳过当前位置，不计算到达该位置的路径数量
                    continue;
                }
                
                // 到达当前位置的唯一路径数量等于到达上方位置和左边位置的唯一路径数量之和
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        
        return dp[m - 1][n - 1]; // 返回到达右下角位置的唯一路径数量
    }
};

优化空间复杂度代码

一维数组

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();    // 获取网格的行数
        int n = obstacleGrid[0].size(); // 获取网格的列数
        
        if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1) {
            // 如果在起点或终点出现了障碍，直接返回0，因为无法到达终点
            return 0;
        }
        
        vector<int> dp(n, 0); // 创建一个大小为n的一维数组，用于保存到达每个位置的唯一路径数量
        
        // 初始化第一行的路径数量
        for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) {
            // 如果当前位置没有障碍，则到达当前位置的路径数量为1
            dp[j] = 1;
        }
        
        // 使用动态规划的思想计算除第一行之外的其他位置的唯一路径数量
        for (int i = 1; i < m; i++) {
            if (obstacleGrid[i][0] == 1) {
                // 如果当前位置有障碍，则到达该位置的路径数量为0
                dp[0] = 0;
            }
            
            for (int j = 1; j < n; j++) {
                if (obstacleGrid[i][j] == 1) {
                    // 如果当前位置有障碍，则跳过当前位置，不计算到达该位置的路径数量
                    dp[j] = 0;
                } else {
                    // 到达当前位置的唯一路径数量等于到达上方位置和左边位置的唯一路径数量之和
                    dp[j] += dp[j - 1];
                }
            }
        }
        
        return dp[n - 1]; // 返回到达右下角位置的唯一路径数量
    }
};

觉得有用的话可以点点赞，支持一下。

如果愿意的话关注一下。会对你有更多的帮助。

每天都会不定时更新哦  >人<  。