[Leetcode] 买卖股票合集(动态规划)

这篇具有很好参考价值的文章主要介绍了[Leetcode] 买卖股票合集(动态规划)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

写完这套题,再搞一台时光机,财务自由不是梦(Doge)

==================================

相关题目链接

121 买卖股票的最佳时机

122 买卖股票的最佳时机 II

123 买卖股票的最佳时机 III

188 买卖股票的最佳时机 IV

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

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

  1. 买卖股票的最佳时机(仅一次交易)

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

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

示例 1:
输入:[7,1,5,3,6,4]
输出:5
解释:在第 2 天(股票价格 = 1)的时候买入,在第 5 天(股票价格 = 6)的时候卖出,最大利润 = 6-1 = 5 。

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

分析

遍历每一天。用变量 minprice 记录已遍历天数的最小股价,初始值为第一天股价;

同时记录每天可以得到的最大利润 maxprofit,即前一天的最大利润 和(今日股价 - 历史最小值 minprice)的较大者,初始值为0。返回最后一天的maxprofit。

说明:下述动态规划只保存了全区间极值,没有用列表保存每天的极值

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

        for price in prices:
            minprice = min(minprice,price)
            maxprofit = max(maxprofit,price-minprice)
        
        return maxprofit

2. 买卖股票的最佳时机(可多次交易)

给你一个整数数组 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 。总利润为 4 + 3 = 7 。

示例 2:
输入:prices = [1,2,3,4,5]
输出:4
解释:在第 1 天(股票价格 = 1)的时候买入,在第 5 天 (股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。 总利润为 4 。

示例 3:
输入:prices = [7,6,4,3,1]
输出:0
解释:在这种情况下, 交易无法获得正利润,所以不参与交易可以获得最大利润,最大利润为 0 。

方法一:所有上坡阶段求和

标志 flag 记录是否持有股票;

buy 和 sale 记录当前持有股票的交易价格,如果当前不持有股票则为0

遍历每日股价,每次买入股票后,更新buy、sale(持续更新)和flag ;

每次卖出股票后,更新buy、sale 和 flag(均为0);

最后一天需要检查 是否持有股票,持有需卖出

flag

ACTION

flag 更新

buy更新

sale更新

prices[i+1] > prices[i]

0

买入

1

prices[i]

prices[i+1]

prices[i+1] <= prices[i]

1

卖出

0

0

0

prices[i+1] > prices[i]

1

prices[i+1]

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        # flag 标记是否持有股票
        flag = 0
        # buy 记录当前持有股票的买入价格
        buy = 0
        # sale 记录当前股票价格,作为暂时的卖出价格
        sale = 0
        sum = 0
        for i in range(len(prices) - 1):
            #如果当前不持有股票,次日股价比今日高,买入股票(更新买入价格),记录次日股价,更新flag标志 持有
            if prices[i+1] > prices[i] and not flag:
                buy = prices[i]
                sale = prices[i+1]
                flag = 1
            #持有股票 且 次日股价不高于今日股价 --> 卖出股票,清空股票买卖价格,更新flag标志 不持有
            elif prices[i+1] <= prices[i] and flag:
                sum = sum + (sale - buy)
                buy = 0
                sale = 0
                flag = 0 
            #持有股票 且 次日股价高于今日股价 --> 继续持有股票,更新卖出价格    
            elif prices[i+1] > prices[i] and flag:
                sale = prices[i+1]
        
        if flag == 1:
            sum = sum + (sale - buy)
        return sum

方法二:贪心

每天都买卖股票(连续持有可以看作当天卖出后再买入),卖出如果收益为正就加入总和

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        sum = 0
        for i in range(1,n):
            tmp = prices[i] - prices[i-1]
            if tmp > 0:
                sum += tmp
        return sum

方法三:动态规划

每天有两种状态,收盘后持有或不持有股票;

初始化一个 n x 2的二维数组 dp,求第 0~ n-1 天 持有 和 不持有股票的最大收入;

第n-1 天如果持有股票,卖出一定比继续持有收益大,所以最后返回第n-1天不持有股票的最大收入

dp[i][0] 代表第i天收盘后不持有股票的最大收益 --> 前日不持有今日无操作、前日持有今日卖出

dp[i][1] 代表第i天收盘后持有股票的最大收益 --> 前日已持有今日无操作 、前日不持有今日买入

初始状态,第一天不持有股票最大收益为0;持有即买入一股,最大收益为 -prices[0]

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        dp= [[0,0]] * 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[n-1][0]

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

给定一个整数数组 prices,其中 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

示例 2:
输入:prices = [1,3,7,5,10,3], fee = 3
输出:6

使用动态规划,和上述题2 一样,多了一个手续费,买入时算在开销里

class Solution:
    def maxProfit(self, prices: List[int], fee: int) -> int:
        n = len(prices)
        dp= [[0,0]] * n
        dp[0][0] = 0
        dp[0][1] = -prices[0]-fee

        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]-fee)
        return dp[n-1][0]

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

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

