【代码训练营】day39 62.不同路径 & 63. 不同路径 II

所用代码 java

不同路径 LeetCode 62

题目链接：不同路径 LeetCode 62 - 中等

思路

• 确定dp数组及下标的含义：从(0,0)到达(i, j)位置总共的路径有dp[i] [j]种
• 递推公式：dp[i] [j] = dp[i-1] [j] + dp[i] [j-1] 该位置数量等于上一行的数量加上一列的数量
• dp数组初始化：dp[i] [0] = 1, dp[0] [i] = 1 第一行和第一列只有一种
• 遍历方向：左到右，上到下
• 打印dp数组：debug

class Solution {
    public 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 i = 0; i < n; i++) {
            dp[0][i] = 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];
//                System.out.println("i=" + i + "=>" + "j=" + j +" => " + dp[i][j] );
//                System.out.println("dp[i-1][j]:" + dp[i-1][j]+ "\tdp[i][j-1]:" + dp[i][j-1]);
            }
        }
        return dp[m-1][n-1];
    }
}

总结

本题的i和j不是第i行和第j列的位置，而是i-1行j-1列的位置，dp[i] [j] 也是指的总共有的路线有多少种。

初次之外，我们每次使用dp[i-1] [j] 的dp[i-1] [j]全是来自于上一行 （前一个状态） ，和上上一行没有关系，所用可以用滚动数组的方式进行空间优化：

class Solution {
    public int uniquePaths(int m, int n) {
        // 总共有n列，行每次进行滚动处理
        int[] dp = new int[n];
        // 使用Arrays的填充功能
        Arrays.fill(dp, 1);
        // 一行一行的滚动处理
        for (int i = 1; i < m; i++) {
            // 每次只需要更新列的值
            for (int j = 1; j < n; j++) {
                dp[j] = dp[j-1] + dp[j];
            }
        }
        return dp[n-1];
    }
}

滚动数组的重点在于：dp[j] = dp[j-1] + dp[j]; 他和二维数组的 dp[i][j] = dp[i-1][j] + dp[i][j-1]; 联系在于：

• dp[j-1] 和dp[i-1] [j] 类似：都是左侧的值。
• dp[j] 和dp[i] [j-1] 类似：dp[i] [j-1]是上一行的结果，也就是前一个状态的结果，这个结果与上上行没有关系，而dp[j]同样是前一个状态，即未更新前的结果。

所以我们可以用滚动数组来进行空间上的优化。

不同路径 LeetCode 63 II

题目链接：不同路径 LeetCode 62 II- 中等

思路

和上一题差不多，但是要考虑一个是有没有障碍物，有的话就不能过表示0

• dp数组含义：从（0，0）到（i，j）总共有dp[i] [j]种路径
• 递推公式：dp[i] [j] = dp[i-1] [j] + dp[i] [j-1] 且 没有障碍物，有障碍的地方dp[i] [j] = 0
• 初始化：dp[i] [0] = 1, dp[0] [i] = 1 且 遇到有石头的地方dp[i] [j] = 0，后面的全为0
• 遍历方向：左到右，上到下
• debug

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[][] dp = new int[m][n];
        // 初始化第一个列，遇到石头下面都不通
        for (int i = 0; i < m; i++) {
            if (obstacleGrid[i][0] == 1) {
                dp[i][0] = 0;
                break;
            }else dp[i][0] = 1;
        }
        // 初始化第一个行，遇到石头右边都不通
        // for(int i = 0; i< n && obstacleGrid[0][i]== 0; i++)
        for (int i = 0; i < n; i++) {
            if (obstacleGrid[0][i] == 1) {
                dp[0][i] = 0;
                break;
            }else dp[0][i] = 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];
    }
}

总结

本题和上一题主要是多了一个障碍物，我们就可以视障碍物为0，即没有任何路径到这个地方。

然后就是初始化的时候遇到障碍就要退出，因为不管是从左到右还是从上到下，遇到障碍是过不去的。

另外初始化的for循环条件可以这样写就比较简单：for(int i = 0; i< n && obstacleGrid[0][i]== 0; i++)

滚动数组空间优化：

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length; // 行
        int n = obstacleGrid[0].length; // 列
        int[] dp = new int[n];
        // 先初始化第一行
        for (int i = 0; i < n && obstacleGrid[0][i] == 0; i++) {
            dp[i] = 1;
        }
        for (int i = 1; i < m; i++) {
            for (int j = 0; j < n; j++) {
                // 有障碍的时候值为0，到下一层遍历的时候相当于上面那个数是石头0
                // 就只用考虑左边的数
                // 还要考虑第一列有没有障碍，所以j从0开始
                if (obstacleGrid[i][j] == 1){
                    dp[j] = 0;
                }else if (j != 0){
                    dp[j] = dp[j-1] + dp[j];
                }
            }
        }
        return dp[n-1];
    }
}