【LeetCode】动态规划系列总结

zxfhahaha

已于 2024-04-01 16:37:36 修改

阅读量399

点赞数 1

分类专栏： LeetCode 文章标签： dp 动态规划

于 2021-06-01 00:57:32 首次发布

本文链接：https://blog.csdn.net/zxfhahaha/article/details/117431958

版权

动态规划系列总结

用到dp的题目类型
解题套路
- 983. 最低票价
背包问题
最长子序列
最大子数组
- 53. 最大子数组和
股票买卖问题
区间问题

参考： labuladong的算法小抄

用到dp的题目类型

动态规划问题的一般形式都是求子序列、从m长的数组中选出n个数

解题套路

动态规划三要素：

重叠子问题
最优子结构
状态转移方程

核心思想就是穷举所有可行解求最值—>列出正确的「状态转移方程」

得到状态转移方程：找状态转移方程的方法是，思考每个状态有哪些「选择」，只要我们能用正确的逻辑做出正确的选择，算法就能够正确运行。
状态转移方程其实就代表着暴力解，然后用DP table 优化

明确 base case
明确「状态」
原问题和子问题中会变化的变量
明确「选择」
导致状态变化的行为
定义 dp 数组/函数的含义
函数的返回值即题目要求我们计算的量，函数的参数为状态转移中会变化的量即状态
遍历顺序
有些状态压缩后，就需要反着遍历，这样不会影响前面的值
对于有些二维的，可以把dp table画出来找到适合的遍历顺序

一句话总结就是遍历所有的状态，从所有选择中找到最值

# 初始化 base case
dp[0][0][...] = base
# 进行状态转移:遍历所有状态的取值
for 状态1 in 状态1的所有取值：
    for 状态2 in 状态2的所有取值：
        for ...
            dp[状态1][状态2][...] = 求最值(选择1，选择2...)

983. 最低票价

在一个火车旅行很受欢迎的国度，你提前一年计划了一些火车旅行。在接下来的一年里，你要旅行的日子将以一个名为 days 的数组给出。每一项是一个从 1 到 365 的整数。

火车票有三种不同的销售方式：

一张为期一天的通行证售价为 costs[0] 美元；
一张为期七天的通行证售价为 costs[1] 美元；
一张为期三十天的通行证售价为 costs[2] 美元。
通行证允许数天无限制的旅行。例如，如果我们在第 2 天获得一张为期 7 天的通行证，那么我们可以连着旅行 7 天：第 2 天、第 3 天、第 4 天、第 5 天、第 6 天、第 7 天和第 8 天。

返回你想要完成在给定的列表 days 中列出的每一天的旅行所需要的最低消费。

示例 1：

输入：days = [1,4,6,7,8,20], costs = [2,7,15]
输出：11
解释：
例如，这里有一种购买通行证的方法，可以让你完成你的旅行计划：
在第 1 天，你花了 costs[0] = $2 买了一张为期 1 天的通行证，它将在第 1 天生效。
在第 3 天，你花了 costs[1] = $7 买了一张为期 7 天的通行证，它将在第 3, 4, …, 9 天生效。
在第 20 天，你花了 costs[0] = $2 买了一张为期 1 天的通行证，它将在第 20 天生效。
你总共花了 $11，并完成了你计划的每一天旅行。
示例 2：

输入：days = [1,2,3,4,5,6,7,8,9,10,30,31], costs = [2,7,15]
输出：17
解释：
例如，这里有一种购买通行证的方法，可以让你完成你的旅行计划：
在第 1 天，你花了 costs[2] = $15 买了一张为期 30 天的通行证，它将在第 1, 2, …, 30 天生效。
在第 31 天，你花了 costs[0] = $2 买了一张为期 1 天的通行证，它将在第 31 天生效。
你总共花了 $17，并完成了你计划的每一天旅行。

提示：

1 <= days.length <= 365
1 <= days[i] <= 365
days 按顺序严格递增
costs.length == 3
1 <= costs[i] <= 1000

思路：

今天买多少要看后几天安排，所以是前面依赖后面，要从后往前遍历每一天。
如果当前天不包含在days中说明不用出门，那么它的最小花费就是后一天的；如果包含在days中，则用出门，然后就有三种选择，就得到了状态转移方程：

 dp[d] = min(dp[d+1]+cost[0],    // 只包当天
 			dp[d+7]+cost[1],   // 包后7天的费用
 			dp[d+30]+cost[2])  // 包后30天的费用

