代码随想录算法训练营第三十九天 | 62.不同路径、63. 不同路径 II

代码随想录算法训练营第三十九天 | 62.不同路径、63. 不同路径 II

62.不同路径

题目链接：62.不同路径

动态规划算法

思路：

1. 确定 dp 数组以及下标的含义： dp[i][j] 表示从 (0,0) 出发，到 (i, j) 有 dp[i][j] 条不同的路径;
2. 确定递推公式： 想要求 dp[i][j]，只能有两个方向来推导出来，即 dp[i - 1][j] 和 dp[i][j - 1]。dp[i - 1][j] 表示从 (0, 0) 的位置到 (i - 1, j) 有几条路径，dp[i][j - 1] 同理。因此 dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，因为 dp[i][j] 只有这两个方向过来;
3. dp 数组如何初始化： 首先 dp[i][0] 即第一行一定都是1，因为从 (0, 0) 的位置到 (i, 0)的路径只有一条，那么 dp[0][j] 也同理；
4. 确定遍历顺序： 从递推公式 dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，dp[i][j] 都是从其上方和左方推导而来，那么从左到右一层一层向下遍历就可以了；
5. 举例推导dp数组： 如下图所示

class Solution {
    public int uniquePaths(int m, int n) {
        if(m <= 2 && n <= 2) return Math.min(m, n);
        // 1.确定 dp 数组及下标的含义：到达当前位置有几条路径
        int[][] dp = new int[m][n];
        // 3.初始化 dp 数组
        for(int i = 0; i < m; i++) {
            dp[i][0] = 1;
        }
        for(int i = 0; i < n; i++) {
            dp[0][i] = 1;
        }
        // 4.确定遍历顺序
        for(int i = 1; i < m; i++) {
            for(int j = 1; j < n; j++) {
                // 2.确定递推公式
                dp[i][j] = dp[i][j - 1] + dp[i - 1][j];
            } 
        }
        // 5.打印 dp 数组（debug 用）
        return dp[m - 1][n - 1];
    }
}

63. 不同路径 II

题目链接：63. 不同路径 II

动态规划算法

思路：本题与上一题相比，主要变动在于障碍改变了递推公式的条件，以及 dp 数组的初始化。

1. 确定 dp 数组以及下标的含义： dp[i][j] 表示从 (0,0) 出发，到 (i, j) 有 dp[i][j] 条不同的路径;
2. 确定递推公式： 与上一题类似，只是需要判断当前位置是否有障碍；
3. dp 数组如何初始化： 在上一题的基础上，以第一行为例，若当前位置有障碍，则后续位置无需初始化，第一列同理。
4. 确定遍历顺序： 从递推公式 dp[i][j] = dp[i - 1][j] + dp[i][j - 1]，dp[i][j] 都是从其上方和左方推导而来，那么从左到右一层一层向下遍历就可以了；
5. 举例推导dp数组： 如下图所示（以力扣本题实例一为例）

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        // 如果在起点或终点出现了障碍，直接返回0
        if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1) {
            return 0;
        }
        
        // 1.确定 dp 数组及下标含义
        int[][] dp = new int[m][n];
        // 3.dp 数组初始化
        for(int i = 0; i < n; i++) { // 第一行
            if(obstacleGrid[0][i] == 1) {
                break;
            } else {
                dp[0][i] = 1;
            }
        }

        for(int j = 0; j < m; j++) { // 第一列
            if(obstacleGrid[j][0] == 1) {
                break;
            } else {
                dp[j][0] = 1;
            }
        }

        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                System.out.print(dp[i][j] + " ");
            }
            System.out.println();
        }

        // 4.确定遍历顺序
        for(int i = 1; i < m; i++) {
            for(int j = 1; j < n; j++) {
                // 2.确定递推公式
                if(obstacleGrid[i][j] == 1) {
                    continue;
                } else if(obstacleGrid[i - 1][j] == 1) {
                    dp[i][j] = dp[i][j - 1];
                } else if(obstacleGrid[i][j - 1] == 1) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = dp[i][j - 1] + dp[i - 1][j];
                }
            }
        }

        // 5.打印 dp 数组（debug 用）
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                System.out.print(dp[i][j] + " ");
            }
            System.out.println();
        }

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

// 代码随想录版本一：
class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[][] dp = new int[m][n];

        //如果在起点或终点出现了障碍，直接返回0
        if (obstacleGrid[m - 1][n - 1] == 1 || obstacleGrid[0][0] == 1) {
            return 0;
        }

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

        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = (obstacleGrid[i][j] == 0) ? dp[i - 1][j] + dp[i][j - 1] : 0;
            }
        }
        return dp[m - 1][n - 1];
    }
}

// 代码随想录版本二（空间优化）：
class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[] dp = new int[n];

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

        for (int i = 1; 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];
    }
}