代码随想录刷题第42天|01背包二维、一维，LeetCode416分割等和子集

1、01背包二维数组

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

dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。

2、递推公式：

不放物品i：dp[i][j] = dp[i - 1][j]。物品i的重量大于背包j的重量时，物品i无法放进背包中，所以背包内的价值依然和前面相同。

放物品i： dp[i,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]);

3、初始化：

当背包容量为0时，dp[i,0] = 0;

i 由 i-1 推导而来，i为0时要初始化。当背包容量 j < weight[0]时，dp[0][j] = 0; 

当背包容量 j >= weight[0]时，dp[0][j] = value[0];

4、遍历顺序：

二维数组 先遍历物品还是先遍历背包容量 都可以，

一维数组 必须要先遍历物品，再遍历背包容量。

5、举例推导dp数组。

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>

void show_dp(vector<vector<int>>& v)
{
	for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++)
	{
		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
		{
			cout << *vit << " ";
		}
		cout << endl;
	}
}

void test_2_wei_bag()
{
	vector<int> weight = { 1,3,4 };
	vector<int> value = { 15, 20, 30 };
	int bagweight = 4;

	vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 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++)
		{
			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]);
		}
	}

	show_dp(dp);
	cout << dp[weight.size() - 1][bagweight] << endl;
}


int main()
{
	test_2_wei_bag();

	system("pause");
	return 0;
}

2、01背包一维数组

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

dp[j] 表示容量为j的背包，能放物品的价值总和最大是多少。

2、递推公式：

不放物品i：取自己 dp[j] = dp[j]。

放物品i： dp[j] = dp[j - weight[i]] + value[i]。

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

3、初始化：

当背包容量为0时，dp[0] = 0;

因为每次要取最大，其他也初始化为0。

4、遍历顺序：

背包容量要倒叙遍历，如果正序遍历，物品可能会放入多次。在二维数组中，dp[i][j]都是从左上角的值推出，因此要保证前面的不要被打乱，倒叙遍历。

一维数组 必须要先遍历物品，再遍历背包容量。

如果先遍历背包容量，背包容量是倒叙遍历，前面的都为0，dp[j - weight[i]] + value[i], 相当于每次只放入一个物品，不能累加，因此价值总和不是最大的。

如果先遍历物品，对于每个物品，前面各容量背包都会有值。

5、举例推导dp数组。

#include<iostream>
using namespace std;
#include<algorithm>
#include<vector>

void show_dp(vector<int>& v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test_1_wei_bag()
{
	vector<int> weight = { 1,3,4 };
	vector<int> value = { 15,20,30 };
	int bagweight = 4;
	vector<int> dp(bagweight + 1, 0);

	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]);
		}
	}
	show_dp(dp);
	cout << dp[bagweight] << endl;
}

int main()
{
	test_1_wei_bag();
	system("pause");
	return 0;
}

3、LeetCode416分割等和子集 

题目链接：416、分割等和子集

一个商品如果可以重复多次放入是完全背包，而只能放入一次是01背包。

本题要求集合里能否出现总和为 sum / 2 的子集。

背包的体积为sum / 2；

背包如果正好装满，说明找到了总和为 sum / 2 的子集；

如果sum是奇数，肯定找不到等和的。

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int sum = 0;
        for (int i = 0; i < nums.size(); i++)
        {
            sum += nums[i];
        }
        if (sum % 2 == 1) return false;
        int target = sum / 2;

        vector<int> dp(10001， 0);
        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;
    }
};