【LeetCode】动态规划总结

置顶

倒过来是圈圈

已于 2023-02-13 10:07:53 修改

阅读量912

点赞数 1

CC 4.0 BY-SA版权

分类专栏： Leetcode进阶之路文章标签：动态规划 leetcode 算法

于 2023-02-12 12:30:11 首次发布

本文链接：https://blog.youkuaiyun.com/qq_43417265/article/details/128791868

动态规划解决的问题

在这里插入图片描述

动态规划和贪心的区别：
动态规划是由前一个状态推导出来的；
贪心是局部直接选最优的。

动态规划解题步骤

状态定义：确定dp数组以及下标的含义
状态转移方程：确定递推公式
初始条件：dp如何初始化
遍历顺序
举例推导dp数组

动态规划如何debug

把dp数组打印出来！！！看看究竟是不是按照自己的思路推导的！

做动规的题目，写代码前一定要把状态转移在dp数组上的具体情况模拟一遍，心中有数，确定最后推出的是想要的结果。

然后再写代码，代码没通过->打印dp数组，看看是不是和自己预先推导的哪里不一样。

如果打印出来和自己预先模拟推导是一样的，那么就是自己的递归公式、初始化或者遍历顺序有问题了。
如果和自己预先模拟推导的不一样，那么就是代码实现细节有问题。

如果代码写出来一直ac不了，灵魂三问：

举例状态转移公式了吗？
打印dp数组了吗？
打印出来的dp数组和我想的一眼吗？

基础题目

1. 整数拆分

343. 整数拆分
给定一个正整数 n ，将其拆分为 k 个 正整数 的和（ k >= 2 ），并使这些整数的乘积最大化。

返回你可以获得的最大乘积。

动态规划五部曲

状态定义：dp[i] 表示分拆数字 i，可以得到的最大乘积。
递推公式：假设对正整数 i 拆分出的第一个正整数是 j（1≤j<i），即 i 可以拆分成 i 和 i-j，则有以下两种情况
（1）i-j不拆了：乘积为 j ∗ ( i − j )
（2）i-j继续拆：乘积为 j ∗ dp [ i − j ]
所以dp[i]=Math.max( j*(i-j) , j*dp[i-j] )
初始条件：dp[0]=dp[1]=0，因为0和1无法拆分成两个正整数
遍历顺序：观察递推公式，dp[i]依靠dp[i-j]，所以一定是从前往后遍历
举例：n=10时，

本题代码如下：

class Solution {
   
   
    public int integerBreak(int n) {
   
   
        int[] dp=new int[n+1];
        for(int i=2;i<=n;i++){
   
   
            for(int j=1;j<i;j++){
   
   
                dp[i]=Math.max(dp[i],Math.max(j*(i-j),j*dp[i-j]));
            }
        }
        return dp[n];
    }
}

时间复杂度： $O(n^2)$
空间复杂度： $O (n)$

2. 不同的二叉搜索树

96.不同的二叉搜索树
给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的二叉搜索树有多少种？返回满足题意的二叉搜索树的种数。

思路

给定一个有序序列 1⋯n，为了构建出一棵二叉搜索树，我们可以遍历每个数字 i，将该数字作为树根，将 1⋯(i−1) 序列作为左子树，将 (i+1)⋯n序列作为右子树。接着我们可以按照同样的方式递归构建左子树和右子树。

观察n=3时的五棵树：
在这里插入图片描述
当1为树根时，右子树有两个节点，布局和n=2时两棵树的布局一致；
当3为树根时，左子树有两个节点，布局也和n=2时两棵树的布局一致；
当2为树根时，其左右子树都只有一个节点，布局和n=1时一棵树的布局一致。

所以dp[3]=元素1为根的搜索树数量dp[1]+元素2为根的搜索树数量dp[2]+元素3为根的搜索树数量dp[3]，
而dp[1]=右子树有2个元素的搜索树数量 $*$ 左子树有0个元素的搜索树数量，
dp[2]=右子树有1个元素的搜索树数量 $*$ 左子树有1个元素的搜索树数量，
dp[3]=右子树有0个元素的搜索树数量 $*$ 左子树有2个元素的搜索树，
即dp[3]=dp[2]*dp[0]+dp[1]*dp[1]+dp[0]*dp[2]。

如图所示，
在这里插入图片描述

动态规划五部曲

