代码随想录-刷题第三十九天

动态规划理论基础

动态规划的题目由重叠子问题构成,每一个状态一定是由上一个状态推导出来的。这一点就区分于贪心,贪心没有状态推导,而是从局部直接选最优的。

动态规划五步曲

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

动态规划里面递推公式十分重要,但是确定dp数组,初始化,遍历顺序也同样十分重要,一定要严格按照这五步进行,将每一步的思路理清。

做动态规划的题目遇到问题时,最好的方式就是打印出dp数组,看是否和自己推理一致。


509. 斐波那契数

题目链接:509. 斐波那契数

思路:动态规划五步曲:

  1. dp[i]的定义为:第i个数的斐波那契数值是dp[i]

  2. 递推公式:dp[i] = dp[i - 1] + dp[i - 2]

  3. 初始化:dp[0] = 0, dp[1] = 1

  4. 从递推公式可以看出,一定是从前向后遍历的。

  5. 举例看是否可行,当N为10的时候,dp数组应该是如下的数列:

    0 1 1 2 3 5 8 13 21 34 55

    如果代码写出来,发现结果不对,就把dp数组打印出来看看与推导的数列是否一致。

class Solution {
    public int fib(int n) {
        if (n == 0) return 0;
        if (n == 1) return 1;             
        int[] dp = new int[n + 1];
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++){
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
}

可以发现,只需要维护两个数值,不需要记录整个序列。代码如下:

class Solution {
    public int fib(int n) { // 动态规划
        if (n <= 1) return n;
        int dp0 = 0;
        int dp1 = 1;
        for (int i = 2; i <= n; i++) {
            int sum = dp1 + dp0;
            dp0 = dp1;
            dp1 = sum;
        }
        return dp1;
    }
}

70. 爬楼梯

题目链接:70. 爬楼梯

思路:动态规划五步曲

  1. dp[i]: 爬到第i层楼梯,有dp[i]种方法

  2. 递推公式:dp[i] = dp[i - 1] + dp[i - 2]

    从dp[i]的定义可以看出,dp[i] 可以有两个方向推出来。

    首先是dp[i - 1],上i-1层楼梯,有dp[i - 1]种方法,那么再一步跳一个台阶不就是dp[i]了么。

    还有就是dp[i - 2],上i-2层楼梯,有dp[i - 2]种方法,那么再一步跳两个台阶不就是dp[i]了么。

    那么dp[i]就是 dp[i - 1]与dp[i - 2]之和!所以dp[i] = dp[i - 1] + dp[i - 2] 。

    在推导dp[i]的时候,一定要时刻想着dp[i]的定义,否则容易跑偏。

  3. 初始化:dp[1] = 1, dp[2] = 2

    题目提示:1 <= n <= 45,所以本题不用考虑dp[0]的初始化!

  4. 从递推公式可以看出是从前向后遍历。

  5. 举例看是否可行

class Solution {
    public int climbStairs(int n) {
        if (n == 1) return 1;
        // 1、确定dp数组及下标含义
        // dp[i]代表爬到第i层楼梯,有dp[i]种方法
        int[] dp = new int[n + 1];
        // 2、确定递推函数
        // dp[i] = dp[i - 1] + dp[i - 2]
        // 3、确定初始化
        dp[1] = 1;
        dp[2] = 2;
        // 4、确定遍历顺序
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
}

本题与斐波那契数相同,可以将空间复杂度从O(n)降为O(1)。


746. 使用最小花费爬楼梯

题目链接:746. 使用最小花费爬楼梯

思路:动态规划五步曲

  1. dp[i]的定义:到达第i台阶所花费的最少体力为dp[i]。

    题目中说 “你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯” 也就是相当于 跳到 下标 0 或者 下标 1 是不花费体力的, 从 下标 0 下标1 开始跳就要花费体力了。

  2. 递推公式:dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])

    可以有两个途径得到dp[i],一个是dp[i - 1],一个是dp[i - 2]

    dp[i - 1] 跳到 dp[i] 需要花费 dp[i - 1] + cost[i - 1]。

    dp[i - 2] 跳到 dp[i] 需要花费 dp[i - 2] + cost[i - 2]。

    那么究竟是从dp[i - 1]跳还是从dp[i - 2]跳呢?一定是选最小的!

  3. 初始化:dp[0] = 0, dp[1] = 0。我们认为第一步无需支付费用,所以到第一个台阶和到第二个台阶都是0。

  4. 遍历顺序为从前到后

  5. 举例推导dp数组

    拿cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1] ,来模拟一下dp数组的状态变化

    代码随想录-刷题第三十九天_第1张图片

    如果代码写出来有问题,就把dp数组打印出来,看看和如上推导的是否一致。

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int len = cost.length;
        int[] dp = new int[len + 1];
        // 每次最多走两步,前两个台阶无需支付费用
        dp[0] = 0;
        dp[1] = 0;
        // 计算到达每一层台阶的最小费用
        for (int i = 2; i <= len; i++) {
            dp[i] = Math.min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
        }
        return dp[len];
    }
}

还可以优化空间复杂度,因为dp[i]就是由前两位推出来的,那么也不用dp数组了

class Solution {
    public int minCostClimbingStairs(int[] cost) {
        int len = cost.length;
        // 每次最多走两步,前两个台阶无需支付费用
        int dp0 = 0;
        int dp1 = 0;
        // 计算到达每一层台阶的最小费用
        for (int i = 2; i <= len; i++) {
            int dp_i = Math.min(dp1 + cost[i - 1], dp0 + cost[i - 2]);
            dp0 = dp1;
            dp1 = dp_i;
        }
        return dp1;
    }
}

你可能感兴趣的:(数据结构,数据结构,算法,java,leetcode,动态规划)