动态规划③

最新推荐文章于 2024-05-02 09:31:29 发布

one_zero_one

最新推荐文章于 2024-05-02 09:31:29 发布

阅读量145

点赞数

分类专栏：动态规划

本文链接：https://blog.csdn.net/one_zero_one/article/details/118738089

版权

动态规划专栏收录该内容

7 篇文章 0 订阅

订阅专栏

这篇博客探讨了多个使用动态规划解决股票交易问题的算法，包括寻找乘积最大子数组、最长乘积为正数的子数组、最佳观光组合以及不同限制条件下的买卖股票最佳时机。每个问题都通过示例进行了详细解释。

摘要由CSDN通过智能技术生成

①

152. 乘积最大子数组

给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。

示例 1:

输入: [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。

示例 2:

输入: [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。

# 考虑负数情况，需要一个数组来保存最小值
class Solution:
    def maxProduct(self, nums: List[int]) -> int:
       

        dpmax=[0 for _ in range(len(nums))]
        dpmin=[0 for _ in range(len(nums))]
     
        dpmax[0]=nums[0]
        dpmin[0]=nums[0]


        for i in range(1,len(nums)):
            dpmax[i]=max(nums[i],dpmax[i-1]*nums[i],dpmin[i-1]*nums[i])
            dpmin[i]=min(nums[i],dpmin[i-1]*nums[i],dpmax[i-1]*nums[i])
        # return max(max(dpmax),min(dpmin)) 
        return max(dpmax)

②

1567. 乘积为正数的最长子数组长度

给你一个整数数组 nums ，请你求出乘积为正数的最长子数组的长度。

一个数组的子数组是由原数组中零个或者更多个连续数字组成的数组。

请你返回乘积为正数的最长子数组长度。

示例 1：

输入：nums = [1,-2,-3,4]
输出：4
解释：数组本身乘积就是正数，值为 24 。

示例 2：

输入：nums = [0,1,-2,-3,-4]
输出：3
解释：最长乘积为正数的子数组为 [1,-2,-3] ，乘积为 6 。
注意，我们不能把 0 也包括到子数组中，因为这样乘积为 0 ，不是正数。

示例 3：

输入：nums = [-1,-2,-3,0,1]
输出：2
解释：乘积为正数的最长子数组是 [-1,-2] 或者 [-2,-3] 。

class Solution:
    def getMaxLen(self, nums: List[int]) -> int:
        dpmax=[0]*len(nums)   #正数乘积个数
        dpmin=[0]*len(nums)   #负数乘积个数

        if nums[0]>0:
            dpmax[0]=1
        if nums[0]<0:
            dpmin[0]=1

        for i in range(1,len(nums)):
            if nums[i]>0:
                dpmax[i]=dpmax[i-1]+1
                dpmin[i]=(dpmin[i-1]+1 if dpmin[i-1]>0 else 0 )
            elif nums[i]<0:
                dpmax[i]=(dpmin[i-1]+1 if dpmin[i-1]>0 else 0)
                dpmin[i]=dpmax[i-1]+1
            else:
                dpmin[i]=dpmax[i]=0
        return max(dpmax)

③

1014. 最佳观光组合

给你一个正整数数组 values，其中 values[i] 表示第 i 个观光景点的评分，并且两个景点 i 和 j 之间的距离为 j - i。

一对景点（i < j）组成的观光组合的得分为 values[i] + values[j] + i - j ，也就是景点的评分之和减去它们两者之间的距离。

返回一对观光景点能取得的最高分。

示例 1：

输入：values = [8,1,5,2,6]
输出：11
解释：i = 0, j = 2, values[i] + values[j] + i - j = 8 + 5 + 0 - 2 = 11

示例 2：

输入：values = [1,2]
输出：2

class Solution:
    def maxScoreSightseeingPair(self, values: List[int]) -> int:
       
        # alist=[]
        # dp=[[0]*len(values) for _ in range(len(values)) ]
        
        # for i in range(len(values)):
        #     for j in range(i+1,len(values)):
        #         dp[i][j]=values[i]+values[j]+i-j
        #     alist.append(max(dp[i]))
        # return max(alist)
        maxl=0
        tmp=values[0]+0
        for j in range(1,len(values)):
            maxl=max(maxl,tmp+values[j]-j)
            tmp=max(tmp,values[j]+j)
        return maxl

④

121. 买卖股票的最佳时机剑指 Offer 63. 股票的最大利润

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

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

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：

输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

示例 2：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        m=prices[0]
        dp=[0] *len(prices)
        for i in range(1,len(prices)):
            if prices[i]<m:
                m=prices[i]

            dp[i]=max(dp[i-1],prices[i]-m)
        return max(dp)

⑤

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

难度简单1279

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

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: prices = [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
     随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。

示例 2:

输入: prices = [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
     注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

示例 3:

输入: prices = [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

class Solution:
    def maxProfit(self, prices: List[int]) -> int:

        profit=0
        for i in range(1,len(prices)):
            if prices[i]>prices[i-1]:
                profit+=prices[i]-prices[i-1]
        return profit

⑥

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

难度中等825

给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格。

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

你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

示例:

输入: [1,2,3,0,2]
输出: 3 
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]

我们目前持有一支股票，对应的「累计最大收益」记为 f[i][0]f[i][0]；

我们目前不持有任何股票，并且处于冷冻期中，对应的「累计最大收益」记为 f[i][1]f[i][1]；

我们目前不持有任何股票，并且不处于冷冻期中，对应的「累计最大收益」记为 f[i][2]f[i][2]。

对于 f[i][0]f[i][0]，我们目前持有的这一支股票可以是在第 i-1i−1 天就已经持有的，对应的状态为 f[i-1][0]f[i−1][0]；或者是第 ii 天买入的，那么第 i-1i−1 天就不能持有股票并且不处于冷冻期中，对应的状态为 f[i-1][2]f[i−1][2] 加上买入股票的负收益 {\it prices}[i]prices[i]。因此状态转移方程为：


f[i][0]=max(f[i−1][0],f[i−1][2]−prices[i])

对于 f[i][1]f[i][1]，我们在第 ii 天结束之后处于冷冻期的原因是在当天卖出了股票，那么说明在第 i-1i−1 天时我们必须持有一支股票，对应的状态为 f[i-1][0]f[i−1][0] 加上卖出股票的正收益 {\it prices}[i]prices[i]。因此状态转移方程为：


f[i][1]=f[i−1][0]+prices[i]

对于 f[i][2]f[i][2]，我们在第 ii 天结束之后不持有任何股票并且不处于冷冻期，说明当天没有进行任何操作，即第 i-1i−1 天时不持有任何股票：如果处于冷冻期，对应的状态为 f[i-1][1]f[i−1][1]；如果不处于冷冻期，对应的状态为 f[i-1][2]f[i−1][2]。因此状态转移方程为：


f[i][2]=max(f[i−1][1],f[i−1][2])

这样我们就得到了所有的状态转移方程。如果一共有 nn 天，那么最终的答案即为：

max(f[n−1][0],f[n−1][1],f[n−1][2])

注意到如果在最后一天（第 n-1n−1 天）结束之后，手上仍然持有股票，那么显然是没有任何意义的。因此更加精确地，最终的答案实际上是 f[n-1][1]f[n−1][1] 和 f[n-1][2]f[n−1][2] 中的较大值，即：

max(f[n−1][1],f[n−1][2])

细节
  
f[0][0]=−prices[0]
f[0][1]=0
f[0][2]=0

  class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        dp=[[0,0,0] *len(prices) for _ in range(len(prices))]

        dp[0][0]=-prices[0]


        for i in range(1,len(prices)):
            dp[i][0]=max(dp[i-1][0],dp[i-1][2]-prices[i])
            dp[i][1]=dp[i-1][0]+prices[i]
            dp[i][2]=max(dp[i-1][1],dp[i-1][2])
        return max(dp[-1][1],dp[-1][2])

⑦

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

难度中等512收藏分享切换为英文接收动态反馈

给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格；整数 fee 代表了交易股票的手续费用。

你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

返回获得利润的最大值。

注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

示例 1：

输入：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

定义状态dp[i][0] 表示第 i天交易完后手里没有股票的最大利润，
dp[i][1] 表示第 i天交易完后手里持有一支股票的最大利润（ii 从 00 开始）。

class Solution:
    def maxProfit(self, prices: List[int], fee: int) -> int:
        dp=[[0,0] for _ in range(len(prices))]
        dp[0][1]=-prices[0]

        for i in range(1,len(prices)):
            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 max(dp[-1][0],dp[-1][1])

⑧

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

难度困难822收藏分享切换为英文接收动态反馈

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

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

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入：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:

        dp=[[0,0,0,0,0] for _ in range(len(prices)) ]
        dp[0][0]=0
        dp[0][1]=-prices[0]
        dp[0][3]=-prices[0]  #当天买入卖出

        for i in range(1,len(prices)):
            dp[i][0]=dp[i-1][0]
            dp[i][1]=max(dp[i-1][1],dp[i-1][0]-prices[i])
            dp[i][2]=max(dp[i-1][1]+prices[i],dp[i-1][2])
            dp[i][3]=max(dp[i-1][2]-prices[i],dp[i-1][3])
            dp[i][4]=max(dp[i-1][4],dp[i-1][3]+prices[i])
        return max(dp[-1][0],dp[-1][1],dp[-1][2],dp[-1][3],dp[-1][4])
#②时间复杂度：O(n)O(n)，其中 nn 是数组 \textit{prices}prices 的长度。空间复杂度：O(1)O(1)。
class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        buy1 = buy2 = -prices[0]
        sell1 = sell2 = 0
        for i in range(1, n):
            buy1 = max(buy1, -prices[i])
            sell1 = max(sell1, buy1 + prices[i])
            buy2 = max(buy2, sell1 - prices[i])
            sell2 = max(sell2, buy2 + prices[i])
        return sell2

⑨

188. 买卖股票的最佳时机 IV (代码还有点问题)

难度困难545

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

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

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1：

参考：https://www.bilibili.com/video/BV13v411h7gX?from=search&seid=4096747844393070362

输入：k = 2, prices = [2,4,1]
输出：2
解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2

class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:

        n=len(prices)
        if k>=(n/2):
            profit=0
            for i in range(1,len(prices)):
                if prices[i]>prices[i-1]:
                    profit+=prices[i]-prices[i-1]
            return profit

        dp=[[0]*(n) for _ in range(k+1)]
        for i in range(1,k+1):
            #当前手上有股票，初始情况下第一次交易想持有，只能以第0天的价格买入
            localmax=dp[i-1][0]-prices[0]

            for j in range(1,n):
                #第i比交易后，手上没有股票（要不j-1天没有，要不j卖了）
                dp[i][j]=max(dp[i][j-1],localmax+prices[j])
                # i比交易后持有股
                localmax=max(dp[i-1][j]-prices[j],localmax)
        return max(dp[k][n-1])