代码随想录算法训练营-day39-62. 不同路径、63. 不同路径 II、整数拆分

62. 不同路径

1. 学习文章链接：
2. 思路：重要的是理解在棋盘格中，因为终点只在右下角，因此到达终点的路径只来自两个方向，即上和左，因此推出dp数组递推公式。
3. 代码：

class Solution {
    public int uniquePaths(int m, int n) {
        // dp数组的含义
        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

1. 学习文章链接：
2. 思路：在62.不同路径的基础上增加了障碍物的判定条件。详情见注释。
3. 代码：

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length;
        int n = obstacleGrid[0].length;
        // 障碍物1：如果是起点或者终点，那么无论如何，都没有路可以走。
        if (obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1) return 0;
        int[][] dp = new int [m][n];
        // 初始化数组
        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++) {
                // 障碍物2：
                // 排除障碍
                if (obstacleGrid[i][j] == 1) continue;
                // 递推公式
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
}

343. 整数拆分

1. 学习文章链接：
2. 思路：这题难理解的地方就在于拆分两次及两次以上的计算方法。具体见注释，更详尽的请移步代码随想录！！！
3. 代码：

class Solution {
    public int integerBreak(int n) {
        // dp[i] 为正整数 i 拆分后的结果的最大乘积
        int[] dp = new int[n + 1];
        // 初始化数据，这里因为0 和 1拆分没有意义，因此初始化直接从dp[2]开始。
        dp[2] = 1;
        // 遍历顺序从前向后进行。直到n。
        for (int i = 3; i <= n; i++) {
            // 这里的 j 其实最大值为 i-j 或者 i / 2, 再大只不过是重复而已，
            // 并且，在本题中，我们分析 dp[0], dp[1]都是无意义的，因此也没有进行初始化
            // j 最大到 i-j,就不会用到 dp[0]与dp[1]
            for (int j = 1; j <= i / 2;j ++ ){
                // 递推公式
                // j * （i - j）是将整数拆成两个数以后的乘积，j * dp[i - j]是拆分两个以上的数的乘积。
                dp[i] = Math.max(dp[i], Math.max(dp[i - j] * j, j * (i - j)));
            }
        }
        return dp[n];
    }
}