代码随想录Day 35|动态规划，二维dp数组，滚动数组，leetcode题目：416.分割等和子集

最新推荐文章于 2024-11-10 14:06:08 发布
最新推荐文章于 2024-11-10 14:06:08 发布
阅读量862 收藏 27
点赞数 11
文章标签： 动态规划 leetcode 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LuckyYH__/article/details/141907268
版权

提示：DDU，供自己复习使用。欢迎大家前来讨论~

文章目录

动态规划Part03

动态规划

一、 动态规划：01背包理论基础

对于面试的话，其实==掌握01背包和完全背包==，就够用了，最多可以再来一个多重背包。

背包问题的理论基础重中之重是01背包，一定要理解透！

多种背包的问题，如下：

416.分割等和子集1

01 背包

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

直接的思路：暴力解决

每一件物品其实只有两个状态，取或者不取，所以可以使用回溯法搜索出所有的情况，那么时间复杂度就是O(2^n)，这里的n表示物品数量。

所以暴力的解法是指数级别的时间复杂度。进而才需要动态规划的解法来进行优化！

下面通过举例进行讲解：

背包最大重量为4。

物品为：

image-20240904232059176

问背包能背的物品最大价值是多少？

二维dp数组01背包

  1. 理解问题与子问题的关系：
    • 背包问题涉及将多个物品放入容量有限的背包中，以最大化背包内物品的总价值。
  2. 分解问题：
    • 将问题分解为在已知前m-1个物品的最优解的基础上，考虑加入第m个物品的情况。
  3. 分析可能的情况：
    • 情况1：第m个物品的重量超过背包容量n，无法放入，最优解与m-1个物品时相同。
    • 情况2：第m个物品可以放入但选择不放，最优解与m-1个物品时相同。
    • 情况3：第m个物品可以放入并且放入，此时最优解是第m个物品的价值加上剩余容量（n-第m个物品的重量）的最优解。

动规五部曲：

  1. 确定dp数组以及下标的含义

一个二维数组，两个维度需要分别表示：物品 和 背包容量

如图，二维数组为 dp[i][j]。

动态规划-背包问题1

那么这里 i 、j、dp[i][j] 分别表示什么呢？ i 来表示物品、j表示背包容量。

动态规划的思路是根据子问题的求解推导出整体的最优解。

  1. 递推关系

整体的过程可以抽象为：

  • 不放物品i：背包容量为j，里面不放物品i的最大价值是d[i - 1][j]。
  • 放物品i：背包空出物品i的容量后，背包容量为j - weight[i]，dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]且不放物品i的最大价值，那么dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值

递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

  1. dp数组如何初始化

关于初始化，一定要和dp数组的定义吻合，否则到递推公式的时候就会越来越乱。

首先从dp[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0。如图：

动态规划-背包问题2

在看其他情况:

状态转移方程 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 可以看出i 是由 i-1 推导出来，那么i为0的时候就一定要初始化。

dp[0][j]，即：i为0，存放编号0的物品的时候，各个容量的背包所能存放的最大价值。

那么很明显当 j < weight[0]的时候，dp[0][j] 应该是 0，因为背包容量比编号0的物品重量还小。

当j >= weight[0]时，dp[0][j] 应该是value[0]，因为背包容量放足够放编号0物品。

代码初始化如下：

for (int j = 0 ; j < weight[0]; j++) {  // 当然这一步，如果把dp数组预先初始化为0了，这一步就可以省略，但很多同学应该没有想清楚这一点。
    dp[0][j] = 0;
}
// 正序遍历
for (int j = weight[0]; j <= bagweight; j++) {
    dp[0][j] = value[0];
}

此时dp数组初始化情况如图所示：

动态规划-背包问题7

dp[0][j] 和 dp[i][0] 都已经初始化了，那么其他下标应该初始化多少呢？

初始-1，初始-2，初始100，都可以！

但只不过一开始就统一把dp数组统一初始为0，更方便一些。

如图：

动态规划-背包问题10

最后初始化代码如下：

// 初始化 dp
vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));
for (int j = weight[0]; j <= bagweight; j++) {
    dp[0][j] = value[0];
}
  1. 确定遍历顺序

在如下图中，可以看出，有两个遍历的维度：物品与背包重量

动态规划-背包问题3

