416.分割等和子集1

01 背包

0-1 背包问题

有n件物品和一个最多能背重量为w 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

**0-1 背包问题的特点：**每种物品有且仅有 1 件，可以选择不放入背包，也可以选择放入背包。

01背包问题二维

使用二维数组

思路：

确定dp数组（dp table）以及下标的含义：dp[i] [j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少**。
确定递推公式： dp[i] [j] = max(dp[i - 1] [j], dp[i - 1] [j - weight[i]] + value[i]);
- 不放东西 :由dp[i - 1] [j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i] [j]就是dp[i - 1] [j]。(其实就是当物品i的重量大于背包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数组如何初始化：
- 首先从dp[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0。如图：
- 其他情况。
状态转移方程 dp[i] [j] = max(dp[i - 1] [j], dp[i - 1] [j - weight[i]] + value[i]); 可以看出i 是由 i-1 推导出来，那么i为0的时候就一定要初始化。

dp[0] [j]，即：i为0，存放编号0的物品的时候，各个容量的背包所能存放的最大价值。

那么很明显当 j < weight[0]的时候，dp[0] [j] 应该是 0，因为背包容量比编号0的物品重量还小。

当j >= weight[0]时，dp[0] [j] 应该是value[0]，因为背包容量放足够放编号0物品。
确定遍历顺序：先遍历物品还是先遍历背包重量呢？其实都可以！！但是先遍历物品更好理解
举例推导dp数组

bai

先遍历物品

def test_2_wei_bag_problem1(bag_size, weight, value) -> int:
	rows, cols = len(weight), bag_size + 1
	dp = [[0 for _ in range(cols)] for _ in range(rows)]

	# 初始化dp数组.
	for i in range(rows):
		dp[i][0] = 0
	first_item_weight, first_item_value = weight[0], value[0]
	for j in range(1, cols):
		if first_item_weight <= j:
			dp[0][j] = first_item_value

	# 更新dp数组: 先遍历物品, 再遍历背包.
	for i in range(1, len(weight)):
		cur_weight, cur_val = weight[i], value[i]
		for j in range(1, cols):
			if cur_weight > j: # 说明背包装不下当前物品.
				dp[i][j] = dp[i - 1][j] # 所以不装当前物品.
			else:
				# 定义dp数组: dp[i][j] 前i个物品里，放进容量为j的背包，价值总和最大是多少。
				dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - cur_weight]+ cur_val)

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

01.背包问题知识（一） | 算法通关手册 (itcharge.cn)

1.定义状态 dp[i] [w]表示为：前 i 件物品放入一个最多能装重量为 w 的背包中，可以获得的最大价值。

2.状态dp[i] [w] 是一个二维数组，其中第一维代表**「当前正在考虑的物品」**，第二维表示「当前背包的载重上限」，二维数组值表示「可以获得的最大价值」。

3.状态方程：dp[i] [w] = max(dp[i - 1] [j], dp[i - 1] [w - weight[i-1]] + value[i-1])

4.初始化：

如果背包载重上限为 0，则无论选取什么物品，可以获得的最大价值一定是 0，即，dp[i] [0] =0，0≤i≤size。
无论背包载重上限是多少，前 0 件物品所能获得的最大价值一定为 0，即，dp[0] [w] = 0，0≤w≤W。

class Solution:
    # 思路 1：动态规划 + 二维基本思路
    def zeroOnePackMethod1(self, weight: [int], value: [int], W: int):
        size = len(weight)
        dp = [[0 for _ in range(W + 1)] for _ in range(size + 1)]
        
        # 枚举前 i 种物品
        for i in range(1, size + 1):
            # 枚举背包装载重量
            for w in range(W + 1):
                # 第 i - 1 件物品装不下
                if w < weight[i - 1]:
                    # dp[i][w] 取「前 i - 1 件物品装入载重为 w 的背包中的最大价值」
                    dp[i][w] = dp[i - 1][w]
                else:
                    # dp[i][w] 取「前 i - 1 件物品装入载重为 w 的背包中的最大价值」与「前 i - 1 件物品装入载重为 w - weight[i - 1] 的背包中，再装入第 i - 1 物品所得的最大价值」两者中的最大值
                    dp[i][w] = max(dp[i - 1][w], dp[i - 1][w - weight[i - 1]] + value[i - 1])
                    
        return dp[size][W]

物品下标从1开始，范围变更为1，size+1

01背包问题一维

动规五部曲分析如下：

1.确定dp数组的定义：在一维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。

2.一维dp数组的递推公式:dp[j] = max(dp[j], dp[j - weight[i]] + value[i])

3.初始化：无论背包载重上限为多少，只要不选择物品，可以获得的最大价值一定是 0，dp[0]就应该是0

4.一维dp数组遍历顺序：先遍历物品再遍历背包（背包倒序遍历）倒序遍历是为了保证物品i只被放入一次

物品0的重量weight[0] = 1，价值value[0] = 15

如果正序遍历

dp[1] = dp[1 - weight[0]] + value[0] = 15

dp[2] = dp[2 - weight[0]] + value[0] = 30 (dp[1]更新)

倒序就是先算dp[2]

dp[2] = dp[2 - weight[0]] + value[0] = 15 （dp数组已经都初始化为0，即dp[1]=0）

dp[1] = dp[1 - weight[0]] + value[0] = 15

5.举例推导dp数组

动态规划-背包问题9

def test_1_wei_bag_problem():
    weight = [1, 3, 4]
    value = [15, 20, 30]
    bag_weight = 4
    # 初始化: 全为0
    dp = [0] * (bag_weight + 1)

    # 先遍历物品, 再遍历背包容量
    for i in range(len(weight)):
        for j in range(bag_weight, weight[i] - 1, -1):
            # 递归公式
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i])

    print(dp)

