动态规划01背包

已于 2024-08-27 22:35:32 修改
阅读量951 收藏 14
点赞数 24
文章标签： 动态规划 算法 数据结构 c++ leetcode
于 2024-08-21 02:45:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79555067/article/details/141371771
版权

模板题

46. 携带研究材料

思路分析:

动态规划思路如下：

  1. dp[i][j] 表示:：从前 i 个物品中挑选，总体积不超过 j ，所有选法中，能挑出来的最大价值
  2. 分情况讨论状态转移方程怎么写：
    • 不放物品i：由dp[i - 1][j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]。
    • 放物品i：由dp[i - 1][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]);
  3. 初始化：
    • 可以物品序号从1开始，而0行0列都初始化为0即可，返回第
  4. 遍历顺序：从上到下，有两个遍历的维度：物品与背包容量，先遍历谁都可以，两个for循环遍历的次序不同，但是因为dp[i][j]所需要的数据就是左上角，所以根本不影响dp[i][j]公式的推导

代码：二维数组

#include <bits/stdc++.h>
using namespace std;
int main() {
    int M, N;
    cin >> M >> N;
    vector<int> weight(M + 1, 0);
    vector<int> value(M + 1, 0);
    for (int i = 1; i <= M; i++) cin >> weight[i];
    for (int i = 1; i <= M; i++) cin >> value[i];
    vector<vector<int>> dp(M + 1, vector<int>(N + 1, 0));
    for (int i = 1; i < M + 1; i++) {
        for (int j = 1; j < N + 1; j++) {
            if (j - weight[i] < 0)
                dp[i][j] = dp[i - 1][j];
            else {
                dp[i][j] =
                    max(dp[i - 1][j], value[i] + dp[i - 1][j - weight[i]]);
            }
        }
    }
    cout << dp[M][N];
    return 0;
}

代码：一维数组(滚动数组)

把dp[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了，只用dp[j]
只不过遍历顺序改变：倒序遍历
只需将二维的代码修改删掉一个维度，然后遍历j从后向前
两个嵌套for循环的顺序，代码中是先遍历物品嵌套遍历背包容量，不可以先遍历背包容量嵌套遍历物品

#include <bits/stdc++.h>
using namespace std;
int main() {
    int M, N;
    cin >> M >> N;
    vector<int> weight(M + 1, 0);
    vector<int> value(M + 1, 0);
    for (int i = 1; i <= M; i++) cin >> weight[i];
    for (int i = 1; i <= M; i++) cin >> value[i];
    vector<int> dp(N + 1, 0);
    for (int i = 1; i < M + 1; i++) {
        for (int j = N; j >= weight[i]; j--) {
            dp[j] = max(dp[j], value[i] + dp[j - weight[i]]);
        }
    }
    cout << dp[N];
    return 0;
}

DP41 【模板】01背包

思路分析

第一问和上一题方法一模一样，第二问只需在第一问思路基础上简单修改即可

  1. 第二问：dp[i][j] 表示:：从前 i 个物品中挑选，总体积正好等于 j ，所有选法中，能挑出来的最大价值
  2. 递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]);
  3. 初始化dp[0][j] = -1;第0行从第1个开始都为-1，(dp[0][0]为0)

tips:dp[i][j] == -1表示没有这种情况,所以在for循环里要有限制条件

代码：二维数组

#include <bits/stdc++.h>
using namespace std;

const int N = 1010;
int n, V, v[N], w[N];
int dp[N][N];
int main() {
    cin >> n >> V;
    for (int i = 1; i <= n; i++) {
        cin >> v[i] >> w[i];
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= V; j++) {
            dp[i][j] = dp[i - 1][j];
            if (j - v[i] >= 0) {
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]);
            }
        }
    }
    cout << dp[n][V] << endl;
    memset(dp, 0, sizeof dp);//回答第二问前清空dp
    for (int j = 1; j <= V; j++)
        dp[0][j] = -1;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= V; j++) {
            dp[i][j] = dp[i - 1][j];
            if (j - v[i] >= 0 && dp[i - 1][j - v[i]] != -1) {
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]);
            }
        }
    }
    cout << (dp[n][V] == -1 ? 0 : dp[n][V]) << endl;

    return 0;
}