那么问题来了，先遍历 物品还是先遍历背包重量呢？

其实都可以！！ 但是先遍历物品更好理解。

那么我先给出先遍历物品，然后遍历背包重量的代码。

// weight数组的大小 就是物品个数
for(int i = 1; i < weight.size(); i++) { // 遍历物品
    for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
        if (j < weight[i]) dp[i][j] = dp[i - 1][j];
        else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

    }
}

先遍历背包，再遍历物品，也是可以的！（注意我这里使用的二维dp数组）

例如这样：

// weight数组的大小 就是物品个数
for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
    for(int i = 1; i < weight.size(); i++) { // 遍历物品
        if (j < weight[i]) dp[i][j] = dp[i - 1][j];
        else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
    }
}

为什么也是可以的呢？

要理解递归的本质和递推的方向。

dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 递归公式中可以看出dp[i][j]是靠dp[i-1][j]和dp[i - 1][j - weight[i]]推导出来的。

dp[i-1][j]和dp[i - 1][j - weight[i]] 都在dp[i][j]的左上角方向（包括正上方向），那么先遍历物品，再遍历背包的过程如图所示：

动态规划-背包问题5

再来看看先遍历背包，再遍历物品呢，如图：

动态规划-背包问题6

大家可以看出，虽然两个for循环遍历的次序不同，但是dp[i][j]所需要的数据就是左上角，根本不影响dp[i][j]公式的推导！

但先遍历物品再遍历背包这个顺序更好理解。

其实背包问题里，两个for循环的先后循序是非常有讲究的，理解遍历顺序其实比理解推导公式难多了。

  1. 举例推导dp数组

来看一下对应的dp数组的数值，如图：

动态规划-背包问题4

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

做动态规划的题目，最好的过程就是自己在纸上举一个例子把对应的dp数组的数值推导一下，然后在动手写代码！

二、动态规划：01背包理论基础（滚动数组）

思路

把二维dp降为一维dp。

一维dp数组（滚动数组）

  1. 二维数组的含义：
    • dp[i][j] 表示将前i个物品放入容量为j的背包中能获得的最大价值。
  2. 更新条件：
    • 不放入物品i：dp[i][j] = dp[i-1][j]，适用于背包容量小于物品体积或不放入物品i更优的情况。
    • 放入物品i：dp[i][j] = dp[i-1][j-weight[i]] + value[i]，前提是背包容量足够。
  3. 状态压缩的可能性：
    • 观察到dp[i][j]的更新仅依赖于上一层dp[i-1]的状态，因此可以优化空间复杂度。
  4. 滚动数组的优化：
    • 可以仅使用两行数组交替更新，每次根据当前行更新下一行，然后交换行。
    • 进一步观察发现，更新dp[i][j]仅依赖于dp[i-1][j]和dp[i-1][j-weight[i]]，与右侧数据无关。
    • 通过从右向左遍历，确保左边的数据是上一行未更新的数据，从而实现一维数组的滚动更新。
  5. 最终实现：
    • 通过上述方法，可以将二维数组压缩到一维数组，有效减少空间复杂度，同时保持算法的正确性和效率。

动规五部曲分析如下：

  1. 确定dp数组的定义

    在一维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。

  2. 一维dp数组的递推公式

    二维dp数组的递推公式为： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

    一维dp数组，其实就上上一层 dp[i-1] 这一层 拷贝的 dp[i]来。

    所以在 上面递推公式的基础上，去掉i这个维度就好。

    递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

  3. 一维dp数组如何初始化

    • 对于背包问题，如果所有物品的价值都是正数，那么将dp数组的所有下标（除了 dp[0]）初始化为0是合理的。
    • 这种初始化策略与dp数组的定义相吻合，并且支持递推公式的正确执行，确保了算法能够找到最优解。

  4. 一维dp数组遍历顺序

    for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

    }
}

    发现和二维dp的写法中，遍历背包的顺序是不一样的！

    倒序遍历是为了保证物品i只被放入一次！,不会将左上的数据覆盖掉，因为要使用到。

    一维dp数组的背包在遍历顺序上和二维其实是有很大差异的

  5. 举例推导dp数组

    一维dp，分别用物品0，物品1，物品2 来遍历背包，最终得到结果如下：

    动态规划-背包问题9

    使用一维dp数组的写法，比较直观简洁

    46. 携带研究材料（第六期模拟笔试） (kamacoder.com)

    // 一维dp数组实现