状态定义：dp[i] 表示1~i 节点组成的二叉搜索树的个数。
递推公式：由思路中看出，dp[i]+=dp[以 j 为根左子树节点数量]*dp[以 j 为根右子树节点数量]，j 从1到 i
所以dp[i]+=dp[j-1] * dp[i-j]。
（j-1作为左子树，i-j作为右子树是由二叉搜索树的定义决定的）
初始条件：dp[0]=1，因为从定义上来说，空节点也是一棵二叉搜索树。
遍历顺序：观察递推公式，dp[i]依靠dp[j-1]和dp[i-j]，所以一定是从前往后遍历。
举例：n=5时，

本题代码如下：

class Solution {
   
   
    public int numTrees(int n) {
   
   
        int[] dp=new int[n+1];
        dp[0]=1;//空节点也是一棵二叉搜索树
        for(int i=1;i<=n;i++){
   
   
            for(int j=1;j<=i;j++){
   
   
                dp[i]+=dp[j-1]*dp[i-j];
            }
        }
        return dp[n];
    }
}

时间复杂度： $O(n^2)$
空间复杂度： $O (n)$

01背包问题

理论基础

区分01背包、完全背包和多重背包：
在这里插入图片描述
重中之重是01背包，多重背包力扣上甚至没有相应的题目。

01背包

有n件物品和一个最多能背重量为 w 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

二维dp数组-01背包

状态定义：dp[i][j] 表示从下标为[0-i]的物品里任意取，重量是 j 时背包内最大价值总和。
递推公式：
（1）不放物品 i ：dp[i][j]=dp[i-1][j]，不放物品i，背包价值依然和前面相同；
（2）放物品 i ：dp[i][j]=dp[i-1][ j-weight[i] ]+value[i]，背包容量为j - weight[i]时，不放物品i的最大价值为dp[i - 1][j - weight[i]] ，所以放入物品i以后价值增加value[i]；
所以dp[i][j]=max(dp[i-1][j], dp[i-1][j-weight[i]] + value[i])。
初始条件：观察递推公式，dp[0][j]是一定要初始化的，否则后面的状态无法推出，
（1）背包容量j=0：无论取哪些物品，背包价值总和一定为0，因此dp[i][0]=0；
（2）物品最大下标i=0：只能取0号物品，
如果 j<weight[i]，背包装不下0号物品，价值为0；
如果 j>=weight[i]，背包只能装0号物品，价值等于0号物品的价值；
遍历顺序：先遍历物品再遍历背包，或者先遍历背包再遍历物品都可以。
根据递推公式，dp[i-1][j]和dp[i - 1][j - weight[i]] 都在dp[i][j]的左上角方向（包括正上方向），那么先遍历物品再遍历背包过程如下所示：

for(int i=1;i<weight.length;i++){
   
   //遍历物品
   for(int j=0;j<=bagweight;j++){
   
   //遍历背包重量
        if(j<weight[i])
            dp[i][j]=dp[i-1][j];
        else
            dp[i][j]=Math.max(dp[i-1][j],dp[i-1][j-weight[i]+value[i]]);
    }
}

而先遍历背包再遍历物品的过程如下所示：
在这里插入图片描述

for(int j=0;j<=bagweight;j++){
   
   //遍历背包重量
    for(int i=1;i<weight.length;i++){
   
   //遍历物品
        if(j<weight[i])
            dp[i][j]=dp[i-1][j];
        else
            dp[i][j]=Math.max(dp[i-1][j],dp[i-1][j-weight[i]+value[i]]);
    }
}

不管哪种方式，更新dp[i][j]需要的就是左上角，两种方式均不影响dp[i][j]的推导。

举例：背包最大重量为4，

则推出dp的数值如下，

最终结果就是dp[2][4]。

一维dp数组-01背包

观察上述递推公式，dp[i][j]=max(dp[i-1][j], dp[i-1][j-weight[i]] + value[i])，发现第 i 行的状态只与第 i-1 行的状态有关，所以可以用滚动数组优化01背包的空间。

状态定义：dp[j] 表示容量为 j 的背包所背的最大价值。
递推公式：dp[j]=max(dp[j], dp[j-weight[i]] + value[i])
初始条件：dp[0]=0，背包装不了东西的时候价值自然是0.
遍历顺序：
注意这里背包重量一定是倒序遍历，否则当前状态会与之前取得状态重合！
除此之外，**两个for循环的顺序也不能颠倒！**因为根据一维dp的写法，背包容量一定是要倒序遍历的，而如果容量放在上一层，那么每个dp[j]就只会放入一个物品，即背包里只放入了一个物品。