设计一个算法计算出最大利润。在满足以下约束条件下,你可以尽可能地完成更多的交易(多次买卖一支股票): 卖出股票后,你无法在第二天买入股票 (即冷冻期为 1 天)。

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

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

示例 2:
输入: prices = [1]
输出: 0

动态规划分析

每天有三种状态,收盘后股票持有、不持有(在冷冻期)、不持有(不在冷冻期)

初始化一个 n x 3的二维数组 dp,求第 0~ n-1 天 上述三种状态的最大收入;

说明:如果第i天有卖出,则收盘后进入冷冻期,第i+1天不能买入,我们把这个冷冻期的状态记在第i天

dp[i][0] 代表第i天收盘后不持有股票、且不在冷冻期的最大收益

收盘后不在冷冻期 ==> 今日没有卖出股票

+收盘后不持有股票 ==> 前日就不持有股票(前日在 或 不在冷冻期)

状态转移方程:dp[i][0] = max(dp[i-1][0], dp[i-1][1])

dp[i][1] 代表第i天收盘后不持有股票、且在冷冻期的最大收益

收盘后在冷冻期 ==> 今日卖出股票

+收盘后不持有股票 ==> 昨日持有股票 且 今日卖出股票

状态转移方程:dp[i][1] = dp[i-1][2] + prices[i]

dp[i][2] 代表第i天收盘时持有股票的最大收益

收盘时持有股票 ==> 昨日已经持有股票 或 昨日不持有不在冷冻期、今日买入

状态转移方程:dp[i][2] = max(dp[i-1][2], dp[i-1][0] - prices[i])

初始状态:

dp[0][0] = 0 #第一天不持有股票最大收益为0

dp[0][1] = 0 #第一天不持有股票最大收益为0

dp[0][2] = -prices[0] #第一天持有即买入一股,最大收益为 -prices[0]

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        if n == 1:
            return 0
        #dp= [[0,0,0]] * n
        dp= [[0] * 3  for _ in range(n)]
       
        #dp[0][0] = 0
        #dp[0][1] = 0
        dp[0][2] = -prices[0]
        # 1+ (n-1)行
        #dp = [[0, 0, -prices[0]]] + [[0] * 3 for _ in range(n - 1)]
        for i in range(1,n):
            #不持有股票,且不在冷冻期的最大收益
            dp[i][0] = max(dp[i-1][0], dp[i-1][1])
            #不持有股票,且在冷冻期的最大收益
            dp[i][1] = dp[i-1][2] + prices[i]
            #持有股票的最大收益
            dp[i][2] = max(dp[i-1][2], dp[i-1][0] - prices[i])

        return max(dp[n-1][0],dp[n-1][1])

5. 买卖股票的最佳时机(最多可以完成两笔交易)

给定一个数组,它的第 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 。

示例 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。

示例 4:
输入:prices = [1]
输出:0

方法一:动态规划

每天有五种状态,初始化一个 n x 5的二维数组 dp,求第 0~ n-1 天下述五种状态的最大收入

dp[i][0] 收盘后不持有股票,未交易过的最大收益 --> 0

dp[i][1] 收盘后是首次持有股票的最大收益 --> 昨天同状态,或前序状态 + 今日为首次买入

dp[i][2] 收盘后不持有股票,已交易过一次的最大收益 --> 昨天同状态,或前序状态 + 今日为首次卖出

dp[i][3] 收盘后是第二次持有股票的最大收益 --> 昨天同状态,或前序状态 + 今日为二次买入

dp[i][4] 收盘后不持有股票,已交易过两次的最大收益 --> 昨天同状态,或前序状态 + 今日为二次卖出

初始状态:

dp[0][0],dp[0][2],dp[0][4] 归为第一天不持有股票的情况,最大收益为0

dp[0][1],dp[0][3] 归为第一天持有股票的情况,最大收益为 -prices[0]

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

        #dp[i][0] 不持有股票,未交易过的最大收益
        #dp[i][1] 首次持有股票状态的最大收益
        #dp[i][2] 不持有股票,已交易过一次的最大收益
        #dp[i][3] 第二次持有股票状态的最大收益
        #dp[i][4] 不持有股票,已交易过两次的最大收益
        dp[0][1] = -prices[0]
        dp[0][3] = -prices[0]
        if n == 1:
            return 0
        for i in range(1,n):
            dp[i][0] = 0 
            dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i])
            dp[i][2] = max(dp[i-1][2], dp[i-1][1] + prices[i])
            dp[i][3] = max(dp[i-1][3], dp[i-1][2] - prices[i])
            dp[i][4] = max(dp[i-1][4], dp[i-1][3] + prices[i])
        
        return max(dp[n-1][0], dp[n-1][2], dp[n-1][4])

