01背包问题分类-最全概括总结

01背包问题的基础见前两篇笔记:
二维数组写法一维数组写法
01背包问题主要分为3类:
背包是否可以装满问题,即存在性问题
背包最多能装多少问题,即最大值问题
有几种方式装满背包,即组合问题
我们接下来就开始看一看这三类问题
1. 背包是否可以装满问题,即存在性问题,是否存在一个。。。,可以使得背包被装满。
例题:分割等和子集
在这里插入图片描述

在这道题中,其实问的就是,是否存在一个子集,该子集的和=原数组和的1/2。
我们可以将背包的容量看作是sum(nums)/2。遍历找到符合该容量的值放入背包,并求其能得到的最大值。如果,最终放入的最大值=sum(nums)/2,那么就说明该背包可以被填满,一个容量为sum(nums)/2的背包被填满,就说明,存在子集,使得该子集的和=原数组和的1/2。
1)dp数组
dp[j]:存入容量为j的背包的集合元素所能得到的最大值。
2)状态转移公式
dp[j] = max(dp[j],dp[j-nums[i]]+nums[i])
3)初始化
dp[0] = 0
4)遍历顺序

for i in range(len(nums)):
	for j in range(sum(nums)/2,0,-1):
		if j < nums[i]:
			dp[j] = dp[j]
		else:
			dp[j] = max(dp[j],dp[j-nums[i]]+nums[i])

5)举例
[1,3,4]
(1+3+4)/2=4
dp[0] = 0
dp[4] = dp[3]+1 = 1
dp[3] = dp[2]+1 = 1
dp[2] = dp[1]+1 = 1
dp[1] = dp[1]+1 = 1
dp[4] = (max(dp[1]+3),dp[4])=4
dp[3] = (max(dp[0]+3),dp[3])=3
dp[2] = 1
dp[1] = 1
dp[4] = (max(dp[0]+4),dp[4])=4
dp[3] =3
dp[2] = 1
dp[1] = 1
dp[4] = 4
所以存在子集
代码如下:

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

2. 背包最多能装多少问题,即最大值问题,也就是当背包装到不能再装的时候,最多能装多少。
例题:最后一块石头的重量II
在这里插入图片描述
其实这道题可以转换为,将这些石头分为总和最接近的两堆,那么这两堆的差值,就是我们要求的结果。比如[2,7,4,1,8,1]->我们可以将它分成[2,7,1,1]和[4,8],这样的总和差值就为1。所以直接将背包的承重看作是石头的总和/2向下取整,即int(sum(stones)/2)。求能该背包装到不能再装时候的最大值max。max就为其中一堆的重量。这样只要用另一堆的重量:(sum(stones)/2-max)-max即为所求。
1)dp
dp[j]:重量为j的背包所能装入的石头的最大总价值
2)状态转移
dp[j] = max(dp[j-stones[i]]+stones[i],dp[j])
3)初始化
dp[0]=0
4)遍历顺序

for i in range(len(stones)):
	for j in range(sum(stones)/2,stones[i]-1,-1):
		dp[j] = max(dp[j-stones[i]]+stones[i],dp[j])

5)例子
[1,2,3,1]->3
dp[0] = 0
dp[3] = 1
dp[2] = 1
dp[1] = 1
dp[3] = max(dp[1]+2,dp[3])=3
dp[2] = max(dp[0]+2,dp[2])=2
dp[1]=1
dp[3]= max(dp[0]+3,dp[3])=3
dp[2]=2
dp[1]=1
dp[3]=max(dp[2]+1,dp[3])=3
dp[2]=max(dp[1]+1,dp[2])=3
dp[1]=max(dp[0]+1,dp[1])=1
return(sum-dp[1]-dp[1]=1)
代码如下:

class Solution:
    def lastStoneWeightII(self, stones: List[int]) -> int:
        sum_stones = int(sum(stones)/2)
        dp = [0]*(sum_stones+1)
        for i in range(len(stones)):
            for j in range(sum_stones,stones[i]-1,-1):
                dp[j] = max(dp[j],dp[j-stones[i]]+stones[i])
        return(sum(stones)-dp[sum_stones]-dp[sum_stones])