选择：
如果不用出门，则不用选择；如果用出门，则选择买1天、7天还是30天的通行证
dp定义
dp[i] 从第i天开始，所需的最小花费

        public int mincostTickets(int[] days, int[] costs) {
   
        int maxDay = days[days.length-1];
        int minDay = days[0];
        // dp[i] 从第i天开始，所需的最小花费
        int[] dp = new int[maxDay+31];
        int i = days.length-1;
        // 遍历每一天
        for(int d = maxDay;d>=minDay;d--){
   
            if(days[i]==d){
   
                // 选择：c[0]+1天后不包 c[1]+7天后不包 c[2]+30天后不包
                dp[d] = Math.min(costs[0]+dp[d+1],costs[1]+dp[d+7]);
                dp[d] = Math.min(dp[d],costs[2]+dp[d+30]);
                i--;

            }else{
   
                // 不在days中表示不需要出门
                dp[d] = dp[d+1];
            }
        }
        return dp[minDay];
    }

背包问题

常见背包问题

常见背包问题可分为：

01 背包问题：
- 最基本的背包问题就是 01 背包问题：一共有 N 件物品，第 i（i 从 1 开始）件物品的重量为 w[i]，价值为 v[i]。在总重量不超过背包承载上限 W 的情况下，能够装入背包的最大价值是多少？
- 本质上是：从数组中选m个数，使其满足target
- dp[i][j]: 表示从nums[0…i]中选m个数（m<=i）使其和为j的方案数或者是否能使其和为j
- 优化成一维：dp[j] 表示使得和为j的方案数或是否能使其和为j，因为i只和前一个相关，所以就去掉了，但是需要外循环遍历 arrs，内循环遍历 target，且内循环倒序
  方案数模板：
```
    // 目标为i的表达式数目是dp[i]种
	int[] dp = new int[target+1];
	// base case 
    dp[0] = 1;
    for (int num : nums) {
       
        for (int j = t;j>=num;j--){
       
            dp[j] = dp[j] + dp[j-num];
        }
    }
```
完全背包问题：
完全背包与 01 背包不同就是每种物品可以有无限多个：一共有 N 种物品，每种物品有无限多个，第 i（i 从 1 开始）种物品的重量为 w[i]，价值为 v[i]。在总重量不超过背包承载上限 W 的情况下，能够装入背包的最大价值是多少？
可见 01 背包问题与完全背包问题主要区别就是物品是否可以重复选取。

背包问题具备的特征：
是否可以根据一个 target（直接给出或间接求出），target 可以是数字也可以是字符串，再给定一个数组 arrs，问：能否使用 arrs 中的元素做各种排列组合得到 target。

背包问题解法：

01 背包问题：
如果是 01 背包，即数组中的元素不可重复使用，外循环遍历 arrs，内循环遍历 target，且内循环倒序（因为物品只能用一次，从二维压缩到一维后不能让之前的结果影响后来的结果所以要倒序）:

完全背包问题：
（1）如果是完全背包，即数组中的元素可重复使用并且不考虑元素之间顺序，arrs 放在外循环（保证 arrs 按顺序），target在内循环。且内循环正序。（因为可以用多次，所以不用倒序）
（2）如果组合问题需考虑元素之间的顺序，需将 target 放在外循环，将 arrs 放在内循环，且内循环正序。

01 背包问题

要点就是数组中的元素不可重复，这样我们就找到我们的target即套公式：
外循环遍历 arrs，内循环遍历 target，且内循环倒序

解法由来

这个套路是怎么得到的呢，下面是解析：
01背包问题由二维到一维的过程：

首先对于01背包问题：
给你一个可装载重量为 W 的背包和 N 个物品，每个物品有重量和价值两个属性。其中第 i 个物品的重量为 wt[i]，价值为 val[i]，现在让你用这个背包装物品，最多能装的价值是多少？

状态：
背包的容量和可选择的物品
选择
是否装进背包
dp的定义
dp[i][j] =x 表示对于前i个物品，背包容量为j时，若x为true 说明恰好能把背包装满；若x为false，说明不能恰好把背包装满
状态转移方程
对于选择不把当前物品装进背包，则是否能把背包装满取决于前一个状态
dp[i][j] = dp[i-1][j]
对于选择把当前物品装进背包，则
dp[i][j] = dp[i-1][j-nums[i-1]]
由于 i 是从 1 开始的，而数组索引是从 0 开始的，所以第 i 个物品的重量应该是 nums[i-1]，这一点不要搞混。

