代码随想录算法训练营第三十七天|01背包问题、分割等和子集

已于 2024-06-29 16:33:42 修改
阅读量1k 收藏 19
点赞数 36
文章标签： 算法
于 2024-06-28 22:10:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43903745/article/details/140043961
版权

01背包问题

在这里插入图片描述

题目链接：46. 携带研究材料
文档讲解：代码随想录
状态：忘了

二维dp

问题1：为啥会想到i代表第几个物品，j代表容量变化？

动态规划中，每次决策都依赖于前一个状态的结果，在背包问题中每次取物品的操作都必须考虑当前背包容量是否足够。所以使用i代表第几个物品，j代表背包容量限定。而第i个物品取和不取直接影响到最大价值总和dp[i][j]。

因此，dp[i][j]可以表示为，在容量j的条件下，取第i个物品所能得到的最大价值总和。

动态转移方程：

每次状态转移，需要考虑当前背包容量是否足够容纳物品i：

  • 如果当前物品i的重量 weight[i] 大于当前背包的容量j，则显然无法将物品i放入背包，因此 dp[i][j] 应该等于 dp[i-1][j]，即不拿当前物品i时的最优解。
  • 如果当前物品i的重量 weight[i] 小于等于当前背包的容量j，则可以尝试将物品i放入背包（不能保证一定能放下）。此时，考虑两种情况：
    • 不放入物品i，也就是物品i放不下，否则能放下的话肯定是放入物品i后总价值更高！即 dp[i][j]=dp[i-1][j]，和上面的情况一样！
    • 放入物品i，能放下物品i，肯定是放入后价值更高，即dp[i][j] = dp[i-1][j - weight[i]] + value[i]，其中 value[i] 是物品i的价值。

考虑到上述情况，所以递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

二维dp题解：

    public static void testWeightBagProblem(int[] weight, int[] value, int bagSize) {

        // 创建dp数组
        int goods = weight.length;  // 获取物品的数量
        int[][] dp = new int[goods][bagSize + 1];

        // 初始化dp数组
        // 创建数组后，其中默认的值就是0
        // 当背包的容量大于等于第一个物品的重量时，才会将取第一个物品时最大价值设为第一个物品的价值
        for (int j = weight[0]; j <= bagSize; j++) {
            dp[0][j] = value[0];
        }

        // 填充dp数组
        for (int i = 1; i < weight.length; i++) {
            for (int j = 1; j <= bagSize; j++) {
                if (j < weight[i]) {
                    /**
                     * 当前背包的容量都没有当前物品i大的时候，是不放物品i的
                     * 那么前i-1个物品能放下的最大价值就是当前情况的最大价值
                     */
                    dp[i][j] = dp[i - 1][j];
                } else {
                    /**
                     * 当前背包的容量不确定可以放下物品i
                     * 那么此时分两种情况：
                     *    1、放不下,所以不放物品i
                     *    2、放物品i
                     * 比较这两种情况下，哪种背包中物品的最大价值最大
                     */
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
                }
            }
        }

        // 打印dp数组
        for (int i = 0; i < goods; i++) {
            for (int j = 0; j <= bagSize; j++) {
                System.out.print(dp[i][j] + "\t");
            }
            System.out.println("\n");
        }
    }
    //这种方法初始化时,初始化了一个(m+1)×(n+1)的二维数组，包含了额外的一行和一列，用来表示没有放入任何物品时的情况。
    public static void testWeightBagProblem2(int[] weight, int[] value, int bagSize) {

        // 创建dp数组
        int m = weight.length;  // 获取物品的数量
        int n = bagSize;
        int[][] dp = new int[m + 1][n + 1];  // 创建动态规划数组，行表示物品数量，列表示背包容量

        // 填充dp数组
        for (int i = 1; i <= m; i++) {  // 遍历物品
            for (int j = 1; j <= n; j++) {  // 遍历背包容量
                if (j < weight[i - 1]) {  // 如果当前背包容量小于当前物品的重量，则无法装入该物品
                    dp[i][j] = dp[i - 1][j];  // 当前最优解等于上一个物品的最优解
                } else {  // 否则可以选择装入当前物品或者不装入当前物品，取两者中的最大值
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weight[i - 1]] + value[i - 1]);
                    // 不装入当前物品：dp[i - 1][j]
                    // 装入当前物品：dp[i - 1][j - weight[i - 1]] + value[i - 1]
                    // value[i - 1] 表示当前物品的价值
                }
            }
        }

        // 打印dp数组
        for (int i = 0; i <= m; i++) {
            for (int j = 0; j <= bagSize; j++) {
                System.out.print(dp[i][j] + "\t");  // 打印每个位置的最优值
            }
            System.out.println("\n");  // 换行
        }
    }