方法二:遍历的同时分为两个区间动态规划(运行超时)

将prices分为两个区间,各自找到两个区间一次交易的最大值(使用上述题1的动态规划方法),相加即为当前区间分段方法的最大收益。遍历每种区间分段的最大值,但是这样提交超出了时间限制。

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        maxProfit = 0
        # i 为分割点,在0~n-1范围遍历
        for i in range(n):
            maxProfit1, maxProfit2 = 0, 0
            #左区间右区间各自遍历求最大收益
            #如果i=0,只执行右区间的遍历;如果i=n-1,只执行左区间的遍历,这两种情况都对应只交易一次
            if i > 0:
                minPrice1 = 10**6
                for j in range(i):
                    minPrice1 = min(minPrice1,prices[j])
                    maxProfit1  = max(maxProfit1 ,prices[j] - minPrice1)
            if i < n-1:
                minPrice2 = 10**6
                for k in range(i,n):
                    minPrice2 = min(minPrice2,prices[k])
                    maxProfit2  = max(maxProfit2 ,prices[k] - minPrice2)
            maxProfit = max(maxProfit, maxProfit1 + maxProfit2)
        return maxProfit

方法三:从两端各自动态规划求最大收益

从prices左侧开始动态规划找每日收益最大值

从prices右侧开始动态规划找每日收益最小值(高买低卖,反过来就是低买高卖)

得到两个列表,前者减后者就是按天的最大值列表,该列表最大值即为所求

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

        dpR[n-1] = 0
        maxVal = prices[-1]
        for j in list(range(1,n))[::-1]:               
            maxVal = max(maxVal,prices[j])
            dpR[j-1] = min(dpR[j],prices[j-1]-maxVal)

        maxProfit = 0
        for i in range(n):
            maxProfit = max(maxProfit,dp[i] - dpR[i])

        return maxProfit

6. 买卖股票的最佳时机(最多可以完成k笔交易)

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

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

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

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

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

其实就是将上述题5一般化,使用动态规划

两笔交易将prices分为五个区间 --> k笔交易将prices分为2k+1个区间,每天有2k+1种状态

初始化一个 n x (2k+1) 的二维数组 dp,求第 0~ n-1 天下述2k+1种状态的最大收入

dp[i][0] 收盘后不持有股票,未交易过的最大收益 --> 0

dp[i][1] 收盘后是首次持有股票的最大收益 --> 昨天同状态,或前序状态 + 今日为首次买入

dp[i][2] 收盘后不持有股票,已交易过一次的最大收益 --> 昨天同状态,或前序状态 + 今日为首次卖出

……

dp[i][2*k-1] 收盘后是第二次持有股票的最大收益 --> 昨天同状态,或前序状态 + 今日为第k次买入

dp[i][2*k] 收盘后不持有股票,已交易过两次的最大收益 --> 昨天同状态,或前序状态 + 今日为k次卖出

状态转移方程一般化:

j为奇数,收盘后持有 --> 昨日持有 或 昨日不持有、今日买入

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

j为偶数,收盘后不持有 --> 昨日不持有 或 昨日持有、今日卖出

dp[i][j] = max(dp[i-1][j], dp[i-1][j-1] + prices[i])

初始状态:

dp[0][0],dp[0][2] ... dp[0][2*k] 归为第一天不持有股票的情况,最大收益为0

dp[0][1],dp[0][3]... dp[0][2*k-1] 归为第一天持有股票的情况,最大收益为 -prices[0]文章来源地址https://www.toymoban.com/news/detail-415558.html

class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:
        n = len(prices)
        if n == 1:
            return 0

        dpLine0 = [ -prices[0] if x%2 == 1 else 0 for x in range(2*k+1) ] 

        dp = [dpLine0] + [[0]*(2*k+1) for _ in range(n-1)]
        
        #dp[i][0] 不持有股票,未交易过的最大收益
        #dp[i][1] 首次持有股票状态的最大收益
        #dp[i][2] 不持有股票,已交易过一次的最大收益
        #dp[i][3] 第二次持有股票状态的最大收益
        #dp[i][4] 不持有股票,已交易过两次的最大收益
        #...

        for i in range(1,n):
            dp[i][0] = 0 
            for j in range(1,2*k+1):
                dp[i][j] = max(dp[i-1][j], dp[i-1][j-1] - prices[i]) if j%2 == 1 else max(dp[i-1][j], dp[i-1][j-1] + prices[i])

        return dp[n-1][2*k]
        #return max(dp[n-1])