代码：一维数组(滚动数组)

#include <bits/stdc++.h>
using namespace std;

const int N = 1010;
int n, V, v[N], w[N];
int dp[N];
int main() {
    cin >> n >> V;
    for (int i = 1; i <= n; i++) {
        cin >> v[i] >> w[i];
    }
    for (int i = 1; i <= n; i++) {
        for (int j = V; j >= v[i]; j--) {
                dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
        }
    }
    cout << dp[V] << endl;
    memset(dp, 0, sizeof dp);
    for (int j = 1; j <= V; j++)
        dp[j] = -1;
    for (int i = 1; i <= n; i++) {
        for (int j = V; j >= v[i]; j--) {
            if (dp[j - v[i]] != -1) {
                dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
            }
        }
    }
    cout << (dp[V] == -1 ? 0 : dp[V]) << endl;

    return 0;
}

练习题

416. 分割等和子集

背包的体积为sum / 2，背包要放入的商品（集合里的元素）重量为 元素的数值，价值也为元素的数值，如果正好装满，说明找到了总和为 sum / 2 的子集。同时背包中每一个元素是不可重复放入。
dp[i]中的i表示背包内总和
题目中说：每个数组中的元素不会超过 100，数组的大小不会超过 200 总和不会大于20000，背包最大只需要其中一半，所以10001大小就可以

  1. dp[j]表示 背包总容量（所能装的总重量）是j，放进物品后，背的最大重量为dp[j]。
  2. 递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
  3. 初始化dp[0]一定是0
  4. 如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历

代码：一维数组(滚动数组)

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        vector<int> dp(10001, 0);
        for (int i = 0; i < nums.size(); i++) sum += nums[i];
        if (sum % 2 == 1)  return false;
        int target = sum / 2;
        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]);
            }
        }
        if (dp[target] == target) return true;
        return false;
    }
};

494. 目标和

先将问题转化成我们熟悉的题型
设我们最终选取的结果中，前面加 + 号的数字之和为 a ，前面加 - 号的数字之和为 b ，整个数组
的总和为 sum ，于是我们有：

  • a + b = sum
  • a - b = target

上面两个式子消去 b 之后，可以得到 a = (sum + target) / 2
也就是说，我们仅需在 nums 数组中选择一些数，将它们凑成和为 (sum + target) / 2 即可。
由于多开一行一列，所以两个for循环里用原数组时候记得下标的映射关系

代码：二维数组

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;
        for (int x : nums) sum += x;
        int aim = (sum + target) / 2;
        if (aim < 0 || (sum + target) % 2) return 0;
        int n = nums.size();
        vector<vector<int>> dp(n + 1, vector<int>(aim + 1, 0));
        dp[0][0] = 1; // 只需初始化这个位置
        // dp表示前i个数里选，总和正好等于j，有多少种选法
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j <= aim; j++) {
                dp[i][j] = dp[i - 1][j];
                if (j >= nums[i - 1])
                    dp[i][j] += dp[i - 1][j - nums[i - 1]];
            }
        }
        return dp[n][aim];
    }
};

代码：一维数组(滚动数组)

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int sum = 0;
        for (int x : nums) sum += x;
        int aim = (sum + target) / 2;
        if (aim < 0 || (sum + target) % 2) return 0;
        int n = nums.size();
        vector<int> dp(aim + 1, 0);
        dp[0] = 1; // 只需初始化这个位置
        for (int i = 1; i <= n; i++) {
            for (int j = aim; j >= nums[i - 1]; j--) {
                dp[j] += dp[j - nums[i - 1]];
            }
        }
        return dp[aim];
    }
};

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

