0-1背包问题
①dp[i][j]数组含义:容量为j的背包随机在前i个物品中取可以取得的最大值。
②初始化:dp[i][0]代表容量为0的背包可以取得的最大价值,无法装东西,其结果必然是0;dp[0][j]初始化只看第0个物品放进去或者不放进去的最大价值,当背包容量(j < weight[0])小于第0个物品重量时其结果为0,其余的初始化为第0个物品的价值,其余值可以随机初始化。
③递推公式:针对容量为j的背包,在处理第i个物品时有两种选择,选择最大的就可以。
I. 不放第i个物品取得的最大值,即在处理第i-1个物品时可以取得的最大value值dp[i-1][j]
II.放第i个物品取得的最大值:如果想要放置第i个物品背包首先要能空出放置第i个物品的质量,此时背包其余部分容量为j-weight[i],而dp[i-1][j-weight[i]]是剩余部分在前i-1个物品里可以取得的最大值,则当前可以取得最大值为dp[i-1][j-weight[i]] + value[i].
④遍历顺序:dp[i][j]的取值完全由dp[0 ~ i-1][0 ~ j-1]来决定,因此从小到大遍历的话先遍历物品还是先遍历容量无所谓,但是如果从大到小遍历容量的话必须先遍历物品(一维dp数组0-1背包问题)。
int backPackSolution(const std::vector<int>& weight, const std::vector<int>& value, size_t capacity) {
std::vector< std::vector<int> > dp(weight.size(), std::vector<int>(capacity + 1, 0));
for (std::vector<int>::size_type i = 0; i < capacity + 1; i++) {
if (i >= weight[0]) dp[0][i] = value[0];
}
for (std::vector<int>::size_type i = 1; i < weight.size(); i++) {
for (std::vector<int>::size_type j = 1; j < capacity + 1; j++) {
if (weight[i] > j) continue;
else dp[i][j] = std::max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
}
}
return dp[weight.size() - 1][capacity];
}
优化:一维dp数组
int backPackSolution1D(std::vector<size_t>& weight, std::vector<unsigned int>& value, size_t capacity) {
std::vector<unsigned int> dp(capacity + 1, 0);
for (std::vector<unsigned int>::size_type i = weight[0]; i <= capacity; i++) {
dp[i] = value[0];
}
for (std::vector<unsigned int>::size_type i = 1; i < value.size(); i++) {
for (size_t j = capacity; j >= weight[i]; j--) { //这里边界条件很巧妙
dp[j] = std::max(dp[j], dp[j - weight[i]] + value[i]);
}
}
return dp.back();
}
暴力超时的回溯
class Solution {
public:
bool canPartition(vector<int>& nums) {
int sum = 0;
for(int num : nums) { sum += num; }
if (sum % 2 == 1) return false;
sum /= 2;
int curSum = 0;
return backtracking(nums, 0, sum, curSum);
}
bool backtracking(vector<int>& nums, vector<int>::size_type startIndex, const int& sum, int& curSum) {
if(curSum == sum) return true;
else if(curSum > sum) return false;
for(vector<int>::size_type i = startIndex; i < nums.size(); i++) {
curSum += nums[i];
if(backtracking(nums, i + 1, sum, curSum)) return true;
curSum -= nums[i];
}
return false;
}
};
动态规划:
class Solution {
public:
bool canPartition(vector<int>& nums) {
int sum = 0;
for(int num : nums) { sum += num; }
if((sum & 1) == 1) return false;
sum = sum >> 1;
if(nums[0] > sum) return false;
else if(nums[0] == sum) return true;
vector<int> dp(sum + 1, 0);
for(vector<int>::size_type i = nums[0]; i < dp.size(); i++) {
dp[i] = nums[0];
}
for(vector<int>::size_type i = 1; i < nums.size(); i++) {
if(nums[0] > sum) return false;
else if(nums[0] == sum) return true;
for(vector<int>::size_type j = dp.size() - 1; j > 0; j--) {
if (nums[i] > j) continue;
else dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
if(dp[j] == sum) return true;
}
}
return false;
}
};