#include <iostream>
#include <vector>
using namespace std;

int main() {
    // 读取 M 和 N
    int M, N;
    cin >> M >> N;

    vector<int> costs(M);
    vector<int> values(M);

    for (int i = 0; i < M; i++) {
        cin >> costs[i];
    }
    for (int j = 0; j < M; j++) {
        cin >> values[j];
    }

    // 创建一个动态规划数组dp，初始值为0
    vector<int> dp(N + 1, 0);

    // 外层循环遍历每个类型的研究材料
    for (int i = 0; i < M; ++i) {
        // 内层循环从 N 空间逐渐减少到当前研究材料所占空间
        for (int j = N; j >= costs[i]; --j) {
            // 考虑当前研究材料选择和不选择的情况，选择最大值
            dp[j] = max(dp[j], dp[j - costs[i]] + values[i]);
        }
    }

    // 输出dp[N]，即在给定 N 行李空间可以携带的研究材料最大价值
    cout << dp[N] << endl;

    return 0;
}

三、题目

题目一：416. 分割等和子集

416. 分割等和子集

解题思路：

这道题目是要找是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

那么只要找到集合里能够出现 sum / 2 的子集总和，就算是可以分割成两个相同元素和子集了。

本题是可以用回溯暴力搜索出所有答案的，但最后超时了，也不想再优化了，放弃回溯，直接上01背包吧。

  • 对于这类数组分割问题，虽然可以尝试使用回溯法，但考虑到效率和时间复杂度，01背包算法通常是更优的选择。
  • 01背包算法能够有效地解决是否可以将数组分割成两个元素和相等的子集的问题，且在时间和空间复杂度上更加高效。

01背包问题

背包问题涉及将一组物品放入容量有限的背包中，以最大化背包内物品的总价值。

背包类型：

  • 01背包：每件物品只能使用一次。
  • 完全背包：每件物品可以无限使用。
  • 多重背包：每件物品可以使用有限次数。
  • 分组背包：物品分组，每组内物品只能选择一个。
  • 混合背包：结合了以上几种类型的元素。

题目要求判断是否可以将数组分成两个子集，使得这两个子集的元素和相等。

根据题目描述，每件物品只能使用一次，因此本题应使用01背包问题的方法来解决。

将问题转化为01背包问题，即寻找一个子集，其元素和等于整个数组元素和的一半。

只有确定了如下四点，才能把01背包问题套到本题上来。

  • 背包的体积为sum / 2
  • 背包要放入的商品（集合里的元素）重量为 元素的数值，价值也为元素的数值
  • 背包如果正好装满，说明找到了总和为 sum / 2 的子集。
  • 背包中每一个元素是不可重复放入。

以上分析完，就可以套用01背包，来解决这个问题了。

动规五部曲分析如下：

  1. 确定dp数组以及下标的含义

在01背包问题中，dp[j] 表示容量为 j 的背包所能装下物品的最大价值。如果每个元素的重量和价值相同，那么 dp[j] 也代表背包容量为 j 时的最大重量。

对于给定的背包容量 target：

  • 如果 dp[target] == target，则表示背包完全装满。
  • 如果 dp[j] < j，则表示背包未完全装满，例如输入数组 [1, 5, 11, 5] 时，dp[7] 只能等于 6，因为只能放入重量为 1 和 5 的物品。

dp[j] 反映了在不超过背包容量 j 的条件下，能够达到的最大重量或价值。

  1. 确定递推公式

01背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

本题，相当于背包里放入数值，那么物品i的重量是nums[i]，其价值也是nums[i]。

所以递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);

  1. dp数组如何初始化

在01背包，一维dp如何初始化，

从dp[j]的定义来看，首先dp[0]一定是0。

如果题目给的价值都是正整数那么非0下标都初始化为0就可以了，如果题目给的价值有负数，那么非0下标就要初始化为负无穷。

这样才能让dp数组在递推的过程中取得最大的价值，而不是被初始值覆盖了。

本题题目中 只包含正整数的非空数组，所以非0下标的元素初始化为0就可以了。

代码如下：