优化：

可以考虑用另一方式来定义dp[i][j]的含义，即dp[i][j] 表示考虑前i个物品，在背包容量为j时可以达到的最大价值。

那么dp[i][j]就可能从两种状态转换而来。

  • 第一种是当前物品i放不下，那么dp[i][j]=dp[i−1][j]，也就是继承上一个状态的最优解
  • 第二种是可以放当前物品i，那么dp[i][j]=dp[i−1][j−weight[i−1]]+value[i]，也就是在上一个状态的继承上加上当前物品i的价值

因此，可以的到递推公式：dp[i][j] = max(dp[i][j], dp[i - 1][j - weight[i - 1]] + value[i]);

优化后题解：

// 使用了优化后的递推公式 dp[i][j] = max(dp[i][j], dp[i - 1][j - weight[i - 1]] + value[i - 1]);
public static void testWeightBagProblem3(int[] weight, int[] value, int bagSize) {
    int length = weight.length;
    // 创建二维数组dp，dp[i][j]表示考虑前i个物品，在背包容量为j时的最大价值
    int[][] dp = new int[length + 1][bagSize + 1];
    
    // 遍历每个物品
    for (int i = 1; i <= length; i++) {
        // 遍历每个背包容量
        for (int j = 1; j <= bagSize; j++) {
            // 先假设不选第i个物品，继承上一个状态的最优解
            dp[i][j] = dp[i - 1][j];
            
            // 判断如果当前背包容量能够容纳第i个物品
            if (weight[i - 1] <= j) {
                // 考虑选择第i个物品后的最优解，这里要注意value[i - 1])是第i个物品的价值，因为第一行和第一列用0填充了,但是value数组是从索引0开始有意义的。
                dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - weight[i - 1]] + value[i - 1]);
            }
        }
    }
}

一维dp