先将问题转化成我们熟悉的题型

  • 任意两块石头在一起粉碎，重量相同的部分会被丢掉，重量有差异的部分会被留下来。那就
    相当于在原始的数据的前面，加上「加号」或者「减号」，是最终的结果最小即可。也就是
    说把原始的石头分成两部分，两部分的和越接近越好。
  • 又因为当所有元素的和固定时，分成的两部分越接近数组「总和的一半」，两者的差越小。
    因此问题就变成了：在数组中选择一些数，让这些数的和尽量接近 sum / 2 ，如果把数看成物
    品，每个数的值看成体积和价值，问题就变成了「01背包问题」。
  1. 状态表示dp[i][j] 表示在前 i 个元素中选择，总和不超过 j ，此时所有元素的 最大和
  2. 递推公式和「01背包一样」
  3. 初始化：由于需要用到上一行的数据，因此我们可以先把第一行初始化。
    由于多开一行一列，所以两个for循环里用原数组时候记得下标的映射关系
    第一行表示「没有石子」。因此想凑成目标和 j ，最大和都是 0
  4. 返回值：
    a. 根据dp，先找到最接近 sum / 2 的最大和 dp[n][sum / 2] ；
    b. 因为我们要的是两堆石子的差，因此返回 sum - 2 * dp[n][sum / 2] 即可

代码：二维数组

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int sum = 0;
        for (int x : stones) sum += x;
        int n = stones.size();
        vector<vector<int>> dp(n + 1, vector<int>(sum / 2 + 1, 0));
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j <= sum / 2; j++) {
                dp[i][j] = dp[i - 1][j];
                if (j >= stones[i - 1])
                    dp[i][j] = max(dp[i][j], dp[i - 1][j - stones[i - 1]] + stones[i - 1]);
            }
        }
        return sum - 2 * dp[n][sum / 2];
    }
};

代码：一维数组(滚动数组)

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int sum = 0;
        for (int x : stones) sum += x;
        int n = stones.size();
        vector<int> dp(sum / 2 + 1, 0);
        for (int i = 1; i <= n; i++) {
            for (int j = sum / 2; j >= stones[i - 1]; j--) {
                dp[j] = max(dp[j], dp[j - stones[i - 1]] + stones[i - 1]);
            }
        }
        return sum - 2 * dp[sum / 2];
    }
};

474. 一和零

m 和 n相当于是一个背包，两个维度的背包
dp[i][j][k] 表示：从前 i 个字符串中挑选，字符 0 的个数不超过 j ，字符 1 的个数不超过 k ，所有的选法中，最大的⻓度。

代码：三维数组

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        int len = strs.size();
        vector<vector<vector<int>>> dp(len + 1, vector<vector<int>>(m + 1, vector<int>(n + 1, 0)));
        for (int i = 1; i <= len; i++) {
            int a = 0, b = 0;
            for (auto ch : strs[i - 1]) {
                if (ch == '0') a++;
                else b++;
            }
            for (int j = 0; j <= m; j++) {
                for (int k = 0; k <= n ; k++) {
                    dp[i][j][k] = dp[i - 1][j][k];
                    if (j >= a && k >= b)
                        dp[i][j][k] = max(dp[i][j][k], dp[i - 1][j - a][k - b] + 1);
                }
            }
        }
        return dp[len][m][n];
    }
};