3. 装满背包有多少种方法,即组合问题。
例题:目标和问题
在这里插入图片描述
其实就是达到target有多少种组合。我们可以看一下,设正数和为x,负数和为-y,那么x+y=sum,x-y=target。这样的话x=(sum+target)/2。所以我们只需要看,一个nums里,正数加起来的和能够达到x的种类就可以了。
1)dp
dp[j]:和能够达到j的种数
2)状态转移
其实就是加入i之后能够到达j的个数(dp[j-nums[i]])再加上未加入i之前本来就可以达到j的个数(dp[j])。也就是dp[j]=dp[j-nums[i]]+dp[j]
3)初始化
dp[0]=1
还要看是否(sum+target)%2=1,如果=1,那么说明没有能够达到target的组合,直接返回0。如果target的绝对值大于sum,那也是没有能够达到target的组合的,直接返回0。
4)遍历顺序

for i in range(len(nums)):
	for j in range(x,nums[i]-1,-1):
		dp[j] = dp[j]+dp[j-nums[i]]

5)举例
[1,1,1,1,1] target = 3
dp[0]=1
dp[4]=dp[3]+dp[4]=0
dp[3]=dp[2]+dp[3]=0
dp[2]=dp[1]+dp[2]=0
dp[1]=dp[0]+dp[1]=1

dp[4]=dp[3]+dp[4]=0
dp[3]=dp[2]+dp[3]=0
dp[2]=dp[1]+dp[2]=1
dp[1]=dp[0]+dp[1]=2

dp[4]=dp[3]+dp[4]=0
dp[3]=dp[2]+dp[3]=1
dp[2]=dp[1]+dp[2]=3
dp[1]=dp[0]+dp[1]=3

dp[4]=dp[3]+dp[4]=1
dp[3]=dp[2]+dp[3]=4
dp[2]=dp[1]+dp[2]=6
dp[1]=dp[0]+dp[1]=4

dp[4]=dp[3]+dp[4]=5
dp[3]=dp[2]+dp[3]=10
dp[2]=dp[1]+dp[2]=10
dp[1]=dp[0]+dp[1]=5
return(dp[4]=5)
代码如下:

class Solution:
    def findTargetSumWays(self, nums: List[int], target: int) -> int:
        if (sum(nums)+target) % 2 == 1 or abs(target)>sum(nums):
            return 0
        positive = int((sum(nums)+target)/2)
        dp=[0]*(positive+1)
        dp[0]=1
        for i in range(len(nums)):
            for j in range(positive,nums[i]-1,-1):
                dp[j] = dp[j] + dp[j-nums[i]]
        return(dp[positive])
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
01背包问题是动态规划中的一个经典问题,它的解法也非常经典,下面是我对该问题的动态规划总结。 1. 状态定义 定义一个二维数组dp[i][j],其中i表示当前考虑到第i个物品,j表示当前背包容量为j,dp[i][j]表示在前i个物品中,背包容量为j时的最大价值。 2. 状态转移方程 对于每个物品,我们可以选择将其放入背包,也可以选择不放入背包,因此状态转移方程如下: 如果不将第i个物品放入背包,则 dp[i][j] = dp[i - 1][j] 即前i-1个物品已经在容量为j的背包中的最大价值就是dp[i - 1][j]。 如果将第i个物品放入背包,则 dp[i][j] = dp[i-1][j-w[i]] + v[i] 即前i-1个物品在容量为j-w[i]的背包中的最大价值加上第i个物品的价值v[i]。 最终的状态转移方程为: dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]] + v[i]) 3. 边界条件 当物品数量为0时,dp[0][j]都等于0;当背包容量为0时,dp[i][0]都等于0。 4. 求解最优解 最终的最大价值为dp[n][W],其中n表示物品数量,W表示背包容量。 5. 代码实现 以下是01背包问题的动态规划代码实现,其中w和v分别表示物品的重量和价值,n和W表示物品数量和背包容量: ```python def knapsack(w, v, n, W): dp = [[0] * (W+1) for _ in range(n+1)] for i in range(1, n+1): for j in range(1, W+1): if j < w[i-1]: dp[i][j] = dp[i-1][j] else: dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i-1]] + v[i-1]) return dp[n][W] ```

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值