在使用二维数组的时候，递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
其实可以发现如果把dp[i - 1]那一层拷贝到dp[i]上，表达式完全可以是：dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);也就是上面优化后的代码。
与其把dp[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了，只用dp[j]（一维数组，也可以理解是一个滚动数组）。

在一维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。此时，dp[j]的状态要么是上次取完物品i-1的状态，要么是加入物品i的状态。

 在取物品0的时候,dp[j]会进行第一轮更新[0  15  15  15	 15]
 在取物品1的时候,dp[j]会进行第二轮更新[0  15	 15	 20	 35]
 在取物品2的时候,dp[j]会进行第三轮更新[0  15	 15  20	 35]

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

  • 左边的 dp[j]：表示在更新当前容量 j 时，新的 dp[j] 值。

  • 右边的 dp[j]：表示背包装不下物品i，所以继承上次容量为 j 时取完物品i-1的最大价值，即在未考虑物品 i 的情况下的最大价值。

  • 右边的 dp[j - weight[i-1]] + value[i]：表示在当前更新之前，容量为 j - weight[i-1] 时的最大价值，加上当前物品 i 的价值。

为什么需要从后向前遍历？

在使用一维数组 dp 时，从后向前遍历容量 j 是为了避免在同一轮次中使用已经更新的值。这保证了每个物品 i 在更新时只被计算一次，不会重复使用。

举个例子：
物品 1: 重量 2，价值 3
物品 2: 重量 3，价值 4
背包容量为 5。

从前向后遍历：
我们从前向后遍历容量 j 来更新 dp 数组。看看会发生什么情况。

遍历第一个物品（重量 2，价值 3）：
j = 2:
dp[2] = max(dp[2], dp[2 - 2] + 3) = max(0, 0 + 3) = 3
更新后 dp = [0, 0, 3, 0, 0, 0]

j = 3:
dp[3] = max(dp[3], dp[3 - 2] + 3) = max(0, 0 + 3) = 3
更新后 dp = [0, 0, 3, 3, 0, 0]

j = 4:
dp[4] = max(dp[4], dp[4 - 2] + 3) = max(0, 3 + 3) = 6
更新后 dp = [0, 0, 3, 3, 6, 0]
从这里开始就出现问题了，求dp[4]的时候使用了更新后的dp[2]的值。

j = 5:
dp[5] = max(dp[5], dp[5 - 2] + 3) = max(0, 3 + 3) = 6
更新后 dp = [0, 0, 3, 3, 6, 6]，求dp[5]的时候使用了更新后的dp[3]的值。

遍历第二个物品。。。。（略）

从后向前遍历：
遍历第一个物品（重量 2，价值 3）：
j = 5:
dp[5] = max(dp[5], dp[5 - 2] + 3) = max(0, 0 + 3) = 3
更新后 dp = [0, 0, 0, 0, 0, 3]，这里使用的dp[2]是还没更新的值。
…（略）

一维dp代码：

    public static void testWeightBagProblem(int[] weight, int[] value, int bagSize) {
        int[] dp = new int[bagSize + 1];
        for (int i = 0; i < weight.length; i++) {
            for (int j = bagSize; j >= weight[i]; j--) {
                //因为i在更新,所以max中的dp[j]都是上一层中的dp[j],所以隐式地实现了"dp[i - 1]一层拷贝到dp[i]"
                dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);//max中的dp[j]是取上一个物品时对应容量j的最大价值
            }
        }
        for (int j = 0; j <= bagSize; j++) {
            System.out.print(dp[j] + "\t");
        }
    }

416. 分割等和子集

在这里插入图片描述

题目链接：416. 分割等和子集
文档讲解：代码随想录
状态：感觉像碰运气做出来的。。

思路：

第一步读题：分割成两个子集，使得两个子集的元素和相等，那么可以考虑先求和再除以2，得到目标值。对于nums中的数字，尝试不同的取值求和，只要得到和为target说明一定可以分成两个和相等的子集。所以可以考虑使用背包解题。

第二步判断背包类型：

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

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

第三步：动规五部曲分析。

  • dp[j] 表示： 容量为j的背包，所背的物品价值最大可以为dp[j]。在本题中就是取不同的值求得最大和dp[j]。本题中如果dp[j]=j就是满足条件了。
  • 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]);
  • 初始化，取第一个数字前，dp[j]都为0
  • 确定遍历顺序：如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！
  • 举例推导dp数组：如果dp[j] == j 说明，集合中的子集总和正好可以凑成总和j

题解：

// 一维dp实现
public boolean canPartition(int[] nums) {
    int sum = 0;
    // 计算数组总和
    for (int num : nums) {
        sum += num;
    }
    // 如果总和是奇数，不可能分成两个相等的子集
    if (sum % 2 == 1) {
        return false;
    }
    // 目标值是总和的一半
    int target = sum / 2;
    // 创建一维dp数组，dp[j]表示是否存在子集和为j
    int[] dp = new int[target + 1];
    // 遍历所有数字
    for (int i = 0; i < nums.length; i++) {
        // 倒序遍历所有可能的和
        for (int j = target; j > 0; j--) {
            // 如果当前数字小于等于目标和，更新dp数组
            if (nums[i] <= j) { // 刚开始没注意到这里, 其实最好写在for循环的判断条件中, 因为使用的数字肯定不能大于目标和
                dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
            }
        }
        // 剪枝，只要有满足条件即可提前退出
        if (dp[target] == target) {
            return true;
        }
    }
    // 检查是否可以找到和为target的子集
    return dp[target] == target;
}

二维dp题解：