// 题目中说：每个数组中的元素不会超过 100，数组的大小不会超过 200
// 总和不会大于20000，背包最大只需要其中一半，所以10001大小就可以了
vector<int> dp(10001, 0);
  1. 确定遍历顺序

如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！

解释：

​ 这样做的原因是为了确保在更新 dp[j] 时，dp[j - weight[i]]（即考虑放入当前物品后的背包容量）的值是还未被当前物品影响的原始值。这样做可以避免一个物品在填充背包时被重复计算，确保每个物品只被计算一次。

​ 倒序遍历可以保证每次使用物品的 dp 值都是未被当前迭代影响的。

代码如下：

// 开始 01背包
for(int i = 0; i < nums.size(); i++) {
    for(int j = target; j >= nums[i]; j--) { // 每一个元素一定是不可重复放入，所以从大到小遍历
        dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
    }
}
  1. 举例推导dp数组

dp[j]的数值一定是小于等于j的。

如果dp[j] == j 说明，集合中的子集总和正好可以凑成总和j，理解这一点很重要。

用例1，输入[1,5,11,5] 为例，如图：

416.分割等和子集2

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

综上分析完毕，C++代码如下：

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;

        // dp[i]中的i表示背包内总和
        // 题目中说：每个数组中的元素不会超过 100，数组的大小不会超过 200
        // 总和不会大于20000，背包最大只需要其中一半，所以10001大小就可以了
        vector<int> dp(10001, 0);
        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];
        }
        // 也可以使用库函数一步求和
        // int sum = accumulate(nums.begin(), nums.end(), 0);
        if (sum % 2 == 1) return false;
        int target = sum / 2;

        // 开始 01背包
        for(int i = 0; i < nums.size(); i++) {
            for(int j = target; j >= nums[i]; j--) { // 每一个元素一定是不可重复放入，所以从大到小遍历
                dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
            }
        }
        // 集合中的元素正好可以凑成总和target
        if (dp[target] == target) return true;
        return false;
    }
};
  • 时间复杂度：O(n^2)
  • 空间复杂度：O(n)，虽然dp数组大小为一个常数，但是大常数

总结

  • 选择二维还是一维数组解法取决于问题的结构和状态转移的特性。
  • 二维数组解法在处理多维决策问题时更直观，而一维数组解法在空间优化方面更有效。
  • 在实际应用中，一维数组解法常常通过倒序遍历或其他技巧来避免状态覆盖问题，确保每个状态的最优解被正确计算。
