Leetcode 第四天动态规划（背包问题） python

又南又难

已于 2023-04-02 22:46:25 修改

阅读量310

点赞数

分类专栏： Leetcode 文章标签： leetcode 动态规划 python

于 2023-03-19 21:25:25 首次发布

本文链接：https://blog.csdn.net/m0_43424109/article/details/129652930

版权

Leetcode 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/last-stone-weight-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

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

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

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

class Solution:
    def lastStoneWeightII(self, stones: List[int]) -> int:
        #将其分为左右相等的两堆
        #dp[j]表示重量为j的石堆
        #递推公式dp[j]=max(dp[j],dp[j-stones[i]]+stones[i])
        target=sum(stones)//2
        dp=[0]*(target+1)
        for i in range(len(stones)):
            for j in range(target,stones[i]-1,-1):
                dp[j]=max(dp[j],dp[j-stones[i]]+stones[i])
        return sum(stones)-dp[target]*2

494 目标和
给你一个整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个表达式：

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

class Solution:
    def findTargetSumWays(self, nums: List[int], target: int) -> int:
        #dp[j]是和为j的组合种类
        #相当于分为两堆，一堆全为正 left，一堆全为负right 满足left-righ=target
        #将right转为left表示，即 left=（sum-target）/2 极为背包容量
        #递推公式 在知道nums[i]的前提下for j in range(left, nums[i]-1,-1) dp[j]=dp[j]+dp[j-num[i]]
        if (sum(nums)-target)%2 ==1:
            return 0
        if target>sum(nums):
            return 0
        left=(sum(nums)-target)//2
        dp=[0]*(left+1)
        dp[0]=1
        for i in range(0,len(nums)):
            for j in range(left, nums[i]-1,-1):
                 dp[j]=dp[j]+dp[j-nums[i]]#*dp[nums[i]]
        return dp[-1]

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

class Solution:
    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        #取这个字符 01的加入是否满足mn
        #dp1[i][j] 表示 装i个0 装j个1 strs的最大子集数
        #字符串的01数量相当于weight 本书的个数相当于value

        dp = [[0] * (n + 1) for _ in range(m + 1)]
        # print(dp)
        for str_ in strs:
            zero_num= str_.count('0')       # 当前字符串中0的数目
            one_num=str_.count('1')  
            for i in range(m,zero_num-1,-1):
                for j in range(n,one_num-1,-1):
                    dp[i][j]=max(dp[i][j],1+dp[i-zero_num][j-one_num])
                # print(dp)
        return dp[m][n]

518. 零钱兑换 II
给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。

请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。
假设每一种面额的硬币有无限个。
题目数据保证结果符合 32 位带符号整数。

class Solution:
    def change(self, amount: int, coins: List[int]) -> int:
        #dp[j] 表示总金额为j元时的组合数
        #递推公式 知道某一个coins[i] for i in (len(coins)) dp[j]=dp[j]+dp[j-coins[i]]
        #初始化
        dp=[0]*(amount+1)
        dp[0]=1
        for i in range(len(coins)):
            for j in range(coins[i],amount+1):
                dp[j]=dp[j]+dp[j-coins[i]]
           
        return dp[amount]

377. 组合总和 Ⅳ
给你一个由不同整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。

题目数据保证答案符合 32 位整数范围。

class Solution:
    def combinationSum4(self, nums: List[int], target: int) -> int:
        #dp[j]表示和为j的组合个数
        #根据给出的示例 前后顺序不同的视为不同组合 所以先遍历背包，再遍历物品
        dp=[0]*(target+1)
        dp[0]=1
        for j in range(0,target+1):
            for i in range(len(nums)):
                if j>=nums[i]:
                    dp[j]=dp[j]+dp[j-nums[i]]
        return dp[target]

70 爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

class Solution:
    def climbStairs(self, n: int) -> int:
        #dp[i]表示爬到第i阶梯的方法总数
        if n==1:
            return 1
        dp1=1
        dp2=1
        #dp2=2
        
        for i in range(2,n+1):
            dp=dp1+dp2
            dp1=dp2
            dp2=dp
        return dp

#完全零一背包解决
        dp=[0]*(n+1)
        dp[0]=1
        if n==1:
             return 1
        for i in range(0,n+1):
            for j in [1,2]:
                dp[i]=dp[i]+dp[i-j]
        return dp[n]

322. 零钱兑换
给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount ，表示总金额。
计算并返回可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1 。
你可以认为每种硬币的数量是无限的。

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        #dp[j]表示凑成总额j所需最少金币的数量
        #递推公式for j in range(coin[i],amount+1) dp[j]=min(dp[j],dp[j-coins[i]])
        dp=[10001]*(amount+1)
        dp[0]=0
        for i in range(0,len(coins)):
            for j in range(coins[i],amount+1):
                if (dp[j-coins[i]]!=10001):
                    dp[j]=min(dp[j],dp[j-coins[i]]+1)
        if dp[amount]==10001:
            return -1
        return dp[amount]

279. 完全平方数
给你一个整数 n ，返回和为 n 的完全平方数的最少数量。

完全平方数是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。

class Solution:
    def numSquares(self, n: int) -> int:
        #dp[j] 表示j的完全平方数的最少数量
        # 递推公式dp[j]=min(dp[j],dp[j-i*i]+1)
        dp=[10001]*(n+1)
        dp[0]=0
        
        for i in range(1,int(sqrt(n))+1):
            for j in range(1,n+1):
                if j-i*i>=0:
                    dp[j]=min(dp[j],dp[j-i*i]+1)

        return dp[n]

139 单词拆分
给你一个字符串 s 和一个字符串列表 wordDict 作为字典。请你判断是否可以利用字典中出现的单词拼接出 s 。

注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
        #dp[i] 表示此时拼接的长度i字符串可以分割 输出True
        
        dp=[False]*(len(s)+1)
        dp[0]=True
        for i in range(len(s)):
            for j in range(i+1,len(s)+1):
                word=s[i:j]
                if word in wordDict and dp[i]==True: 
                    # i到j段字符在字典里以及s中前i位字符在字典里
                    dp[j]=True

        return dp[-1]