到了这里,关于[Leetcode] 买卖股票合集(动态规划)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【LeetCode动态规划#12】详解买卖股票I~IV,经典dp题型

    力扣题目链接(opens new window) 给定一个数组 prices ,它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。 你只能选择 某一天 买入这只股票,并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。 返回你可以从这笔交易中获取的最

    2023年04月24日
    浏览(53)
  • 【LeetCode动态规划#13】买卖股票含冷冻期(状态众多,比较繁琐)、含手续费

    力扣题目链接(opens new window) 给定一个整数数组,其中第 i 个元素代表了第 i 天的股票价格 。 设计一个算法计算出最大利润。在满足以下约束条件下,你可以尽可能地完成更多的交易(多次买卖一支股票): 你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)

    2023年04月25日
    浏览(46)
  • 算法[动态规划]---买卖股票最佳时机

    1、题目: 给你一个整数数组 prices,其中 prices[i] 表示某支股票第 i 天的价格。 在每一天,你可以决定是否购买和/或出售股票。你在任何时候最多只能持一股股票。你也可以先购买,然后在同一天出售。 返回你能获得的最大利润 。 2、 分析特点: 题目要求:在任何时候最多

    2024年02月09日
    浏览(40)
  • 动态规划--买卖股票含冷冻期309

            这道题很明显下一天的利润需要由上一天的状态推导出来,所以这是很明显的动态规划问题         普通的股票问题有两种状态:持有股票的利润,不持有股票的利润,但这道题有一个冷冻期,使得这道题有4种状态:         1、 持有股票的利润 ;         

    2024年04月28日
    浏览(33)
  • 动态规划——买卖股票的最佳时机系列题

    买卖股票有一系列题目 以下是我找出它们之间的区别: 第一题,只能买一次,从最低价入手,最高价卖出 第二题,可以买无数次,但买了之后,必须卖出之后,再来重新买入,再卖出。 第三题,只能买两次,但买了之后,必须卖出之后,再来重新买入,再卖出。 第四题,

    2024年01月17日
    浏览(49)
  • 动态规划(day11)买卖股票问题进阶

    目录 123.买卖股票的最佳时机III 看到题目的第一想法                看到代码随想录之后的想法 自己实现过程中遇到的困难 188.买卖股票的最佳时机IV 看到题目的第一想法                看到代码随想录之后的想法 自己实现过程中遇到的困难 力扣题目链接(opens new windo

    2024年01月21日
    浏览(61)
  • day49-动态规划10-买卖股票问题

    但是利用其他思路只能解决具体场景下的问题,并不能解决通用的一些问题。 dp[i][0] :表示第i天持有该股票的最大收益, dp[i][1] 表示第i天不持有该股票的最大收益。需要注意的是第i天的情况是什么样,并不是表示第i天就卖出了这只股票,而是表示 递推公式: dp[i][0] 第一

    2024年02月08日
    浏览(39)
  • 动态规划——买卖股票的最佳时机系列题Ⅱ

    这一期是和上一期是连着的,包含的题目如下: 这三个题目所需要的思路是很相近的,先给出第一个的题目。 给定一个数组,它的第 i 个元素是一支给定的股票在第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。 注意:你不能同时

    2024年01月19日
    浏览(41)
  • 【学会动态规划】买卖股票的最佳时机 IV(18)

    目录 动态规划怎么学? 1. 题目解析 2. 算法原理 1. 状态表示 2. 状态转移方程 3. 初始化 4. 填表顺序 5. 返回值 3. 代码编写 写在最后: 学习一个算法没有捷径,更何况是学习动态规划, 跟我一起刷动态规划算法题,一起学会动态规划! 题目链接:188. 买卖股票的最佳时机 IV

    2024年02月13日
    浏览(39)
  • 【学会动态规划】最佳买卖股票时机含冷冻期(15)

    目录 动态规划怎么学? 1. 题目解析 2. 算法原理 1. 状态表示 2. 状态转移方程 3. 初始化 4. 填表顺序 5. 返回值 3. 代码编写 写在最后: 学习一个算法没有捷径,更何况是学习动态规划, 跟我一起刷动态规划算法题,一起学会动态规划! 题目链接:309. 最佳买卖股票时机含冷冻

    2024年02月14日
    浏览(51)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包