算法 第43天 动态规划5

1049 最后一块石头的重量II

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。

def lastStoneWeightII(stones:'List[int]')->int:
	target=sum(stones)//2
	dp=[0]*(target+1)
	for stone in stones:
		for j in range(target,stone-1,-1):
			dp[j]=max(dp[j],dp[j-stone]+stone)
	return sum(stones)-2*dp[-1]

def lastStoneWeightII(stones):
	target=sum(stones)//2
	dp=[[False]*(target+1) for _ in range(len(stones)+1)]# dp[i][j]表示前i块石头能否组成重量j
	for i in range(len(stones)+1):
		dp[i][0]=True
	for i in range(1,len(stones)+1):
		for j in range(1,target+1):
			if stone[i-1]>j: # 当
				dp[i][j]=dp[i-1]dp[j] 
			else:
				dp[i][j]=dp[i-1]dp[j] or dp[i-1]dp[j-stone[i-1]]
	for i in range(target,-1,-1):
		if dp[len(stones)][i]:
			return sum(stones)-2*i

494 目标和

给你一个非负整数数组 nums 和一个整数 target 。

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

思路

加法总和$x$，减法总和$sum-x$，
$x-(sum-x)=target$    $\Rightarrow$    $x=(target+sum)/2$
目标和问题转换为 在nums中选择元素组成 x

# 回溯
def backtracking(candidates,target,total,startIndex,path,result):
	if total==target:
		result.append(path[:])
	for i in range(startIndex,len(candidates)):
		if total+candidates[i]>target:
			break
		total+=candidates[i]
		backtracking(candidates,target,total,i+1,path,result)
		total-=candidates[i]
		path.pop()
def findTargetSumWays(nums:'List[int]',target:int)->int:
	total=sum(nums)
	if total<target or (target+total)%2!=0:
		return 0 
	result=[]
	nums.sort()
	backtracking(nums,(total+targete)//2,0,0,[],result)
	return len(result)


#动态规划
def findTargetSuWays(nums,target):
	total=sum(nums)
	if abs(target)>total:
		return 0
	target_sum=(target+total)//2
	dp=[[0]*(target_sum+1) for _ in range(len(nums)+1)]
	dp[0][0]=1
	for i in range(1,len(nums)+1):
		for j in range(target_sum+1):
			dp[i][j]=dp[i-1][j]
			if j>=nums[i-1]:
				dp[i][j]+=dp[i-1][j-nums[i-1]]
	return dp[len(nums)][target_sum]  

474 一和零

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。
请你找出并返回 strs 的最大子集的长度，该子集中 最多 有 m 个 0 和 n 个 1 。
如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的 子集 。

输入：strs = [“10”, “0001”, “111001”, “1”, “0”], m = 5, n = 3
输出：4
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {“10”,“0001”,“1”,“0”} ，因此答案是 4 。
其他满足题意但较小的子集包括 {“0001”,“1”} 和 {“10”,“1”,“0”} 。{“111001”} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。

def findMaxForm(strs:'List[str]',m:int,n:int)->int:
	dp=[[0]*(n+1) for _ in range(m+1)]  # dp[i][j]表示最多有i个0和j个1的strs的最大子集的大小
	for s in strs:
		zeroNum=s.count('0')
		oneNum=len(s)-zeroNum
		for i in range(m,zeroNum-1,-1): 
			for j in range(n,oneNum-1,-1):
				dp[i][j]=max(dp[i][j],dp[i-zeroNum][j-oneNum]+1)
		return dp[m][n]