算法记录 | Day42 动态规划

416.分割等和子集1

01 背包

0-1 背包问题

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

img

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

01背包问题 二维

使用二维数组

思路 :

  1. 确定dp数组(dp table)以及下标的含义:dp[i] [j] 表示从下标为[0-i]的物品里任意取,放进容量为j的背包,价值总和最大是多少**。

    动态规划-背包问题1

  2. 确定递推公式: 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得到的最大价值
  3. dp数组如何初始化:

    • 首先从dp[i][j]的定义出发,如果背包容量j为0的话,即dp[i][0],无论是选取哪些物品,背包价值总和一定为0。如图:

    动态规划-背包问题2

    • 其他情况。

    状态转移方程 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物品。

    动态规划-背包问题7

  4. 确定遍历顺序:先遍历 物品还是先遍历背包重量呢?其实都可以!! 但是先遍历物品更好理解

  5. 举例推导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]
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值