数据结构刷题（二十九）：62不同路径、63不同路径II、343.整数拆分

一、62. 不同路径

仍然是动态规划五步走：

1.确定dp数组（dp table）以及下标的含义

dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。

2.确定递推公式

想要求dp[i][j]，只能有两个方向来推导出来，即dp[i - 1][j] 和 dp[i][j - 1]。

3.dp数组的初始化

如何初始化呢，首先dp[i][0]一定都是1，因为从(0, 0)的位置到(i, 0)的路径只有一条，那么dp[0][j]也同理。

4.确定遍历顺序：确定机器人只能向右或向下走

5.举例子推导：

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 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];
            }
        }
        // 区别于一维动态规划数组长度n+1
        return dp[m-1][n-1];
    }
}

 二、63. 不同路径 II

1.区别于不同路径，如果在行进过程中障碍，那么当前的(i, j)如果就是障碍的话应该就保持初始状态（初始状态为0）

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        
        // 先get一下长宽
        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;
        }
        // 初始化
        // 障碍之后（包括障碍）都是走不到的位置，所以障碍之后的dp[i][0]应该还是初始值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循环中，碰见障碍物就设置为0
        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];
    }
}

三、343. 整数拆分

1.注意点：初始化是从dp[2] = 1开始，并且做for循环时，需要对dp[i]本身先进行最大乘积的计算。

2.最后一步确保到dp[n]， 所以保证for循环的i<=n

class Solution {
    public int integerBreak(int n) {

        // dp[i]表示的是当前正整数i的最大乘积所得
        int[] dp = new int[n + 1];
        // 初始化
        dp[2] = 1;
        // 注意i <= n， 最后要算dp[n]
        for (int i = 3; i <= n; i++) {
            // 需要对当前的dp[i]进行最大乘积的计算， 从j=1开始，保证j和i-j的范围
            for (int j = 1; j <= i - j; j++){
                dp[i] = Math.max(dp[i], Math.max(dp[i - j] * j, (i - j) * j));
            }
        }
        return dp[n];
    }
}