for(int i=0;i<weight.length;i++){
   
   //遍历物品
    for(int j=bagweight;j>=weight[i];j--){
   
   //遍历背包重量(反向)
        dp[i][j]=Math.max(dp[i-1][j],dp[i-1][j-weight[i]+value[i]]);
    }
}

举例：背包最大重量为4，

完整代码如下：

class Solution {
   
   
    public boolean bagpack(int[] nums) {
   
   
        int[] dp=new int[bagweight+1];
        for(int i=0;i<weight.length;i++){
   
   //遍历物品
            for(int j=bagweight;j>=weight[i];j--){
   
   //遍历背包重量(反向)
                dp[j]=Math.max(dp[j],dp[j-weight[i]+value[i]]);
            }
        }
        return dp[bagweight];
    }
}

一维数组的01背包代码更加简洁，空间复杂度还比二维dp数组下降了一个数量级。

quiz

对于纯二维01背包，先实现，然后提问：

为什么两个for循环的嵌套这么写？反过来写行不行？为什么？

对于一维数组的01背包，实现，然后提问：

两个for循环的顺序反过来写行不行？为什么？

1. 分割等和子集

416. 分割等和子集
给你一个 只包含正整数 的非空数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

思路

首先，本题要求集合中能否出现总和为sum/2的子集；其次，数组中元素只能用一次，不可重复使用，因此考虑01背包而不是完全背包；接着，将题目中给定条件与01背包一一对应。

背包体积为sum/2
背包物品->集合元素，物品重量->元素数值，物品价值->元素数值
背包正好装满，说明找到了总和为sum/2的子集
每一个元素不可重复放入

动态规划五部曲

状态定义：dp[j] 表示背包容量是 j 时，所背的最大重量。
本题每一个元素的数值既是重量，也是价值。当dp[target]==target时，说明背包装满了。
那什么时候装不满呢？以[1,5,11,5]举例，dp[7]只能等于6，即装不满；而dp[6]就可以等于6，则说明装满了。
递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])，同01背包。
初始条件：dp[0]=0，背包重量为0时，说明没装东西，价值必然是0。
遍历顺序：同01背包问题，

for(int i=0;i<n;i++){
   
   
    for(int j=target;j>=nums[i];j--){
   
   
        dp[j]=Math.max(dp[j],dp[j-nums[i]]+nums[i]);
    }
}

举例：
dp[j]的值一定是小于等于 j 的。
如果dp[j]==j，说明集合中的子集总和正好可以凑成总和 j 。
以输入[1,5,11,5] 为例，如图，

最后dp[11]==11，说明可以将这个数组分割成两个子集，使得两个子集的元素和相等。

完整代码如下：

class Solution {
   
   
    public boolean canPartition(int[] nums) {
   
   
        int n=nums.length,sum=0;
        for(int num:nums)
            sum+=num;
        if(n<2||sum%2==1)
            return false;
        int target=sum/2;
        int[] dp=new int[target+1];
        for(int i=0;i<n;i++){
   
   
            for(int j=target;j>=nums[i];j--){
   
   
                dp[j]=Math.max(dp[j],dp[j-nums[i]]+nums[i]);
            }
        }
        return dp[target]==target?true:false;
    }
}

时间复杂度： $O(n^2)$
空间复杂度： $O (n)$

2. 最后一块石头的重量 II

1049. 最后一块石头的重量 II【中等】
有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为
y-x。

最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。

思路

本题其实就是尽量让石头分成重量相同的两堆，相撞之后剩下的石头最小，和前一道416. 分割等和子集非常像，化解为01背包问题。

石头的重量stones[i]对应01背包中物品的重量weight[i]和物品价值value[i]。

动态规划五部曲

状态定义：dp[j] 表示背包容量是 j 时，所背的最大重量。
递推公式：dp[j] = max(dp[j], dp[j - stones[i]] + stones[i])，同01背包。
初始条件：dp[i]=0，背包重量为0时，说明没装东西，价值必然是0。
遍历顺序：同01背包问题，

for(int i=0;i<n;i++){
   
   
    for(int j=target;j>=stones[i];j--){
   
   
        dp[j]=Math.max(dp[j],dp[j-stones[i]]+stones[i]);
    }
}

举例：输入[2

最低0.47元/天解锁文章

200万优质内容无限畅学