算法套路十四——动态规划之背包问题：01背包、完全背包及各种变形

news2024/11/24 17:28:55

算法套路十四——动态规划之背包问题：01背包、完全背包及各种变形

算法示例一——0/1背包：

0-1背包:有n个物品，第i个物品的体积为w[i]，价值为v[i]，每个物品至多选一个， 求体积和不超过capacity时的最大价值和，其中i从0开始。

动态规划递归

  1. 递归函数定义：在0/1背包问题中，递归函数dfs需要2个参数，i和c来表示当前考虑的物品和背包的剩余容量，dfs(i, c)代表的是考虑前i个物品，在背包容量为c的情况下能够获得的最大价值。
  2. 状态转移方程：在递归过程中，我们需要依次考虑每个物品，然后采用算法套路十——回溯法之子集型回溯进行选或不选的枚举。
    • 如果不选第i个物品，则为dfs(i-1, c)，即前i-1个物品在背包容量为c的情况下能够获得的最大价值。
    • 如果选第i个物品，则为dfs(i-1, c-w[i]) + v[i]，即前i-1个物品在背包容量为c-w[i]的情况下能够获得的最大价值加上第i个物品的价值v[i]。
    • 最终，dfs(i, c)的值为以上两种情况的较大值，即转移方程为·dfs(i,c) =max (dfs(i- 1,c),dfs(i- 1,c- w[i]) + v[i])
  3. 边界条件：
    • 当i小于0，没有物品选择，此时dfs(i, c)的值为0；或者判断当i==0时，如果背包容量c能够放下第一个物品，则直接返回第一个物品的价值v[0]，否则返回0。
    • 当背包的剩余容量c小于第i个物品的重量w[i]时，无法选择第i个物品，此时dfs(i, c)的值为dfs(i-1, c)。
  4. 所求值：dfs(n-1, capacity)，表示考虑前n个物品，在背包容量为capacity的情况下能够获得的最大价值。
def zero_ one_ knapsack(capacity: int, w: List[int], v: List[int]) -> int:
	n = len(w)
	# python的@cache装饰器可以用来寄存函数对已处理参数的结果，以便遇到相同参数可以直接给出答案。
	@cache
	def dfs(i, c):
		if i<0:
			return 0
		'''
		if i==0:
			return v[0] if c>=w[0] else 0 
		'''
		if c < w[i]:
			return dfs(i-1, c)
		return max(dfs(i-1, c), dfs(i-1, c-w[i]) + v[i])
	return dfs(n-1, capacity)

递归dfs()1:1 转换成迭代递推的dp[][]二维数组

定义一个二维数组dp，其中dp[i][j]表示考虑前i个物品，在背包容量为j的情况下能够获得的最大价值，并使用一个双重循环来遍历所有的物品和背包容量，根据0/1背包问题的状态转移方程 dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]]+v[i]) if j>=w[i] else dp[i-1][j] 来更新dp数组的值。最终，dp[n-1][capacity]的值即为所求的最大价值。

def zero_one_knapsack(capacity: int, w: List[int], v: List[int]) -> int:
    n = len(w)
    #n行capacity + 1列
    dp = [[0] * (capacity + 1) for _ in range(n)]
    for i in range(n):
        for j in range(capacity + 1):
            if i == 0:
                dp[i][j] = v[i] if j >= w[i] else 0
            else:
                if j < w[i]:
                    dp[i][j] = dp[i - 1][j]
                else:
                    dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i]] + v[i])
    return dp[n - 1][capacity]

考虑到数组从0开始，为了数组方便我们可以将代码中所有的i加一，此时状态转移方程为状态转移方程 dp[i+1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]) if j>=w[i] else dp[i+1][j] = dp[i ][j]，这样最后返回结果为dp[n][capacity]，如下所示

def zero_one_knapsack(capacity: int, w: List[int], v: List[int]) -> int:
    n = len(w)
    #n行capacity + 1列
    dp = [[0] * (capacity + 1) for _ in range(n)]
    dp[0][0]=1
    for i in range(n):
        for j in range(capacity + 1):
        	#dp[i+1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]) if j>=w[i] else dp[i+1][j] = dp[i ][j]
            if j < w[i]:
                dp[i+1][j] = dp[i ][j]
            else:
                dp[i+1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i])
    return dp[n][capacity]

空间优化：转换为一维数组