test_1_wei_bag_problem()

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

01.背包问题知识（一） | 算法通关手册 (itcharge.cn)

1.定义状态 dp[w]表示为：将物品放入一个最多能装重量为 w 的背包中，可以获得的最大价值。

2.dp[w] = max(dp[w], dp[w - weight[i-1]] + value[i-1])

3.初始化：无论背包载重上限为多少，只要不选择物品，可以获得的最大价值一定是 0，即 dp[w] = 0, 0<=w<=W

class Solution:
    # 思路 2：动态规划 + 滚动数组优化
    def zeroOnePackMethod2(self, weight: [int], value: [int], W: int):
        size = len(weight)
        dp = [0 for _ in range(W + 1)]
        
        # 枚举前 i 种物品
        for i in range(1, size + 1):
            # 逆序枚举背包装载重量（避免状态值错误）
            for w in range(W, weight[i - 1] - 1, -1):
                # dp[w] 取「前 i - 1 件物品装入载重为 w 的背包中的最大价值」与「前 i - 1 件物品装入载重为 w - weight[i - 1] 的背包中，再装入第 i - 1 物品所得的最大价值」两者中的最大值
                dp[w] = max(dp[w], dp[w - weight[i - 1]] + value[i - 1])
                
        return dp[W]

物品下标从1开始，范围变更为1，size+1

416.分割等和子集

思路：

转换为 01背包

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

动规五部曲

1.确定dp数组以及下标的含义:如果背包容量为target， dp[target]就是装满背包之后的重量，所以当 dp[target] == target 的时候，背包就装满了

2.确定递推公式

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]);

3.dp数组如何初始化:01背包，一维dp初始化，dp[0] =0

4.确定遍历顺序:如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历

5.举例推导dp数组:

dp[j]的数值一定是小于等于j的。

如果dp[j] == j 说明，集合中的子集总和正好可以凑成总和j，理解这一点很重要。

416.分割等和子集2

一维数组

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        target = sum(nums)
        if target % 2 == 1: return False
        target //= 2
        dp =[0 for _ in range(target+1)]
        dp[0] = 0
        for i in range(len(nums)):
            for j in range(target,nums[i]-1,-1):
                dp[j] = max(dp[j],dp[j-nums[i]]+nums[i])
        return target == dp[target]

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        target = sum(nums)
        if target % 2 == 1: return False
        target //= 2
        dp =[0 for _ in range(target+1)]
        dp[0] = 0
        for i in range(1,len(nums)+1):
            for j in range(target,nums[i-1]-1,-1):
                dp[j] = max(dp[j],dp[j-nums[i-1]]+nums[i-1])
        return target == dp[target]

二维数组

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        target = sum(nums)
        if target % 2 == 1: return False
        target //= 2
        dp =[[0 for _ in range(target+1)] for _ in range(len(nums))]

        for i in range(len(nums)):
            dp[i][0]= 0

        for j in range(target+1):
            if nums[0] <=j:
                dp[0][j] = nums[0]

        # 先遍历物品再遍历背包
        for i in range(len(nums)):
            cur_weight = nums[i]
            cur_value = nums[i]
            for j in range(target+1):
                if cur_weight > j:
                    dp[i][j] = dp[i-1][j]
                else:
                    dp[i][j]  = max(dp[i-1][j],dp[i-1][j-cur_weight]+cur_value)
        return target == dp[-1][target]

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        target = sum(nums)
        if target % 2 == 1: return False
        target //= 2
        dp =[[0 for _ in range(target+1)] for _ in range(len(nums)+1)]

        # 先遍历物品再遍历背包
        for i in range(1,len(nums)+1):
            for j in range(target+1):
                if  j < nums[i-1] :
                    dp[i][j] = dp[i-1][j]
                else:
                    dp[i][j]  = max(dp[i-1][j],dp[i-1][j-nums[i-1]]+nums[i-1])
        return target == dp[-1][target]