// 二维dp实现
public boolean canPartition(int[] nums) {
    int sum = 0;
    // 计算数组总和
    for (int num : nums) {
        sum += num;
    }
    // 如果总和是奇数，不可能分成两个相等的子集
    if (sum % 2 == 1) {
        return false;
    }
    // 目标值是总和的一半
    int target = sum / 2;
    // 创建二维dp数组，dp[i][j]表示前i个数能否组成和为j
    int[][] dp = new int[nums.length + 1][target + 1];
    // 遍历所有数字
    for (int i = 1; i <= nums.length; i++) {
        // 遍历所有可能的和
        for (int j = 1; j <= target; j++) {
            if (nums[i - 1] > j) {
                // 如果当前数字大于目标和，不能选当前数字，继承上一个状态的结果
                dp[i][j] = dp[i - 1][j];
            } else {
                // 否则，可以选择或者不选择当前数字，取两者的最大值
                dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - nums[i - 1]] + nums[i - 1]);
            }
        }
    }
    // 检查是否可以找到和为target的子集
    return dp[nums.length][target] == target;
}
*MaybE
关注
  • 36
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++使用回溯法解决01背包问题（含算法原理和代码）
12-24
回溯法是一种搜索算法，常用于解决组合优化问题，如八皇后问题、迷宫问题等。在01背包问题中，回溯法同样能够发挥其威力。01背包问题是一个经典的动态规划问题，但也可以通过回溯法进行解决。下面我们将深入探讨回溯...
算法设计与分析实验4 ：利用动态规划的方法解决子集等和分割判断问题
01-17
【背包问题与子集等和分割的关联】 这个问题可以通过转化为0-1背包问题来解决。0-1背包问题指的是给定一组物品，每种物品都有重量和价值，目标是在不超过背包容量的前提下，选择物品以最大化价值。在这个子集等和...
代码随想录算法训练营第37天 |01背包、等和子集
weixin_53088678的博客
06-29 95
【代码】代码随想录算法训练营第37天 |01背包、等和子集。
代码随想录算法训练营第41天| 01背包问题、416. 分割等和子集
qq_44119037的博客
02-24 394
完成。
代码随想录算法训练营第42天| 01 背包问题，416. 分割等和子集
dreams00的博客
09-06 197
链接: 01 背包问题 二维数组 链接: 01 背包问题 一维数组 链接: 416. 分割等和子集这道题很懵，可能需要重做
代码随想录算法训练营第42天 | 01背包问题 416. 分割等和子集
miracle_world的博客
12-23 362
动态规划
代码随想录算法训练营第35天| 背包问题 416. 分割等和子集
meiqiuxiaohei的博客
08-07 242
思路：1. 为了求能否分成两个和相等的子集，首先要求总和的1/2是多少，如果是奇数则返回false；如果是偶数则遍历整个数组，看能否找到几个元素，使他们的和等于sum/2，也就是说刚好能填满容量为sum/2的背包。学习了背包问题的二维解决方法和一维解决方法，当前状态是由之前的状态决定的。二维解决方法可以按当前访问的物品进行压缩，变成滚动数组，从而转化为一维解决方法。2. dp[j] 背包容量为j时能否填满 递推公式：dp[j]=dp[j] || dp[j-nums[i]]416. 分割等和子集。
代码随想录算法训练营第42天 | 01背包 416.分割等和子集
lebowskii的博客
11-02 236
day 42 01背包基础 等和子集
代码随想录算法训练营Day35 | 01背包问题 | 416. 分割等和子集
wonderlandlja的博客
08-10 256
【代码】代码随想录算法训练营Day35 | 01背包问题 | 416. 分割等和子集。
代码随想录算法训练营第42天 | 01背包理论基础 416.分割等和子集
qq_44173169的博客
02-07 482
int。
代码随想录算法训练营第42天 || 01背包问题 || 416. 分割等和子集
m0_63617655的博客
02-11 108
代码随想录算法训练营第42天 || 01背包问题 || 416. 分割等和子集
01背包问题和分数背包问题详解（贪心算法）
05-10
01背包问题与分数背包问题是计算机科学中优化问题的经典实例，尤其在算法设计与分析领域中占有重要地位。这些问题常用于资源有限时如何选择物品以最大化价值或收益，广泛应用于项目选择、投资决策、物流规划等多个...
01背包问题回溯法解决子集树
11-10
01背包问题是一种经典的组合优化问题，经常出现在计算机科学、运筹学以及算法设计与分析中。在这个问题中，我们有n个物品，每个物品都有一个重量w[i]和一个价值v[i]，以及一个容量为W的背包。目标是选择物品的子集，...
C#，子集和问题（Subset Sum Problem）的算法与源代码
04-25
C#，子集和问题（Subset Sum Problem）的算法与源代码 1 子集和问题（Subset Sum Problem） 给定一组非负整数和一个值和，确定给定集合中是否存在和等于给定和的子集。 示例： 输入：set[]={3，34，4，12，5，2}，...
算法：外卖调度
m0_73915763的博客
08-13 1142
有N个餐厅和M个外卖员，每个餐厅在某个时间点会产生一个外卖订单，这些订单都有产生时间、所需送达时间和优先级。外卖员在空闲时会选择最优先的订单来配送，直到所有订单都被送达。具体规则如下: 对于每个餐厅的订单，优先级高的订单优先，其次是所需送达时间最短的订单，再次是产生时间最早的订单。外卖员在空闲时会从所有餐厅的最高优先级订单中挑选一个所需送达时间最短的订单进行配送，若所需送达时间相同则选择餐厅编号最小的订单。
【LeetCode】字母异位词分组
LittleFishC的博客
08-14 88
使用unordered_map（哈希表）将排序后的字符串映射到一个字符串列表中。哈希表的键是排序后的字符串，值是所有与该键对应的原始字符串组成的列表。输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]给你一个字符串数组，请你将字母异位词组合在一起。字母异位词是由重新排列源单词的所有字母得到的一个新单词。输出: [[“a”]]输出: [[“”]]
看demo学算法之 循环神经网络（RNN）
最新发布
wx740851326的博客
08-15 219
今天我们来聊聊神经网络中的“记忆大师”——循环神经网络（RNN）。想象一下，你正在看电影，每一帧都连贯着前一帧的故事情节。RNN就像是这样一位观众，它能记住之前看到的内容，帮助理解当前的画面。是不是很酷？🎬。
每日OJ_牛客HJ75 公共子串计算
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
08-12 507
每日OJ_牛客HJ75 公共子串计算（求最大公共子串，使用递推实现 假设 x(i)：字符串第i个字符 y(j)：字符串第j个字符 dp[i][j]：以x(i)，y(j)结尾的最大子串长度。比如：x: "abcde" y:"bcdae" dp[2][1]：以x(2)，y(1)结尾的最大子串长度即：x遍历到"abc"，y遍历 到"bc"，都以字符'c'结尾时最大公共子串为"bc"）
请为子集和问题（是否存在和为t的子集）设计一个拉斯维加斯算法，给出c++代码
04-25
好的，让我来回答您的问题。 对于子集和问题，我们可以使用以下拉斯维加斯算法： 1. 生成一个长度为n的数组a，其中每个元素都是随机的+1或-1. 2. 对于每个长度小于等于n的子集s，计算其元素之和sum，并判断sum是否等于t。 3. 如果找到一个sum等于t的子集，则返回true。 4. 如果找不到符合要求的子集，则返回false。 下面是该算法的C语言代码实现： #include <stdbool.h> #include <stdlib.h> bool subset_sum(int *a, int n, int t) { for (int i = 0; i < n; i++) { a[i] = rand() % 2 ? 1 : -1; } for (int i = 0; i < (1 << n); i++) { int sum = 0; for (int j = 0; j < n; j++) { if ((i >> j) & 1) { sum += a[j]; } } if (sum == t) { return true; } } return false; } 请注意，这只是一个简单的实现，可能无法处理较大的输入。对于大型输入，可以使用更高效的算法，如动态规划。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值