62.不同路径 63.不同路径 II

62.不同路径 63.不同路径 II

62.不同路径

力扣题目链接(opens new window)

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

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

问总共有多少条不同的路径？

示例 1：

• 输入：m = 3, n = 7
• 输出：28

示例 2：

• 输入：m = 2, n = 3
• 输出：3

解释： 从左上角开始，总共有 3 条路径可以到达右下角。

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

示例 3：

• 输入：m = 7, n = 3
• 输出：28

示例 4：

• 输入：m = 3, n = 3
• 输出：6

提示：

• 1 <= m, n <= 100
• 题目数据保证答案小于等于 2 * 10^9

思路:动态规划

思路：动态规划
动态规划五部曲
1.dp数组的定义以及下标的含义
定义二维数组dp[i] [j],表示到达(i,j)点的所有路径
2.推导递归公式
因为路径只会从两个方向过来dp[i-1] [j] 和 dp[i] [j-1]
所以这两个方向路径总和就是到达(i,j)点路径的总和
dp[i] [j] = dp[i-1] [j] + dp[i] [j-1]
3.dp数组初始化
因为到达dp[0] [j] 和 dp[0] [j]只有一条路径
dp[0] [j] = 1 dp[i] [0] = 1
4.遍历顺序
题目要求从机器人只能向下或者向右移动，相当于从（0，0）移动到（i，j)
从前到后一层层遍历即可
5.举例推导dp数组
如图所示

时间复杂度：O(m * n)
空间复杂度：O(m * n)

代码如下

public static void main(String args[]){
    int m =3;
    int n =7;
    uniquePaths(3,7);
}


public static int uniquePaths(int m, int n) {
    int[][] dp = new int[m][n];
    for (int i = 0; i < m; i++)
        dp[i][0] = 1;
    for (int j = 0; j < n; j++)
        dp[0][j] = 1;

    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            dp[i][j] = dp[i-1][j] + dp[i][j-1];
        }
    }

    return dp[m-1][n-1];
}

63.不同路径 II

力扣题目链接(opens new window)

一个机器人位于一个 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

思路:动态规划

如果某个问题有很多重叠子问题，那么使用动态规划是最有效的，所以动态规划的每一个状态一定是由上一个状态推导出来的
跟不同路径相比，此题目在基础上增加了障碍。障碍无法在路径上出现。初始化障碍(i,j)点的dp[i] [j]值为0
原因请看示例，举例如下

到达点1(i,j)的路径数量dp[i] [j] = dp[i-1] [j] + dp[i] [j-1]
但由于dp[i-1] [j]是障碍，没有达到障碍的路径，所以dp[i-1] [j]等于0
因此得出障碍点对应dp数组值为0
因为机器人只能向右侧和下侧移动，如果障碍在上边界和左边界出现，障碍之后（包括障碍）都是走不到的位置了，所以障碍之后的dp应该还是初始值0。
所以需要考虑障碍在上左边界出现的情况
动态规划五部曲
1.确认dp数组以及下标含义
定义二维数组dp[i] [j]表示到达(i,j)点路径的数量
2.确认递推公式
dp[i] [j] = dp[i] [j] = dp[i-1] [j] + dp[i][j-1]
3.初始化dp数组
因为到达dp[0] [j] 和 dp[0] [j]只有一条路径
dp[0] [j] = 1 dp[i] [0] = 1
障碍所在点dp[i] [j] = 0
障碍在上边界出现的情况dp[0] [j]
dp[0] [j]这条边之后的节点都为0
障碍在左边界出现的情况
dp[i] [0]这条边之后的节点都为0
4.确认遍历顺序
题目要求从机器人只能向下或者向右移动，相当于从（0，0）移动到（i，j)
从前到后一层层遍历即可
5.举例推导dp数组
obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]] 一共两条路线

时间复杂度：O(m * n)
空间复杂度：O(m * n)

代码如下

public static void main(String args[]) {
    int[][] obstacleGrid = new int[][]{{1, 0}};
    uniquePathsWithObstacles(obstacleGrid);
}

public static int uniquePathsWithObstacles(int[][] obstacleGrid) {
    int m = obstacleGrid.length;
    int n = obstacleGrid[0].length;
    int[][] dp = new int[m][n];// dp数组初始化

    for (int i = 0; i < m && obstacleGrid[i][0] != 1; i++) {
        dp[i][0] = 1;
    }
    for (int j = 0; j < n && obstacleGrid[0][j] != 1; j++) {
        dp[0][j] = 1;
    }


    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            if (obstacleGrid[i][j] == 1) {// 遍历到障碍节点
                dp[i][j] = 0;
            } else {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
    }

    return dp[m - 1][n - 1];
}

问题

问题
在障碍出现在上左边界时，初始化出现错误
我的思路是：当障碍出现在上左边界，边界dp均初始化为0.
正确思路是：当障碍出现在上左边界，障碍包括障碍后的边界所对应dp均为0，障碍所在边界前的dp均为1
但正确思路也不是我排查出，而是想不出来才看的题解
像这类问题可以归根于初始化dp数组错误，进而导致推导的dp数组出现错误
如果在举例推导dp数组时，针对障碍在边界的情况推导。这类问题是可以避免的。但我只是在脑海里推演，并不严谨
所以举例推导dp数组很重要，而且要推导到特殊情况