代码随想录算法训练营第三十九天 | 62.不同路径 & 63. 不同路径 & 343. 整数拆分

1. 不同路径

62. 不同路径 - 力扣（LeetCode）

第一行第一列都是 1

当前位置的路径条数，就是前一格和上一格路径条数相加

class Solution {
    public int uniquePaths(int m, int n) {
        //dp[m][0] = 1 dp[0][n] = 1
        //dp[1][1] = dp[1][0] + dp[0][1]
        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];
            }
        }

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

2. 不同路径 II

63. 不同路径 II - 力扣（LeetCode）

注意在初始化dp的时候，遇到了障碍物，即意味着后面的位置都无法到达

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        //dp[m][0] = 1 dp[0][n] = 1
        //dp[1][1] = dp[1][0] + dp[0][1]
        // m行 n列
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        int[][] dp = new int[m][n];
        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 i = 0; i < n && obstacleGrid[0][i] == 0; i++){
            dp[0][i] = 1;
        }

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

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

3. 整数拆分

343. 整数拆分 - 力扣（LeetCode）

dp[i] 为正整数 i 拆分后的结果的最大乘积

dp[i-j] 为正整数 i-j 拆分后的结果的最大乘积

i 可以拆分成 j +（i-j）

其中 j 是一个固定拆分值 （j是从1开始遍历，拆分j的情况，在遍历j的过程中其实都计算过了）

而 对于i-j 可以直接作为因数，不拆分

也可以拆分 通过 dp[i-j] 找到其拆分后的结果的最大乘积

也可以这么理解，j * (i - j) 是单纯的把整数拆分为两个数相乘，而j * dp[i - j]是拆分成两个以及两个以上的个数相乘。

class Solution {
    public int integerBreak(int n) {
        //dp[i] 为正整数 i 拆分后的结果的最大乘积
        int[] dp = new int[n+1];
        dp[2] = 1; //2: 1*1
        for(int i = 3; i <= n; i++) {
            for(int j = 1; j <= i/2; j++) { // i = j + i-j
                dp[i] = Math.max(dp[i], Math.max(j*(i-j), j*dp[i-j]));
            }
        }
        return dp [n];
    }
}

eg. 6

1*5  1*（1*4，2*3）

2*4  2*（1*3，2*2）对于2 的拆分，前面已经包括

3*3  3*（1*2）