LluckyYH
关注
javascript-leetcode面试题解动态规划问题之第416题分割等和子集-题解.zip
03-16
在本压缩包中，我们关注的是一个与JavaScript编程、LeetCode面试及动态规划相关的知识点——第416题“分割等和子集”。这是一道经典的算法问题，常见于求职面试，尤其是对于寻找前端开发职位的应聘者。下面将详细...
leetcode二维数组-leetcode:我的LeetCode记录
07-07
leetcode二维数组力码 我的 LeetCode 记录 561.阵列分区I（2018.3.15 20:49） 给定一个由 2n 个整数组成的数组，您的任务是将这些整数分组为 n 对整数，比如 (a1, b1), (a2, b2), ..., (an, bn) 这使得 min(ai, bi) ...
leetcode二维数组-Leetcode-:我的算法练习解决方案
07-07
5. **动态规划**：很多二维数组问题可以通过动态规划来解决，比如最短路径、岛屿数量、矩阵中的最长连续递增路径等。 6. **排序与堆**：在二维数组中执行排序操作，或者使用堆（如最小堆和最大堆）来解决与优先级...
leetcode二维数组搜索-LeetCode-Review:重写LeetCode问题
07-01
leetcode二维数组搜索tags: Leetcode [toc] Leetcode list 一、DataStructure Array Linked_list Stack Queue BT BST Set 二、brute search 穷举(DFS) 17.Letter Combinations of a Phone Number backtracking int ...
leetcode二维数组-LeetCode:力码
07-07
leetcode二维数组力码 列表 #605. 可以放置鲜花 #581。 最短的未排序连续子阵列 #566。 重塑矩阵 #624。 数组中的最大距离 #532。 数组中的 K-diff 对 #414。 第三个最大数 细节 #605. 可以放花 问题描述： 假设你有...
【AGC005D】~K Perm Counting（计数抽象成图）
2301_77025310的博客
10-01 2815
注意到位置为id，权值为v ,不合法的情况，当且仅当 v = id+k或 v= id-k。dp(i,j,pd)表示考虑到第i号点， 连了j条边，是否有连接i 到 i-1号点。因此，我们把每一个位置和权值抽象成点 ，不合法的情况之间连一条边，可以构成二分图。由此可知，当选了n条边，就恰好n个位置不合法，限制条件是：连的边不能相邻，求出f(m) ，f(m)指代至少有m个位置不合法的方案数。由此总共有2n 个点 k 条链，链与链之间无边 互不干涉。把二分图展开成k条链，进行dp。简单的乘法原理罢了。
LeetCode 143.重排链表
最新发布
qq_57349657的博客
11-10 101
链表快慢指针 练习题 ： 重排链表
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 363
Leetcode 160. 相交链表
leetcode 3254 长度为 K 的子数组的能量值 I 中等
2401_88085478的博客
11-06 313
【代码】leetcode 3254 长度为 K 的子数组的能量值 I 中等。
LeetCode 876.链表的中间结点
qq_57349657的博客
11-08 252
链表快慢指针 练习题 ： 链表的中间结点
Java | Leetcode Java题解之第551题学生出勤记录I
m0_57195758的博客
11-09 322
Java | Leetcode Java题解之第551题学生出勤记录I
LeetCode 234.回文链表
qq_57349657的博客
11-08 254
链表快慢指针 练习题 ：回文链表
力扣17-电话号码的数字组合
myblog
11-08 462
力扣17-电话号码的字母组合
Python | Leetcode Python题解之第554题砖墙
Mopes__的博客
11-10 142
Python | Leetcode Python题解之第554题砖墙
【d63】【Java】【力扣】141.训练计划III
m0_74814985的博客
11-06 251
使用递归实现出口 ，遇到null每一层要做：把下层放进去，把本层放下去 记录
二分查找习题篇(上)
zoelinkailuo的博客
11-07 930
给定⼀个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。这里，我们把数组的元素分为两部分——小于等于target的部分[left,Bright] and 大于target的部分[Bright+1,right]。这里，我们把数组的元素分为两部分——平方后小于等于x的部分[1,mid] and 平方后大于x的部分[mid-1, x]和一个目标值，在数组中找到目标值，并返回其索引;
LeetCode 560. 和为K的子数组题解
Rockivy的博客
11-08 1051
给定一个整数数组 和一个整数 ，要求返回数组中和为 的连续子数组的个数。子数组是数组中连续的非空元素序列。这是一个经典的前缀和应用场景，同时通过不断优化，我们可以从O(N³)的暴力解法提升到O(N)的哈希表解法。下面，我们分阶段详细讲解不同解法的逐步优化。 时间复杂度：O(N³) 空间复杂度：O(1) 方法二：暴力解法优化 思路 进一步优化暴力解法，将最内层的求和操作提前到第二层，避免重复求和。 固定左边界，右边界扩展过程中累加计算区间和，从而降低一个维度的循环。 实现 时间复杂度：O(N
LeetCode:27. 移除元素
2301_78566776的博客
11-06 294
设置一个指针k，并且遍历数组，当元素不为val时，nums[k]更新，并且k++。这样前k项正好是这个数组中不包含val的全部项。但是注意如果出现当两个值均为val的元素相邻时，后向前覆盖可能会导致漏删。此时在下面代码中的“i--”可规避掉这个问题。主要思路：从前往后遍历数组nums,当遇到值与val相等的元素，元素的顺序可能发生改变。如下例子，9,4前移覆盖掉2。移除所有数值等于 val。
力扣（leetcode）面试经典150题——88. 合并两个有序数组
qq_36748747的博客
11-10 80
给你两个按排列的整数数组nums1和nums2，另有两个整数m和n，分别表示nums1和nums2中的元素数目。请你nums2到nums1中，使合并后的数组同样按排列。最终，合并后数组不应由函数返回，而是存储在数组nums1中。为了应对这种情况，nums1的初始长度为m + n，其中前m个元素表示应合并的元素，后n个元素为0，应忽略。nums2的长度为n。需要合并 [1,2,3] 和 [2,5,6]。合并结果是 [,2,,5,6] ，其中斜体加粗标注的为 nums1 中的元素。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值