【代码随想录】【动态规划】基础理论 基础题目

基础理论

动态规划适合有重叠子问题性质的题目。

动态规划中每一个状态一定是由上一个状态推导出来的。

动态规划五步曲

1. 确定dp数组（dp table）以及下标的含义
2. 确定递推公式
3. dp数组如何初始化
4. 确定遍历顺序
5. 举例推导dp数组

动态规划debug

• 找问题的最好方式就是把dp数组打印出来，看看究竟是不是按照自己思路推导的！
• 如果打印出来和自己预先模拟推导是一样的，那么就是自己的递归公式、初始化或者遍历顺序有问题了。
• 如果和自己预先模拟推导的不一样，那么就是代码实现细节有问题。

刷题顺序

基础题目

70. 爬楼梯

class Solution {
    public int climbStairs(int n) {
        // dp[i]: 爬到第i阶有几种爬法
        int[] dp = new int[n+1];

        // 初始化
        dp[0] = 1;

        if(n == 0){
            return dp[n];
        }

        dp[1] = 1;

        // 递推公式
        for(int i=2; i<=n; i++){
            dp[i] = dp[i-1] + dp[i-2];
        }

        // 返回结果
        return dp[n];
    }
}

746. 使用最小花费爬楼梯

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int n = cost.length; // 台阶下标: 0->n

        // dp[i]: 爬到第i级台阶所需的最小费用
        int[] dp = new int[n+1];

        // 初始化
        dp[0] = 0;
        dp[1] = 0; // min{cost[0], 0}

        // 递推计算
        for(int i=2; i<=n; i++){
            dp[i] = Math.min(dp[i-1] + cost[i-1], dp[i-2] + cost[i-2]);
        }

        // 返回结果
        return dp[n]; // 楼顶相当于第n+1级台阶
    }
}

62. 不同路径

class Solution {
    public int uniquePaths(int m, int n) {
        // dp[i][j]：从map[0][0]到map[i][j]有多少条不同的路径
        int[][] dp = new int[m][n];

        // 初始化
        for(int j=0; j<n; j++){
            dp[0][j] = 1;
        }
        for(int i=0; i<m; i++){
            dp[i][0] = 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

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
        int m = obstacleGrid.length, n = obstacleGrid[0].length;

        // dp[i][j]：从map[0][0]到map[i][j]有多少条不同的路径
        int[][] dp = new int[m][n];

        // 初始化
        boolean flag = false; // 第一个障碍物之后的位置可达路径均为0
        for(int j=0; j<n; j++){
            if(flag == false){
                if(obstacleGrid[0][j] == 0){
                    dp[0][j] = 1;
                }else{
                    // 第一次遇到障碍物
                    flag = true;
                    dp[0][j] = 0;
                }
            }else{
                dp[0][j] = 0;
            }
        }
        flag = false;
        for(int i=0; i<m; i++){
            if(flag == false){
                if(obstacleGrid[i][0] == 0){
                    dp[i][0] = 1;
                }else{
                    // 第一次遇到障碍物
                    flag = true;
                    dp[i][0] = 0;
                }
            }else{
                dp[i][0] = 0;
            }
        }

        // 递推计算
        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];
    }
}

343. 整数拆分

class Solution {
    public int integerBreak(int n) {
        // dp[i]: 将正整数i拆分成至少两个正整数的和之后，得到的最大乘积
        int[] dp = new int[n+1];

        // 初始化：0和1都无法拆分成至少两个正整数的和
        dp[0] = dp[1] = 1;

        // 递推计算
        for(int i=2; i<=n; i++){
            // 先从dp[i]中拆分出一个正整数k（1<=k<i）
            // 对于剩下的i-k，可以不拆分：k*(i-k)，也可以继续拆分成两个正整数之和：k*dp[i-k]
            dp[i] = 0;
            for(int k=1; k<i; k++){
                dp[i] = Math.max(Math.max(k*(i-k), k*dp[i-k]), dp[i]);
            }
        }

        // 返回结果
        return dp[n];
    }
}

96. 不同的二叉搜索树

class Solution {
    public int numTrees(int n) {
        // dp[i]：由节点值从1到n的n个节点组成的二叉搜索树的种数
        int[] dp = new int[n+1];

        // 初始化：不存在由0个节点组成的二叉搜索树
        dp[0] = 1;

        // 递推计算
        for(int i=1; i<=n; i++){
            dp[i] = 0;
            for(int k=1; k<=i; k++){
                dp[i] += (dp[k-1] * dp[i-k]);
            }
        }

        // 返回结果
        return dp[n];
    }
}