这样就可以写出伪代码

    for (int i = 1; i <= n; i++) {
   
        for (int j = 1; j <= sum; j++) {
   
            if (j - nums[i - 1] < 0) {
   
               // 背包容量不足，不能装入第 i 个物品
                dp[i][j] = dp[i - 1][j]; 
            } else {
   
                // 装入或不装入背包
                dp[i][j] = dp[i - 1][j] || dp[i - 1][j-nums[i-1]];
            }
        }
    }

注意到 dp[i][j] 都是通过上一行 dp[i-1][…] 转移过来的，之前的数据都不会再使用了。
所以，我们可以进行状态压缩，将二维 dp 数组压缩为一维。

压缩后的代码：
这就是我们上面总结的套路：arrs在外层，target在里层，且里层要倒序。
因为每个物品（或者说数字）只能用一次，以免之前的结果影响其他的结果。

    for (int i = 0; i < n; i++) 
        for (int j = sum; j >= 0; j--) 
            if (j - nums[i] >= 0) 
                dp[j] = dp[j] || dp[j - nums[i]];

时间复杂度 O(n*sum)，空间复杂度 O(sum)。

416. 分割等和子集

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

示例 1：
输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。

示例 2：
输入：nums = [1,2,3,5]
输出：false
解释：数组不能分割成两个元素和相等的子集。

提示：
1 <= nums.length <= 200
1 <= nums[i] <= 100

思路：

找到是哪种背包问题
nums 是我们的选择，这个选择是不可重复的，所以是0-1背包问题。
由于是两个和相等的子集，所以相当于是求一个子集的和为sum/2。
外层循环为选择池 num: nums，内层循环为 target。
dp定义
dp[i] 表示是否存在和为 i 的 num 组合。
状态转移方程
对于元素之和等于 i - num 的每一种组合，在最后添加 num 之后即可得到一个元素之和等于 i 的组合，因此dp[i] 依赖于 dp[i - num]，并且在计算 dp[i - num] 时，要保证索引较小的元素值不被覆盖，需要后向更新 dp[i]，并且当 i - num < i 时， dp[i] 已经更新过，于是：
dp[i] = dp[i] || dp[i - num]

    public boolean canPartition(int[] nums) {
   

        int sum = 0;
        for (int num : nums) {
   
            sum+=num;
        }
        // 是奇数肯定不符合
        if((sum&1)==1){
   
            return false;
        }
        int target = sum/2;
        // dp[i] 是否存在和为i的num组合
        boolean[] dp = new boolean[target+1];
       // Arrays.fill(dp,false);
        dp[0] = true;
        for(int num:nums){
   
            for (int i = target; i >= num; i--) {
   
				// 不装入背包或装入
                dp[i] = dp[i] || dp[i-num];

            }

        }
        return dp[target];
    }

494. 目标和

给你一个整数数组 nums 和一个整数 target 。
向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个表达式：
例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1” 。
返回可以通过上述方法构造的、运算结果等于 target 的不同表达式的数目。

示例 1：
输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3
示例 2：
输入：nums = [1], target = 1
输出：1

提示：
1 <= nums.length <= 20
0 <= nums[i] <= 1000
0 <= sum(nums[i]) <= 1000
-1000 <= target <= 100

问题转化：
加正负符号得到最终的目标和，相当于我们把加+的集合在一起就是正数和x，把加-的集合在一起就是负数和y。而正数和x就是我们背包问题的目标和。
x-y = target
我们一直x+y = nums的和 sum
因此x=(target+sum)/2.
也就是从nums里选出几个数，使其和为x，这就转换成了0-1背包问题

dp[i] 表示和为 i 的 num 组合有 dp[i] 种

    public int findTargetSumWays(int[] nums, int target) {
   
        int sum = Arrays.stream(nums).sum();
        int x = (sum+target)/2;
        if(target > sum || (target + sum) % 2 == 1) return 0;
        // dp[i] 目标为i 的表达式组合数
        int[] dp = new int[x+1];
        // base case
        dp[0] = 1;
        // 选择 num
        for(int num:nums){
   
            for (int i = x; i >=num; i--) {
   
                dp[i] = dp[i] + dp[i-num];
            }
        }
        return dp[x];
    }

1049 最后一块石头的重量 II

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。
每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：
如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。

示例 1：
输入：stones = [2,7,4,1,8,1]
输出：1
解释：
组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]，
组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]，
组合 2 和 1，得到 1，所以数组转化为 [1,1,1]，
组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。
示例 2：

