餐饮加盟网网站建设新网站多久被收录

背包问题

二维

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

dp数组有两维，横轴表示背包重量j（0-j），纵轴表示不同物品（0-i），dp[i][j]即表示从下标为[0-i]的物品里任意取，对于重量为j的背包，最大的价值是多少。dp[i][j]的对物品i来说只有2种情况，物品i未放入或者放入，如果物品i未放入，由dp[i-1][j]可以推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i-1][j]（当物品i的重量大于背包j的重量时，物品i无法放进背包中，所以背包内的价值依然和前面相同。）（参考代码随想录 (programmercarl.com)）放物品时，

dp[i][j] =dp[i-1][j-weight[i]]+value[i]，即当未放入i时，且重量为j-weight[i]的dp值加上i的价值。

即dp[i][j]的最终推导公式为：dp[i][j] = max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i])

考虑到dp[i][j]的含义，则dp[i][0]意味着背包重量为0的价值，理应全为0，dp[i][0]的值初始化全部为0,此外当i为0时，若j<weight[0]时，dp[i][j]的值应该为0，因为背包容量比编号为0的物品重量要小，而当j>=weight[0]时，dp[0][j]的值应该是value[0]，因为背包容量足够放编号为0的物品（注意这里是0-1背包问题，只有放入和取出两种操作，所以这里dp[0][j]只为values[0]而不是values[0]的倍数）

由于dp的递推公式dp[i][j] = max(dp[i-1][j], dp[i-1][j-weight[i]] + value[i])，当前dp[i][j]仅与之前的元素有关，其他地方无需初始化。

vector<vector<int>>dp(weight.size(),vector<int>(bagweight + 1, 0));
for(int j = weight[0]; j <= bagweight; j++){dp[0][j] = value[0];
}

之后是确定遍历顺序，对物品和背包的遍历都是可行的。

以遍历物品为例，当j<weight[i]时，无法将物品i放入，则dp[i][j] = dp[i-1][j]，否则为上述的dp公式。

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];elsedp[i][j] = max(dp[i][j-1],dp[i-1][j-weight[i]]+value[i]);}
}

遍历背包的话

for(int j = 0; j <= bagweight; j++){for(int i = 0; i < weight.size(); i++){if(j < weight[i])dp[i][j] = dp[i-1][j];elsedp[i][j] = max(dp[i-1][j],dp[i-1][j-value[i]] + value[i]);}
}

只是变更一下顺序，其他一样（对本题是这样的）。

之后就是返回dp数组的最大值即可。

代码随想录的代码如下：

//二维dp数组实现
#include <bits/stdc++.h>
using namespace std;int n, bagweight;// bagweight代表行李箱空间
void solve() {vector<int> weight(n, 0); // 存储每件物品所占空间vector<int> value(n, 0);  // 存储每件物品价值for(int i = 0; i < n; ++i) {cin >> weight[i];}for(int j = 0; j < n; ++j) {cin >> value[j];}// dp数组, dp[i][j]代表行李箱空间为j的情况下,从下标为[0, i]的物品里面任意取,能达到的最大价值vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));// 初始化, 因为需要用到dp[i - 1]的值// j < weight[0]已在上方被初始化为0// j >= weight[0]的值就初始化为value[0]for (int j = weight[0]; j <= bagweight; j++) {dp[0][j] = value[0];}for(int i = 1; i < weight.size(); i++) { // 遍历科研物品for(int j = 0; j <= bagweight; j++) { // 遍历行李箱容量// 如果装不下这个物品,那么就继承dp[i - 1][j]的值if (j < weight[i]) dp[i][j] = dp[i - 1][j];// 如果能装下,就将值更新为 不装这个物品的最大值 和 装这个物品的最大值 中的 最大值// 装这个物品的最大值由容量为j - weight[i]的包任意放入序号为[0, i - 1]的最大值 + 该物品的价值构成else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);}}cout << dp[weight.size() - 1][bagweight] << endl;
}int main() {while(cin >> n >> bagweight) {solve();}return 0;

算法使用两层嵌套循环来补全dp数组，外层执行weight.size()次，即n次，内层执行了bagweight+1次，定为m次，时间复杂度为O(n*m)，空间复杂度使用了二维数组，O(n*m)。

一维

滚动数组，不太理解，周末看看。

代码随想录 (programmercarl.com)

// 一维dp数组实现
#include <iostream>
#include <vector>
using namespace std;int main() {// 读取 M 和 Nint 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，初始值为0vector<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. 分割等和子集 - 力扣（LeetCode）

        本来想着直接排序然后依次加入最小的数，然后发现果然有错[1,1,2,2]。

        以[1,5,11,5]这个题例为例，可以抽象为 一个背包容量为11，剩余元素（只能使用1次）是否能装满这个容量为11的背包。0-1背包问题。

        DP数组含义，容量为j的最大价值为dp[j],当dp[target] == target时，表示能装满（此处的target为数组sum的一半，因为两个子集和要相等），即能实现分割等和子集。

        背包容量从0到10001，因为数字总和不超过20000，则target<=10000,dp数组长度到达10001就够了。

        dp[j] = max(dp[j],dp[j - nums[i]]+ nums[i]);

        对dp的初始化，由于nums数组全为正整数，可以全部初始化为0，（若存在负数，则应初始化为INT_MIN）。

遍历顺序物品遍历在外，背包遍历在内层，且内层倒序遍历。参考代码随想录 (programmercarl.com)

最后需考虑，当dp[target] == target时，返回true，否则为false。

此外，若sum%2 == 1，则表明sum为奇数，不存在两个相等的子数组和，return false。剪枝。

class Solution {
public:bool canPartition(vector<int>& nums) {int sum = 0; for(auto x:nums){sum += x; // 计算数组元素的总和}// 如果总和是奇数，那么不能平分，直接返回falseif(sum%2 == 1)return false;// 计算目标和，即每个子集应该达到的和const int target = sum/2;// 初始化动态规划数组dp，大小为10001，初值都为0// dp[j]表示是否能够从前i个数字中选取一些数字，使得这些数字的和为jvector<int>dp(10001, 0);// 遍历数组中的每个数字for(int i = 0; i < nums.size();i++){// 从大到小遍历目标和及其以下的值for(int j = target; j >= nums[i]; j--){// 更新dp[j]，选取或不选取当前数字，取两种情况的最大值dp[j] = max(dp[j],dp[j - nums[i]] +nums[i]);}}// 如果dp[target]等于target，说明可以找到和为target的子集，返回trueif(dp[target] == target)return true;return false;}
};

算法的时间复杂度为O(n^2)，空间复杂度为O(n)。