数据结构算法刷题：背包问题
整数和是p，负数和是s-p，那么target = p - (s-p)，求出p = (s+t)//2
class Solution:
def findTargetSumWays(self, nums: List[int], target: int) -> int:
target += sum(nums)
if target < 0 or target % 2: #target 一定是偶数而且是大于0
return 0
target = target // 2
n = len(nums)
@cache #cache是将传参和返回记录下来，避免了重复计算
def dfs(i,c):
if i < 0:
return 1 if c == 0 else 0 #如果c小于0，那就没有找到，返回0，c==0返回1
if nums[i] > c: #当前值大于c，不能选
return dfs(i-1,c)
return dfs(i-1,c)+dfs(i-1,c-nums[i]) #返回选或者不选的和
return dfs(n-1,target)
改成递推的形式
class Solution:
def findTargetSumWays(self, nums: List[int], target: int) -> int:
target += sum(nums)
if target < 0 or target % 2:
return 0
target = target // 2
n = len(nums)
dp = [[0]*(target+1) for i in range(n+1)]
dp[0][0] = 1 #初始化
for i,x in enumerate(nums):
for c in range(target+1):
if c < x: #不选
dp[i+1][c] = dp[i][c]
else: #选+不选
dp[i+1][c] = dp[i][c] + dp[i][c-x]
return dp[-1][-1]
class Solution:
def coinChange(self, coins: List[int], amount: int) -> int:
#完全背包，对于完全背包，每次选择之后，还可以继续选。
n = len(coins)
@cache
def dfs(i,c):
if i < 0:
return 0 if c == 0 else inf #如果当前不满足条件就返回无穷
if c < coins[i]: #不选
return dfs(i-1,c)
return min(dfs(i-1,c),dfs(i,c-coins[i])+1) #选的时候不能是i-1，因为选了可以再选
a = dfs(n-1,amount)
return a if a < inf else -1
改成递推的形式
class Solution:
def coinChange(self, coins: List[int], amount: int) -> int:
n = len(coins)
dp = [[inf]*(amount+1) for i in range(n+1)]
dp[0][0] = 0
for i,x in enumerate(coins):
for c in range(amount+1):
if x > c:
dp[i+1][c] = dp[i][c] #不选，往下走
else:
dp[i+1][c] =min(dp[i][c],dp[i+1][c-x]+1) #选了还可以继续选i+1
ans = dp[-1][-1]
return ans if ans < inf else -1
在例题494中，如果是至多是target。那就在边界条件时不需要判断，初始化dp全部为1.
class Solution:
def findTargetSumWays(self, nums: List[int], target: int) -> int:
target += sum(nums)
if target < 0 or target % 2:
return 0
target = target // 2
n = len(nums)
dp = [[1]*(target+1) for i in range(n+1)]
for i,x in enumerate(nums):
for c in range(target+1):
if c < x: #不选
dp[i+1][c] = dp[i][c]
else: #选+不选
dp[i+1][c] = dp[i][c] + dp[i][c-x]
return dp[-1][-1]
class Solution:
def findTargetSumWays(self, nums: List[int], target: int) -> int:
target += sum(nums)
if target < 0 or target % 2: #target 一定是偶数而且是大于0
return 0
target = target // 2
n = len(nums)
@cache #cache是将传参和返回记录下来，避免了重复计算
def dfs(i,c):
if i < 0:
return 1
if nums[i] > c: #当前值大于c，不能选
return dfs(i-1,c)
return dfs(i-1,c)+dfs(i-1,c-nums[i]) #返回选或者不选的和
return dfs(n-1,target)
如果是至少为target，那就是比target大也可以。
class Solution:
def findTargetSumWays(self, nums: List[int], target: int) -> int:
target += sum(nums)
if target < 0 or target % 2: #target 一定是偶数而且是大于0
return 0
target = target // 2
n = len(nums)
@cache #cache是将传参和返回记录下来，避免了重复计算
def dfs(i,c):
if i < 0:
return 1 if c <= 0 else 0
return dfs(i-1,c)+dfs(i-1,c-nums[i]) #不会判断nums[i]>c的情况
return dfs(n-1,target)