输入：stones = [31,26,33,21,40]
输出：5
示例 3：

输入：stones = [1,2]
输出：1
提示：
1 <= stones.length <= 30
1 <= stones[i] <= 100

思路：
每次选两个石头，再把减后的值放到石头堆其实就是把stones分成正号堆和负号堆，将减之后的结果放回石头堆其实就是给(x-y) 加正号还是负号
如果是+(x-y)，那其实就是x和y还是在原来的堆，不变；
如果是-(x-y)，那就是x和y交换一下位置
因此可以转换为：为 stones 中的每个数字添加 +/-，使得形成的「计算表达式」结果绝对值最小。

那么这个问题就可以转换成0-1背包问题，类似于目标和

这就将问题彻底切换为 01 背包问题：从 stones 数组中选择，凑成总和不超过 sum/2
的最大价值。
其中「成本」&「价值」均为数值本身。

dp定义
定义 dp[i] 代表考虑前 i 个物品（数值），凑成总和不超过 i 的最大价值。
状态转移
不选和选取最大价值
dp[i] = max(dp[i], dp[i-stone]+stone)

class Solution {
   
    public int lastStoneWeightII(int[] stones) {
   
        int sum = Arrays.stream(stones).sum();
        int target = sum/2;
        // dp[i] 考虑前 i 个物品（数值），凑成总和不超过 i 的最大价值。
        int[] dp = new int[target+1];

        for (int stone : stones) {
   
            for (int i = target; i >=stone; i--) {
   
                // 选 和 不选 取最大值
            
                dp[i] = Math.max(dp[i],dp[i-stone]+stone);
            }
        }
        return Math.abs(sum - dp[target] - dp[target]);
    }
}

879. 盈利计划

879. 盈利计划
集团里有 n 名员工，他们可以完成各种各样的工作创造利润。
第 i 种工作会产生 profit[i] 的利润，它要求 group[i] 名成员共同参与。如果成员参与了其中一项工作，就不能参与另一项工作。
工作的任何至少产生 minProfit 利润的子集称为盈利计划。并且工作的成员总数最多为 n 。
有多少种计划可以选择？因为答案很大，所以返回结果模 10^9 + 7 的值。

示例 1：
输入：n = 5, minProfit = 3, group = [2,2], profit = [2,3]
输出：2
解释：至少产生 3 的利润，该集团可以完成工作 0 和工作 1 ，或仅完成工作 1 。
总的来说，有两种计划。
示例 2：
输入：n = 10, minProfit = 5, group = [2,3,5], profit = [6,7,8]
输出：7
解释：至少产生 5 的利润，只要完成其中一种工作就行，所以该集团可以完成任何工作。
有 7 种可能的计划：(0)，(1)，(2)，(0,1)，(0,2)，(1,2)，以及 (0,1,2) 。
提示：
1 <= n <= 100
0 <= minProfit <= 100
1 <= group.length <= 100
1 <= group[i] <= 100
profit.length == group.length
0 <= profit[i] <= 100

思路：
经典的背包问题是一种限制：容量的限制标准，我们这题有两种限制:员工人数的上限和利润的下限

dp定义
dp[i] [j] [k] 对profit[0,…,i] 选择了j个员工并满足利润至少为k 的盈利计划的总数目
最后返回的结果就是遍历j从0到n的结果和 dp[len][j][minprofit]
转移方程
我们有两种选择，
- 一种是选profit[i]
  选的话必须当前所需的员工数group[i] 必须要小于等于目前可用的员工数j
  这里要注意的是，我们第三维由于是利润至少为k，那么当当前profit[i] 直接满足所需利润k
  那就是一种情况，不需要借助前一个的利润
```
dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-group[i-1]][Math.max(0,k-profit[i-1])]
```
- 一种是不选
  不选那当前的计划数就是i-1的计划数
  dp[i-1][j][k]

class Solution {
   