可以将二维数组dp[]转换为一维数组dp[]，此时我们需要使用一个双重循环来遍历所有的物品和背包容量，根据0/1背包问题的状态转移方程来更新dp数组的值。
其实该思路就是算法套路十——回溯法之子集型回溯中的思路二——从答案出发的思路，直接枚举所有选择物品i的情况，即枚举在所有不同容积下选择物品i的情况，并用数组记录，因此我们需要对容积从后往前遍历。
在一维数组下的状态转移方程中，f[j] 表示恰好容量为 j 时的最大或最小价值，但是它只与前 i 个物品有关。因为在状态转移时，对于当前正在考虑的第 i 件物品，假如其体积 w[i] 比当前枚举的体积 j 大，那么该物品就无法放入背包中，因此它应该不会对 f[j] 的结果产生影响。在一维数组中，我们并没有明确保存“选取了哪些物品”，而是只保存了阶段 i（前 i 个物品）和决策 j（背包容量）。在状态转移时，我们始终是以 “前i个物品” 作为暗含条件的。

def zero_one_knapsack(capacity: int, w: List[int], v: List[int]) -> int:
    n = len(w)
    dp = [0] * (capacity + 1) 
    # 遍历每个物品
    for i in range(n):
        # 从后往前遍历，更新 dp 数组，容量j仅仅遍历到能选择当前物品的w[i]，防止数组越界
        for j in range(capacity, w[i]-1, -1):
        	#枚举所有选择物品i的情况，并记录
            dp[j] = max(dp[j], dp[j-w[i]] + v[i])
    # 返回背包容量下的最大价值
    return dp[capacity]

从后往前遍历的原因是为了避免在更新 dp 数组时重复使用同一个物品，且对容积j进行遍历时我们仅仅遍历到能选择当前物品的w[i]。当我们从后往前遍历时，我们确保在计算 dp[j] 时，dp[j-w[i]] 的值是基于不包含当前物品 i 的子问题的解。这样，我们可以确保每个物品只被使用一次。
如果我们从前往后遍历，那么在计算 dp[j] 时，dp[j-w[i]] 的值可能已经包含了物品 i，这样就可能导致物品 i 被重复使用，从而得到错误的结果。

如物品重量：w = [3, 4, 5] 物品价值：v = [30, 50, 60] 背包容量：capacity = 8

首先，我们看一下遍历物品 0 时从前往后遍历的情况：
在这里插入图片描述

从前往后遍历时，我们可以看到 dp[6] 的值为 60，这意味着我们在背包容量为 6 的情况下可以获得总价值为 60 的物品。然而，这是不正确的，因为我们实际上重复使用了物品 0（重量为 3，价值为 30）。

现在，我们看一下遍历物品 0 时从后往前遍历的情况：
在这里插入图片描述
从后往前遍历时，我们可以看到 dp[6] 的值为 30，这是正确的，因为我们只使用了物品 0（重量为 3，价值为 30）一次。
通过这个对比，我们可以看到从后往前遍历可以避免在更新 dp 数组时重复使用同一个物品。

算法示例二——完全背包：