代码：二维数组(滚动数组)

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        int len = strs.size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        for (int i = 1; i <= len; i++) {
            int a = 0, b = 0;
            for (auto ch : strs[i - 1]) {
                if (ch == '0') a++;
                else b++;
            }
            for (int j = m; j >= a; j--) {
                for (int k = n; k >= b; k--) {
                    dp[j][k] = max(dp[j][k], dp[j - a][k - b] + 1);
                }
            }
        }
        return dp[m][n];
    }
};
Alexia～
关注
01背包问题动态规划01背包问题动态规划
01-21
在"dynamic-programming-master"这个压缩包中，可能包含了一些关于动态规划的代码示例、练习题目和解题思路，对于学习和理解动态规划，特别是01背包问题的动态规划解法，是非常有帮助的。建议解压后仔细研究其中的...
动态规划 01背包问题 程序和代码
01-31
01背包问题作为动态规划的一个经典实例，是很多编程爱好者和专业开发者需要掌握的基础知识。在本压缩包中，你将找到关于10背包问题的动态规划实现，包括程序和代码。 01背包问题是一个典型的组合优化问题，假设我们...
动态规划01背包问题-java
m0_63267251的博客
04-02 1733
01背包问题是背包问题中最经典的一种。
【动态规划】01背包问题（通俗易懂，超基础讲解）
热门推荐
Yngz_Miao的博客
08-24 43万+
问题描述 有n个物品，它们有各自的体积和价值，现有给定容量的背包，如何让背包里装入的物品具有最大的价值总和？ 为方便讲解和理解，下面讲述的例子均先用具体的数字代入，即：eg：number＝4，capacity＝8 i（物品编号） 1 2 3 4 w（体积） 2 3 4 5 v（价值） 3 4 5 6 总...
动态规划 01背包 java实现
qq_62383709的博客
11-20 371
动态规划 01背包java实现
dp 动态规划 01背包问题 Python
Gbn_longger的博客
02-09 1659
https://www.bilibili.com/video/av33930433?from=search&seid=10637513335818789097 https://www.cnblogs.com/anzhengyu/p/11408466.html https://blog.csdn.net/blowfire123/article/details/112570815
动态规划01-背包问题
yzd111的博客
08-24 1140
有N件物品和一个容量是V的背包。每件物品只能使用一次。第i件物品的体积是Vi​，价值是Wi​。求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。第一行两个整数NV，用空格隔开，分别表示物品数量和背包容积。接下来有N行，每行两个整数Vi​Wi​，用空格隔开，分别表示第i件物品的体积和价值。输出一个整数，表示最大价值。
C++ 动态规划 01背包问题
fucheng的博客
02-01 1124
C++ 动态规划 01背包问题
动态规划求解01背包问题
Dong's Blog
10-03 2373
你的背包~背到现在还没烂~
动态规划——01背包问题
Wu_L7的博客
04-22 3万+
面向小白的动态规划之01背包问题的详细讲解
C++动态规划01背包问题
m0_74158049的博客
03-02 1401
详细讲解了01背包问题的动态规划解法思路。
算法 动态规划 01背包问题
XXXTENTAC1ON的博客
05-04 1350
01背包问题分析代码实现从前往后拿，递归实现非递归实现非递归实现，自上向下填充 允接上一文章内容： 算法 动态规划: link. 问题分析 按照普通思维，首先想到应该为贪心算法，也就是计算每个物品重量价值比，将性价比高的物品装入背包，但是这并不是该问题的最优解，因为物品不是可分割的，不能按照重量价值比进行选择 这道问题的最优解应该通过动态规划求解，那么其递归方程式为： 在这里f(i,j)，记为当背包容量为 j，现有 i 物品可拿，所能装进背包的最大价值 再者我们举例说明，假设背包总容量为8，现在有四件
动态规划_01背包_01背包_C++_算法_背包_动态规划_
09-30
标题中的"动态规划_01背包_01背包_C++_算法_背包_动态规划_"揭示了我们讨论的主题是使用C++编程语言实现的01背包问题的动态规划算法。01背包问题指的是每个物品只能被选择或不被选择（即0或1），不能被分割，目标是...
【C++算法】9.双指针_四数之和
最新发布
hlyd520的博客
10-04 420
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1126
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
排序算法之归并排序
qq_64039411的博客
10-01 488
需要注意的是，在实际应用中，归并排序的空间复杂度较高，需要额外的空间来存储临时数组。如果对空间复杂度有要求，可以考虑使用其他排序算法。归并排序是一种分治算法，它将一个数组分成两个子数组，然后递归地对子数组进行排序，最后将两个有序的子数组合并成一个有序的数组。归并排序的时间复杂度是O(nlogn)，其中n是数组的长度。它是一种稳定的排序算法，适用于各种数据类型的排序。合并排序的关键在于合并操作。
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1306
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
算法：按既定顺序创建目标数组
AWSDN的博客
09-29 238
本文主要介绍按既定顺序创建目标数组问题
动态规划01背包C语言代码
06-02
下面是一个简单的动态规划 01 背包问题的 C 语言代码实现： ``` #include #define N 5 // 物品数量 #define W 10 // 背包容量 int max(int a, int b) { return a > b ? a : b; } int main() { int i, j; int...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值