动态规划（中）

Winfred_Bo

于 2022-05-16 21:53:04 发布

阅读量116

点赞数

文章标签：动态规划 leetcode 算法

本文链接：https://blog.csdn.net/Winfred_Bo/article/details/124789536

版权

确定dp数组（dp table）以及下标的含义
确定递推公式
dp数组如何初始化
确定遍历顺序
举例推导dp数组

以上内容参考及总结参考（leetcode 和代码随想录）：随想录—参考链接

3.打家劫舍（中）

198. 打家劫舍

题目描述：
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
示例 1： 输入：[1,2,3,1] 输出：4 解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。   偷窃到的最高金额 = 1 + 3 = 4 。
示例 2： 输入：[2,7,9,3,1] 输出：12 解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。   偷窃到的最高金额 = 2 + 9 + 1 = 12 。
class Solution:
    def rob(self, nums: List[int]) -> int:
        pre , cur = 0 , 0 
        for num in nums:
            pre , cur = cur , max(pre+num,cur)
        return cur

213. 打家劫舍 II

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。
这道题目和198.打家劫舍 (opens new window)是差不多的，唯一区别就是成环了。
class Solution:
    def rob(self, nums: List[int]) -> int:
        def my_rob(nums):
            pre ,cur = 0 , 0 
            for num in nums:
                pre , cur = cur , max(cur,pre+num)
            return cur 
        return max(my_rob(nums[1:]),my_rob(nums[:-1])) if len(nums)!= 1 else nums[0]

337. 打家劫舍 III

在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。
这个地区只有一个入口，我们称之为“根”。 
除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。
 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。
class Solution:
    def dp(self, root):
        if not root:
            return [0,0]
        l = self.dp(root.left)
        r = self.dp(root.right)
        return [max(l)+max(r) , root.val+l[0]+r[0]]
    def rob(self, root: TreeNode) -> int:
        if not root:
            return 0
        return max(self.dp(root))

4.股票问题（中）

121. 买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
示例 1：
输入：[7,1,5,3,6,4]
输出：5

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        dp = [0]*n
        minprice = prices[0]
        for i in range(1,n):
            minprice = min(minprice , prices[i])
            dp[i] = max(dp[i-1] , prices[i]-minprice)
        return dp[-1]

122. 买卖股票的最佳时机 II

在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。
（多次买卖一支股票）。
返回 你能获得的最大 利润 
输入：prices = [7,1,5,3,6,4]
输出：7

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        dp = [[0] * 2 for _ in range(n)]
        dp[0][0] = 0
        dp[0][1] = -prices[0]
        for i in range(1,n):
            dp[i][0] = max(dp[i-1][0] , dp[i-1][1] + prices[i])
            dp[i][1] = max(dp[i-1][1] , dp[i-1][0] - prices[i])
        return dp[-1][0]

123. 买卖股票的最佳时机 III

设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。
输入：prices = [3,3,5,0,0,3,1,4]
输出：6
解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
     随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。
class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        dp=[ [[0,0,0],[0,0,0]] for i in range(n) ]
        dp[0][0][0] = 0
        dp[0][1][0] = -prices[0]
        dp[0][0][1] = float('-inf') 
        dp[0][0][2] = float('-inf')
        dp[0][1][1] = float('-inf') 
        dp[0][1][2] = float('-inf')
        for i in range(1,n):
            dp[i][0][0] = 0 
            dp[i][1][0] = max(dp[i-1][0][0]-prices[i],dp[i-1][1][0])
            dp[i][0][1] = max(dp[i-1][0][1],dp[i-1][1][0]+prices[i])
            dp[i][0][2] = max(dp[i-1][0][2],dp[i-1][1][1]+prices[i])
            dp[i][1][1] = max(dp[i-1][1][1],dp[i-1][0][1]-prices[i])
            dp[i][1][2] = float('-inf')
        return max(dp[-1][0][1],dp[-1][0][2],0)

188. 买卖股票的最佳时机 IV

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
输入：k = 2, prices = [2,4,1]
输出：2

class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:
        n = len(prices)
        if n == 0:return 0
        dp = [[0]*(2*k + 1) for _ in range(n)]
        for j in range(1,2*k,2):
            dp[0][j] = -prices[0]
        for i in range(1,n):
            for j in range(0,2*k-1,2):
                dp[i][j+1] = max(dp[i-1][j+1] , dp[i-1][j]-prices[i])
                dp[i][j+2] = max(dp[i-1][j+2] , dp[i-1][j+1]+prices[i])
        return dp[-1][-1]

309. 最佳买卖股票时机含冷冻期

给定一个整数数组prices，其中第  prices[i] 表示第 i 天的股票价格 。

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

    卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

输入: prices = [1,2,3,0,2]
输出: 3 
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]
class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        dp = [ [0]*3 for _ in range(n)]
        dp[0][0] = 0
        dp[0][1] = -prices[0]
        dp[0][2] = float('-inf')
        for i in range(1,n):
            dp[i][0] = max(dp[i-1][0] , dp[i-1][2])
            dp[i][1] = max(dp[i-1][1] , dp[i-1][0]-prices[i])
            dp[i][2] = dp[i-1][1] + prices[i]
        return max(dp[n-1][0] , dp[n-1][2])

714. 买卖股票的最佳时机含手续费

给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格 ；整数 fee 代表了交易股票的手续费用。
输入：prices = [1, 3, 2, 8, 4, 9], fee = 2
输出：8
解释：能够达到的最大利润:  
在此处买入 prices[0] = 1
在此处卖出 prices[3] = 8
在此处买入 prices[4] = 4
在此处卖出 prices[5] = 9
总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8

class Solution:
    def maxProfit(self, prices: List[int], fee: int) -> int:
        n = len(prices)
        dp = [[0]*2 for _ in range(n)]
        dp[0][0] = 0
        dp[0][1] = -prices[0]
        for i in range(1,n):
            dp[i][0] = max(dp[i-1][0],dp[i-1][1]+prices[i]-fee)
            dp[i][1] = max(dp[i-1][1],dp[i-1][0]-prices[i])
        return dp[-1][0]