完全背包：N种物品和一个容量为V的背包，每种物品都有无限件可用。第i种物品的体积是v[i]，价值是val[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
0/1背包和完全背包是两种常见的背包问题，它们的主要区别在于每个物品是否可以重复使用。
在0/1背包问题中，每个物品只能使用一次，即要么选择将该物品放入背包中，要么不放入。因此，0/1背包问题也被称为“二进制背包问题”。而在完全背包问题中，每个物品可以使用多次，即可以选择将该物品放入背包中多次。因此，完全背包问题也被称为“多重背包问题”。

动态规划递归

因为每个物品可以使用多次，所以在解决完全背包问题时，我们需要对每个物品进行循环，以便计算每个物品可以使用多少次，所以在选择当前物品i之后还要继续递归是否选择当前物品i，故完全背包的状态转移方程:dp(i,j)=max(dp(i-1,j),dp(i,j-v)+val[i])，这也是与0/1背包的唯一区别，就是在选择物品i之后仍需继续递归物品i

def unbounded_knapsack(capacity: int, w: List[int], v: List[int]) -> int:
	n = len(w)
	# python的@cache装饰器可以用来寄存函数对已处理参数的结果，以便遇到相同参数可以直接给出答案。
	@cache
	def dfs(i, c):
		if i<0:
			return 0
		'''
		if i==0:
			return v[0] if c>=w[0] else 0 
		'''
		if c < w[i]:
			return dfs(i-1, c)
			#与0/1背包的唯一区别，dfs第一个参数仍是i
		return max(dfs(i-1, c), dfs(i, c-w[i]) + v[i])
	return dfs(n-1, capacity)

递归dfs()1:1 转换成迭代递推的dp[][]二维数组

同0/1背包定义一个二维数组dp，其中dp[i][j]表示考虑前i种物品，在背包容量为j的情况下能够获得的最大价值，并使用一个双重循环来遍历所有的物品和背包容量，转移方程 dp[i+1][j] = max(dp[i][j], dp[i+1][j-w[i]] + v[i]) if j>=w[i] else dp[i+1][j] = dp[i][j]来更新dp数组的值。最终，dp[n-1][capacity]的值即为所求的最大价值。

def unbounded_knapsack(capacity: int, w: List[int], v: List[int]) -> int:
    n = len(w)
    dp = [[0] * (capacity + 1) for _ in range(n)]
    for i in range(n):
        for j in range(capacity + 1):
        	#dp[i+1][j] = max(dp[i][j], dp[i+1][j-w[i]] + v[i]) if j>=w[i] else dp[i+1][j] = dp[i][j]
            if j < w[i]:
                dp[i+1][j] = dp[i][j]
            else:
            	#与0/1背包的唯一区别，选择i+1后第一维度仍是i+1
                dp[i+1][j] = max(dp[i][j], dp[i+1][j-w[i]] + v[i])
    return dp[n][capacity]

空间优化：转换为一维数组

与0/1背包类似，完全背包也可以换为一维数组，不过不同的是完全背包一种物品可以选择多次，所以需要从前往后遍历。

def unbounded_knapsack(capacity: int, w: List[int], v: List[int]) -> int:
    n = len(w)
    dp = [0] * (capacity + 1)
    for i in range(n):
        for j in range(w[i], capacity + 1):
       		 #与0/1背包的唯一区别：需要从前往后遍历
            dp[j] = max(dp[j], dp[j-w[i]] + v[i])
    return dp[capacity]

背包问题常见变形

  • 至多装capacity,求方案数/最大价值和
  • 恰好装capacity,求方案数/最大/最小价值和
  • 至少装capacity,求方案数/最小价值和

最大、小值问题一般会回归到 方案数 或 数字个数问题， 一般会使用到 max/min 函数约束答案，此时使用inf 初始化来表示极端情况。 每种方式的数组初始及转移方程如何定义可参考下表，且对于每种问题为什么如此设计初始数组及转移方程经过思考相信可以理解，但做题时仍需具体问题具体分析

问题类型二维初始数组二维转移方程最终结果注意事项一维初始数组一维转移方程
求至多容量j的最大价值dp = [[0]*(capacity+1) for _ in range(n+1)]dp[i+1][j] = max(dp[i][j], dp[i][j-w[i]]+v[i])
if j>=w[i] else
dp[i][j]		dp[n][capacity]外层循环所有的物品 i，内层循环遍历所有的容量 jf = [0] * (capacity+1)f[j] = max(f[j], f[j-w[i]]+v[i])
求恰好为容量j的最大价值dp = [[-inf]*(capacity+1) for _ in range(n+1)];dp[0][0]=0dp[i+1][j] = max(dp[i][j], dp[i][j-w[i]]+v[i])
if j>=w[i] else
dp[i][j]		dp[n][capacity]初始值 dp[0][0] = 0, dp[0][j] = 负无穷 (j != 0)f = [0] + [-inf] * capacityf[j] = max(f[j], f[j-w[i]]+v[i])
求恰好为容量j的最小价值dp = [[inf]*(capacity+1) for _ in range(n+1)];dp[0][0]=0dp[i+1][j] = min(dp[i][j], dp[i][j-w[i]]+v[i])
if j>=w[i] else
dp[i][j]		dp[n][capacity]初始值 dp[0][0] = 0, dp[0][j] = 正无穷 (j != 0)f = [0] + [inf] * capacityf[j] = min(f[j], f[j-w[i]]+v[i])
求至少容量j的最小价值dp = [[inf]*(capacity+1) for _ in range(n+1)];dp[0][0]=0dp[i+1][j] = min(dp[i][j], dp[i][j-w[i]]+v[i])
if j>=w[i] else
dp[i][j]		dp[n][capacity]-f = [0] + [inf] * capacityf[j] = min(f[j], f[j-w[i]]+v[i])
求至多容量j的方案个数dp = [[1] + [0]*capacity for _ in range(n+1)]dp[i+1][j] += dp[i][j-w[i]]
if j>=w[i] else
dp[i+1][j] =dp[i][j]		dp[n][capacity]初始值 dp[i][0] = 1 表示每个容量下至少有一种选法即选择不放任何物品f = [1] + [1] * capacityf[j] += f[j-w[i]]
求恰好为容量j的方案个数dp = [[1] + [0]*capacity for _ in range(n+1)]dp[i+1][j] += dp[i][j-w[i]]
if j>=w[i] else
dp[i+1][j] =dp[i][j]		dp[n][capacity]初始值 dp[i][0] = 1f = [1] + [0] * capacityf[j] += f[j-w[i]]
求至少容量j的方案个数dp = [[1] + [0]*capacity for _ in range(n+1)]dp[i+1][j] += dp[i][j-w[i]]
if j>=w[i] else
dp[i+1][j] =dp[i][j]		dp[n][capacity]-f = [1] + [0] * capacityf[j] += f[j-w[i]]

算法练习一：LeetCode416. 分割等和子集

给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
在这里插入图片描述

如表格所示，求恰好容量的方案数，故二维初始数组为dp = [[1] + [0]*capacity for _ in range(n+1)]，转移方程为dp[i+1][j] += dp[i][j-w[i]] if j>=w[i] else dp[i+1][j] =dp[i][j] dp[n][capacity]，因此我们直接定义zero_one_knapsack_Number_of_schemes()函数来求0/1背包恰好为容量为p的方案数

动态规划

func canPartition(nums []int) bool {
    s:=sum(nums)
    if s%2!=0{
        return false
    }
    p:=s/2
    if zero_one_knapsack_Number_of_schemes(nums,p)==0{
        return false
    }
    return true
}
//二维动态规划数组求恰好容量为p的0/1背包的方案数，w为体积数组
func zero_one_knapsack_Number_of_schemes(w []int,capacity int)int{
    n:=len(w)
    dp:=make([][]int,n+1)
    for i := range dp {
        dp[i] = make([]int, capacity+1)
    }
    dp[0][0] = 1
    for i:=0;i<n;i++{
        for j:=0;j<=capacity;j++{
            if j<w[i]{
                dp[i+1][j]=dp[i][j]
            }else {
                dp[i+1][j]=dp[i][j]+dp[i][j-w[i]]
            }
        }
    }
    return dp[n][capacity]
}
func sum(nums []int)int{
    sum:=0
    for _,x:=range nums{
        sum+=x
    }
    return sum
}

空间优化为一维数组

一维数组初始化为f = [1] + [0] * capacity，转移方程为f[j] += f[j-w[i]]，且定义zero_one_knapsack_Number_of_schemes()函数来求0/1背包恰好为容量为p的方案数

func canPartition(nums []int) bool {
    s:=sum(nums)
    if s%2!=0{
        return false
    }
    p:=s/2
    if one_dimensional_zero_one_knapsack_Number_of_schemes(nums,p)==0{
        return false
    }
    return true
}
//一维动态规划数组求恰好容量为p的0/1背包的方案数
func one_dimensional_zero_one_knapsack_Number_of_schemes(w []int,capacity int)int{
    n:=len(w)
    dp:=make([]int,capacity +1)
    dp[0]=1
    for i:=0;i<n;i++{
    // 从后往前遍历，更新 dp 数组，容量j仅仅遍历到能选择当前物品的w[i]，防止数组越界
        for j:=capacity ;j>=w[i];j--{
        //枚举所有选择nums[i]的情况
            dp[j]+=dp[j-w[i]]
        }
    }
    return dp[capacity]
}
func sum(nums []int)int{
    sum:=0
    for _,x:=range nums{
        sum+=x
    }
    return sum
}

算法练习二：LeetCode494. 目标和

给你一个整数数组 nums 和一个整数 target 。
向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个 表达式 ：
例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1” 。
返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。
在这里插入图片描述

本题看上去与背包问题无关，但实际为0/1背包的变形问题，我们假设数组和为sum，添加+号的数和为p，那么添加-号的和为sum-p，则有p-(sum-p)=target，则2p=target+sum，则题目的要求可以写为选择数组中的数，使其和恰好为(target+sum)/2。

动态规划

如表格所示，求恰好容量的方案数，故二维初始数组为dp = [[1] + [0]*capacity for _ in range(n+1)]，转移方程为dp[i+1][j] += dp[i][j-w[i]] if j>=w[i] else dp[i+1][j] =dp[i][j] dp[n][capacity]，因此我们直接调用上一题中的zero_one_knapsack_Number_of_schemes()函数来求0/1背包恰好为容量为p的方案数

//p
//s-p
//p-s+p=t
//p=(t+s)/2
//等价于和为p的方案数
func findTargetSumWays(nums []int, target int) int {
    target += sum(nums)
    if target<0||target%2!=0{
        return 0
    }
    p:=target/2
    return zero_one_knapsack_Number_of_schemes(nums,p)
}
//二维动态规划数组求恰好容量为p的0/1背包的方案数,w表示体积数组
func zero_one_knapsack_Number_of_schemes(w []int,capacity int)int{
    n:=len(w)
    dp:=make([][]int,n+1)
    for i := range dp {
        dp[i] = make([]int, capacity +1)
    }
    dp[0][0] = 1
    for i:=0;i<n;i++{
        for j:=0;j<=capacity ;j++{
            if j<w [i]{
                dp[i+1][j]=dp[i][j]
            }else {
                dp[i+1][j]=dp[i][j]+dp[i][j-w[i]]
            }
        }
    }
    return dp[n][capacity]
}
func sum(nums []int)int{
    sum:=0
    for _,x:=range nums{
        sum+=x
    }
    return sum
}

空间优化为一维数组

一维数组初始化为f = [1] + [0] * capacity，转移方程为f[j] += f[j-w[i]],直接调用上一题中one_dimensional_zero_one_knapsack_Number_of_schemes()函数来求0/1背包恰好为容量为p的方案数

func findTargetSumWays(nums []int, target int) int {
    target += sum(nums)
    if target<0||target%2!=0{
        return 0
    }
    p:=target/2
    return one_dimensional_zero_one_knapsack_Number_of_schemes(nums,p)
}
//一维动态规划数组求恰好容量为p的0/1背包的方案数
func one_dimensional_zero_one_knapsack_Number_of_schemes(w []int,capacity int)int{
    n:=len(w)
    dp:=make([]int,capacity +1)
    dp[0]=1
    for i:=0;i<n;i++{
    // 从后往前遍历，更新 dp 数组，容量j仅仅遍历到能选择当前物品的w[i]，防止数组越界
        for j:=capacity;j>=w[i];j--{
        //枚举所有选择nums[i]的情况
            dp[j]+=dp[j-w[i]]
        }
    }
    return dp[capacity]
}
func sum(nums []int)int{
    sum:=0
    for _,x:=range nums{
        sum+=x
    }
    return sum
}

算法练习三：LeetCode322. 零钱兑换

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。
计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额，返回 -1 。
你可以认为每种硬币的数量是无限的。
在这里插入图片描述

动态规划

该题中对于不同的硬币可以重复选择，故为完全背包问题的变形。
如表格所示，求恰好金额的最少硬币数，即恰好容量的最小价值，每个物品价值为1，故二维初始数组为dp = [[inf]*(capacity+1) for _ in range(n+1)];dp[0][0]=0，转移方程为dp[i+1][j] = min(dp[i][j], dp[i][j-w[i]]+v[i]) if j>=w[i] else dp[i][j]，本题的所有v[i]都表示物品数为1，故定义unbounded_knapsack_Min_items()求恰好容量的的最少物品数。

func coinChange(coins []int, amount int) int {
    
    ans := unbounded_knapsack_Min_items(coins,amount)
    if ans < math.MaxInt/2 {
        return ans
    }
    return -1
}
func unbounded_knapsack_Min_items(nums []int,capacity int)int{
    n := len(nums)
    dp:=make([][]int,n+1)
    for i:=0;i<=n;i++{
        dp[i]=make([]int, capacity+1)
        for j := range dp[0] {
        dp[i][j] = math.MaxInt / 2 // 除 2 是防止下面 + 1 溢出
        }
    }
    dp[0][0]=0
    for i:=0;i<n;i++{
        for j:=0;j<=capacity;j++{
            if j<nums[i]{
                dp[i+1][j]=dp[i][j]
            }else{
                dp[i+1][j]=min(dp[i][j],dp[i+1][j-nums[i]]+1)
            }
        }
    }
    return dp[n][capacity]
}
func min(a, b int) int { if a > b { return b }; return a }

空间优化为一维数组

由表格可知数组初始化为dp = [0] + [inf] * capacity 转移方程为dp[j] = min(dp[j], dp[j-w[i]]+v[i])，本题的所有v[i]都为1,且定义one_dimensional_unbounded_knapsack_Min_items()来求一维数组下恰好容量的最少物品数

func coinChange(coins []int, amount int) int {
    ans := one_dimensional_unbounded_knapsack_Min_items(coins,amount)
    if ans < math.MaxInt/2 {
        return ans
    }
    return -1
}
func one_dimensional_unbounded_knapsack_Min_items(w []int,capacity int)int{
    n := len(w)
    dp:=make([]int,capacity+1)
    for i:=0;i<=capacity;i++{
        dp[i]=math.MaxInt/2
    }
    dp[0]=0

    for i:=0;i<n;i++{
        for j:=w[i];j<=capacity;j++{
            dp[j]=min(dp[j],dp[j-w[i]]+1)
        }
    }
    return dp[capacity]
}
func min(a, b int) int { if a > b { return b }; return a }

算法练习四：LeetCode279. 完全平方数

给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。1 <= n <= 104
完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。
在这里插入图片描述

动态规划

本题也是对于完全背包的变形，与上题类似，不过其中的物品体积w为1到10000所有的平凡数组成的数组，故直接调用上题的unbounded_knapsack_Min_items()求和为n的最少平方数个数

func numSquares(n int) int {
    w := make([]int, 100)
    for i := 0; i < len(w); i++ {
        w[i] = (i+1) * (i+1)
    }
    return unbounded_knapsack_Min_items(w,n)
}
func unbounded_knapsack_Min_items(nums []int,capacity int)int{
    n := len(nums)
    dp:=make([][]int,n+1)
    for i:=0;i<=n;i++{
        dp[i]=make([]int, capacity+1)
        for j := range dp[0] {
        dp[i][j] = math.MaxInt / 2 // 除 2 是防止下面 + 1 溢出
        }
    }
    dp[0][0]=0
    for i:=0;i<n;i++{
        for j:=0;j<=capacity;j++{
            if j<nums[i]{
                dp[i+1][j]=dp[i][j]
            }else{
                dp[i+1][j]=min(dp[i][j],dp[i+1][j-nums[i]]+1)
            }
        }
    }
    return dp[n][capacity]
}
func min(a, b int) int { if a > b { return b }; return a }

空间优化为一维数组

直接调用上题的one_dimensional_unbounded_knapsack_Min_items()来求一维数组下和为n的最少平方数个数

func numSquares(n int) int {
    w := make([]int, 100)
    for i := 0; i < len(w); i++ {
        w[i] = (i+1) * (i+1)
    }
    return one_dimensional_unbounded_knapsack_Min_items(w,n)
}
func one_dimensional_unbounded_knapsack_Min_items(w []int,capacity int)int{
    n := len(w)
    dp:=make([]int,capacity+1)
    for i:=0;i<=capacity;i++{
        dp[i]=math.MaxInt/2
    }
    dp[0]=0

    for i:=0;i<n;i++{
        for j:=w[i];j<=capacity;j++{
            dp[j]=min(dp[j],dp[j-w[i]]+1)
        }
    }
    return dp[capacity]
}
func min(a, b int) int { if a > b { return b }; return a }

算法练习五：LeetCode518. 零钱兑换 II

给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。
请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。
假设每一种面额的硬币有无限个。
题目数据保证结果符合 32 位带符号整数。在这里插入图片描述

动态规划

本题求和为amount的方案数，可以直接修改练习一中的zero_one_knapsack_Number_of_schemes()为unbounded_knapsack_Number_of_schemes()来解决，且由示例可知，0/1背包改为完全背包仅需在选择物品i之后仍继续递归物品i即可

func change(amount int, coins []int) int {
    return unbounded_knapsack_Number_of_schemes(coins,amount)
}

//二维动态规划数组求恰好容量为p的完全背包的方案数，w为体积数组
func unbounded_knapsack_Number_of_schemes(w []int,capacity int)int{
    n:=len(w)
    dp:=make([][]int,n+1)
    for i := range dp {
        dp[i] = make([]int, capacity+1)
    }
    dp[0][0] = 1
    for i:=0;i<n;i++{
        for j:=0;j<=capacity;j++{
            if j<w[i]{
                dp[i+1][j]=dp[i][j]
            }else {
                //唯一区别
                dp[i+1][j]=dp[i][j]+dp[i+1][j-w[i]]
            }
        }
    }
    return dp[n][capacity]
}
func sum(nums []int)int{
    sum:=0
    for _,x:=range nums{
        sum+=x
    }
    return sum
}

空间优化为一维数组

直接修改练习一中的one_dimensional_zero_one_knapsack_Number_of_schemes()为one_dimensional_unbounded_knapsack_Number_of_schemes()来解决，且由示例可知，0/1背包改为完全背包在用一维数组解决时只需要将遍历循序由从后往前修改为从前往后遍历即可。

func change(amount int, coins []int) int {
    return one_dimensional_unbounded_knapsack_Number_of_schemes(coins,amount)
}
//一维动态规划数组求恰好容量为p的0/1背包的方案数
func one_dimensional_unbounded_knapsack_Number_of_schemes(w []int,capacity int)int{
    n:=len(w)
    dp:=make([]int,capacity +1)
    dp[0]=1
    for i:=0;i<n;i++{
    // 从后往前遍历，更新 dp 数组，容量j仅仅遍历到能选择当前物品的w[i]，防止数组越界
        for j:=w[i] ;j<=capacity;j++{
        //枚举所有选择nums[i]的情况
            dp[j]+=dp[j-w[i]]
        }
    }
    return dp[capacity]
}
func sum(nums []int)int{
    sum:=0
    for _,x:=range nums{
        sum+=x
    }
    return sum
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/480876.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【状态机dp之 股票买卖 题型系列 帮你学懂 状态机】股票买卖（1-6道题）

【状态机dp之 股票买卖 题型系列 帮你学懂 状态机】股票买卖（1-6道题）

股票买卖 股票买卖 1这道题就是求max {ai−aj|j<i} 股票买卖 2股票买卖 3方法一&#xff1a;前后缀拆分dp怎么想到的&#xff1f;方法二&#xff1a;状态机dpf[0/1][i]表示只考虑前i支股票且手头有/没有股票的最大收益 股票买卖 4考虑前 i 天的股票&#xff0c;第 i 天的 决…
阅读更多...
深入浅出C++ ——C++11

深入浅出C++ ——C++11

文章目录 一、C11简介二、列表初始化二、声明四、范围for循环五、STL中的变化六、右值引用和移动语义1. 什么是左值&#xff1f;什么是左值引用&#xff1f;2. 左值引用与右值引用比较3. 右值引用使用场景和意义4. 完美转发 新的类功能默认成员函数类成员变量初始化defaultdele…
阅读更多...
在Unity中制作完整的技能系统（介绍篇）

在Unity中制作完整的技能系统（介绍篇）

1. 系统结构介绍 首先我们需要对技能中的部分进行一个划分。通过观察&#xff0c;我们不难发现&#xff0c;在多个技能中经常有一些相同的内容&#xff08;以下的例子均来自于《英雄联盟》&#xff09;&#xff1a; 火男被动的燃烧一定时间持续伤害和提莫的E技能中毒一定时间…
阅读更多...
【@Param注解】| 台面使用——＞底层原理分析

【@Param注解】| 台面使用——＞底层原理分析

🐇 🐇 😄 🐇 🐇 🐇 🐇 😄 🐇 🐇 🐇 🐇 😄 🐇 🐇 🐇 🐇 😄 🐇 🐇 🐇 🐇 😄 目录 🦁 定义🦁 台面使用🦁 底层原理分析🦁 尾声🐇 🐇 😄 🐇 🐇 🐇 🐇 😄 🐇 🐇 🐇 🐇 😄 🐇 🐇 🐇 🐇 😄…
阅读更多...
【Python】什么是爬虫，爬虫实例

【Python】什么是爬虫，爬虫实例

有s表示加密的访问方式 一、初识爬虫 什么是爬虫 网络爬虫&#xff0c;是一种按照一定规则&#xff0c;自动抓取互联网信息的程序或者脚本。由于互联网数据的多样性和资源的有限性&#xff0c;根据用户需求定向抓取相关网页并分析已成为如今主流的爬取策略爬虫可以做什么 你可以…
阅读更多...
【JAVAEE】JAVA数据库连接（JDBC）

【JAVAEE】JAVA数据库连接（JDBC）

1.什么是JDBC&#xff1f; Java数据库连接&#xff0c;&#xff08;Java Database Connectivity&#xff0c;简称JDBC&#xff09;是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口&#xff0c;提供了诸如查询和更新数据库中数据的方法。JDBC也是Sun Microsyste…
阅读更多...
[优雅的面试]MySQL与Redis双写一致性方案

[优雅的面试]MySQL与Redis双写一致性方案

前言 由于缓存的高并发和高性能已经在各种项目中被广泛使用&#xff0c;在读取缓存这方面基本都是一致的&#xff0c;大概都是按照下图的流程进行操作&#xff1a; 但是在更新缓存方面&#xff0c;是更新完数据库再更新缓存还是直接删除缓存呢&#xff1f;又或者是先删除缓存再…
阅读更多...
TypeError: Object of type ‘Decimal‘ is not JSON serializable

TypeError: Object of type ‘Decimal‘ is not JSON serializable

错误 TypeError: Object of type ‘Decimal’ is not JSON serializable 场景 该错误是在Python3中使用Flask的报错&#xff0c;之前代码是运行正常的&#xff0c;时过几年后再次安装部署&#xff0c;确出现问题。 分析 经过分析发现依旧是版本依赖导致的更新问题。最近在…
阅读更多...
JS手写实现Promise.race

JS手写实现Promise.race

Promise.race() 是一个常见的 JavaScript Promise 方法&#xff0c;它接受一个 Promise 数组作为参数&#xff0c;并返回一个新的 Promise 对象。这个新的 Promise 对象在传入的 Promise 数组中&#xff0c;任意一个 Promise 对象状态变为 fulfilled 或者 rejected&#xff0c;…
阅读更多...
57.网页设计图标实战

57.网页设计图标实战

首先我们需要找一个图标库&#xff0c;本次演示采用的是heroicon ● 之后我们根据需求搜索与之想匹配的图标并复制svg代码 ● 之后将我们的代码复制到我们想要放置图标的地方 ● 当然我们需要使用CSS来修饰一下 .features-icon {stroke: #087f5b;width: 32px;height: 3…
阅读更多...
Python——Pyqt5的数据可视化小工具（完整代码）

Python——Pyqt5的数据可视化小工具（完整代码）

前言 作业要求&#xff1a;【都已经打包放网上了&#xff0c;有缘人需要就自取】 一份报告书&#xff08;在全球变暖背景下碳中和对各国的二氧化碳排放量的影响项目报告书&#xff09; 一份代码 作业包&#xff1a;python数据可视化小工具.zip - 蓝奏云 大一的时候&#xff0c;…
阅读更多...
Java 整合常用docker Api

Java 整合常用docker Api

整合环境&#xff1a; 与docker 版本差异不大&#xff0c;基本都可以 API version: 1.26开放docker api &#xff0c;两种方式 /etc/sysconfig/docker &#xff0c;最后一行添加&#xff1b;开放端口&#xff1a;2375 -H tcp://0.0.0.0:2375systemctl status docker 查询 d…
阅读更多...
vsftpd.conf参数配置

vsftpd.conf参数配置

文章目录 初始vsftdp.conf翻译后需修改参数write_enableYES&#xff08;启用任何形式的FTP写入命令&#xff09;userlist_file/etc/vsftpd.user_list、userlist_enableYES、userlist_denyNOlocal_umask022&#xff08;放开权限&#xff09;chroot_local_userYES&#xff08;限定…
阅读更多...
每日学术速递4.29

每日学术速递4.29

CV - 计算机视觉 | ML - 机器学习 | RL - 强化学习 | NLP 自然语言处理 Subjects: cs.LG 1.A Cookbook of Self-Supervised Learning 标题&#xff1a;自监督学习食谱 作者&#xff1a;Randall Balestriero, Mark Ibrahim, Vlad Sobal, Ari Morcos, Shashank Shekhar, Tom…
阅读更多...
学知识变现，看完这些就够了

学知识变现，看完这些就够了

点击查看【18本知识变现电子书】 100个实用知识点 60万字知识变现精华 资深知识变现教练海哥扛鼎之作 2000多位学员实战经验干货总结 从理论到实践&#xff0c;从思维到实操 教你彻底学透如何知识变财富 .......... 全网最全知识变现知识付费电子教程 资深知识变现教练海…
阅读更多...
Linux线程相关函数：线程的创建、属性、回收、退出、取消

Linux线程相关函数：线程的创建、属性、回收、退出、取消

1. 线程号 进程号在系统中唯一&#xff0c;但线程号只在其所属进程环境中有效。 &#xff08;1&#xff09;pthread_self函数 #include<pthread.h>pthread_t pthread_self(void); /* 功能&#xff1a;获取线程号 返回值&#xff1a;调用此函数线程的ID */ pthread_se…
阅读更多...
【Unity-UGUI控件全面解析】| Panel 容器组件详解

【Unity-UGUI控件全面解析】| Panel 容器组件详解

🎬【Unity-UGUI控件全面解析】| Panel 容器组件详解一、组件介绍二、组件属性面板三、代码操作组件💯总结🎬 博客主页：https://xiaoy.blog.csdn.net 🎥 本文由 呆呆敲代码的小Y 原创，首发于 CSDN🙉 🎄 学习专栏推荐：Unity系统学习专栏 🌲 游戏制作专栏推荐：游…
阅读更多...
2007-2020年上市公司数字经济化指标含原始数据和计算代码（do文档）

2007-2020年上市公司数字经济化指标含原始数据和计算代码（do文档）

2007-2020年上市公司数字经济化指标含原始数据和计算代码&#xff08;do文档&#xff09; 1、时间&#xff1a;2007-2020 2、范围&#xff1a;A股上市公司剔除jin rong行业 3、数据说明&#xff1a;包含计算过程和原始数据 4、参考文献&#xff1a;祁怀锦,数字经济对公司治…
阅读更多...
利用C#实现动态替换桌面快捷方式对应的应用程序

利用C#实现动态替换桌面快捷方式对应的应用程序

公司有一个特殊的业务可能会用到这个&#xff0c;至于什么业务就不展开了。本文的内容作为备用方案。 实现思路&#xff1a; 1 获取当前exe程序运行的全路径 2 获取桌面的所有快捷方式 3 遍历快捷方式&#xff0c;获取快捷键方式对应程序的运行路径&#xff0c;并与当前…
阅读更多...
【开发工具】 今天我要教会你安装Office 2021 RTM 专业增强零售版 你开不开心

【开发工具】 今天我要教会你安装Office 2021 RTM 专业增强零售版 你开不开心

&#x1f680; 个人主页 极客小俊 ✍&#x1f3fb; 作者简介&#xff1a;web开发者、设计师、技术分享博主 &#x1f40b; 希望大家多多支持一下, 我们一起进步&#xff01;&#x1f604; &#x1f3c5; 如果文章对你有帮助的话&#xff0c;欢迎评论 &#x1f4ac;点赞&#x1…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023