    public int profitableSchemes(int n, int minProfit, int[] group, int[] profit) {
   
        int pl = profit.length;
        int MOD = (int)1e9+7;
        // dp[i][j][k] 对于profit[0...i] 用j个工人 达到利润至少为k 的计划数目
        int[][][] dp = new int[pl+1][n+1][minProfit+1];
        //base case
        dp[0][0][0] = 1;
        // 石头
        for (int i = 1; i <= pl; i++) {
   
            // 工人
            for (int j = 0; j <= n; j++) {
   
                // 利润
                for (int k = 0; k <=minProfit ; k++) {
   
                    // 当前所需的工人数可以满足要求 可以选择
                    if(j-group[i-1]>=0){
   
                        // 前一个的Profit+ 当前profit = 当前能满足的利润k 那如果前一个profit 小于0，也就是当前的profit直接能满足条件，就可以计划数+1
                        dp[i][j][k] = (dp[i-1][j][k] + dp[i-1][j-group[i-1]][Math.max(0,k-profit[i-1])])% MOD;
                    } else{
   
                        dp[i][j][k] = dp[i-1][j][k];
                    }
                }
            }
        }

        int sum =0;
        for (int j = 0; j <= n; j++) {
   

            sum = (sum+dp[pl][j][minProfit]) % MOD;
        }
        return sum;
    }
}

由于i只和前一个状态有关，我们可以进行状态压缩
状态压缩后：也就是我们的套路
外层遍历选择，内层倒序遍历n及minProfit
倒序的原因保证求dp[j][k]时用到的dp[j-group[i-1]][Math.max(0,k-profit[i-1])]是上一时刻的值，如果正序遍历的话这个值会被改

class Solution {
   
    public int profitableSchemes(int n, int minProfit, int[] group, int[] profit) {
   
        int pl = profit.length;
        int MOD = (int)1e9+7;

        // 用j个工人 达到利润至少为k 的计划数目
        int[][] dp = new int[n+1][minProfit+1];
        //base case
        // 对利润为0时 不管工人有多少，总能提供一种方案
        for (int j = 0; j <= n; j++) {
   
            dp[j][0] = 1;
        }

        // 石头
        for (int i = 1; i <= pl; i++) {
   
            // 工人
            for (int j = n; j >= group[i-1]; j--) {
   
                // 利润
                for (int k = minProfit; k >=0 ; k--) {
   
                    // 当前所需的工人数可以满足要求 可以选择
                    dp[j][k] = (dp[j][k] + dp[j-group[i-1]][Math.max(0,k-profit[i-1])])% MOD;
                }
            }
        }
        return dp[n][minProfit];
    }
}

474. 一和零

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。
请你找出并返回 strs 的最大子集的大小，该子集中最多有 m 个 0 和 n 个 1 。
如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的子集。

示例 1：
输入：strs = [“10”, “0001”, “111001”, “1”, “0”], m = 5, n = 3
输出：4
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {“10”,“0001”,“1”,“0”} ，因此答案是 4 。
其他满足题意但较小的子集包括 {“0001”,“1”} 和 {“10”,“1”,“0”} 。{“111001”} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。
示例 2：

输入：strs = [“10”, “0”, “1”], m = 1, n = 1
输出：2
解释：最大的子集是 {“0”, “1”} ，所以答案是 2 。

提示：

1 <= strs.length <= 600
1 <= strs[i].length <= 100
strs[i] 仅由 ‘0’ 和 ‘1’ 组成
1 <= m, n <= 100

dp定义：
strs[0…i]中j个0 k个1 的最大子集的大小
dp[i][j][k]
最后dp[len][m][n] 就是最大子集的大小
状态转移：
就是选择和不选两种情况

    public int findMaxForm(String[] strs, int m, int n) {
   

        int len = strs.length;
        // dp[i][j][k]：strs[0..i]中j个0 k个1 的最大子集的大小
        int[][][] dp = new int[len+1][m+1][n+1];

        for (int i = 1; i <= len; i++) {
   
            // 零的个数
            int zeros = countZero(strs[i-1]);
            // 1的个数
            int ones = strs[i-1].length()-zeros;
            for (int j = 0; j <= m; j++) {
   
                for (int k = 0; k <= n; k++) {
   
                    // 选strs[i-1]
                    if(j>=zeros && k>=ones){
   
                        dp[i][j][k] = Math.max(dp[i-1][j][k

最低0.47元/天解锁文章

zxfhahaha

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
1
评论
【LeetCode】动态规划系列总结

动态规划系列总结用到dp的题目类型解题套路322. 零钱兑换参考：labuladong的算法小抄用到dp的题目类型动态规划问题的一般形式都是求最值解题套路动态规划三要素：重叠子问题最优子结构状态转移方程核心思想就是穷举所有可行解求最值—>列出正确的「状态转移方程」得到状态转移方程：状态转移方程其实就代表着暴力解，然后用DP table 优化明确 base case明确「状态」原问题和子问题中会变化的变量明确「选择」导致状态变化的行为定义 dp 数组/函数的含义
复制链接

扫一扫