【leetcode总结】解析dp股票系列:)

最新推荐文章于 2024-04-02 22:46:18 发布

sdbhewfoqi

最新推荐文章于 2024-04-02 22:46:18 发布

阅读量215

点赞数

分类专栏：数据结构 leetcode解题记录

本文链接：https://blog.csdn.net/weixin_31866177/article/details/119798636

版权

leetcode解题记录同时被 2 个专栏收录

148 篇文章 12 订阅

订阅专栏

数据结构

27 篇文章 2 订阅

订阅专栏

121. 买卖股票的最佳时机（easy）（只能买卖一次股票，求最大利润）

122. 买卖股票的最佳时机 II（easy）（可以买卖多次股票，求最大利润）

309. 最佳买卖股票时机含冷冻期（middle）（可以买卖多次股票，但是卖出之后有一天冷冻期，求最大利润）

714. 买卖股票的最佳时机含手续费（middle）（可以买卖多次股票，但是交易股票有手续费，求最大利润）

901. 股票价格跨度（middle）（单调栈）

123. 买卖股票的最佳时机 III（hard）（可以买卖 2 次股票，求最大利润）

188. 买卖股票的最佳时机 IV（hard）（可以买卖 <=k 次股票，求最大利润）

0：持有现金，买入股票需要减钱，需要减手续费；
1：持有股票，卖出股票需要加钱；
return dp[][][0]，最后都是一个持有现金的状态。

dp[ i ][ j ][ flag ]

i 表示第i个交易日，也就是prices的第i个节点。
j 是买入的次数，也就是记录交易次数（这里不是卖出）。
flag 是是否持有股票的标志，持有为1，没有0。

节点0， 1入度各为2（箭头指向节点次数）代表了要到达节点0， 1各有两种方法，两种方法取收益最大值，可以写出状态转换方程：
dp[i][j][0] = max(dp[i - 1][j][0], dp[i - 1][j][1] + prices[i])
dp[i][j][1] = max(dp[i - 1][j][1], dp[i - 1][j - 1][0] - prices[i])
所有题目都是以这个转换方程做改变。

关于边界状态：

1、边界状态，因为方程中有i - 1，第一个i - 1为-1，所以我们可以直接用初始化dp的最后一位dp[-1]存点东西而已，因为初始dp中元素全是0，所以我们只需要找出不可能的初始状态，给它赋值-float('inf')，也就是负无穷。

这里dp[-1][k][1],这种无论k是什么，在-1是未开始的状态，你股票就持有了j = 1，这种全是负无穷。
还有dp[i][0][1]，交易次数是0，你股票是持有状态，这种也都是负无穷。在考虑交易次数的题中，需要这个边界条件。

2、为什么交易次数计数，只能是买入，不能是卖？其实都是可以的，只是边界条件变了，这里直接用买入做交易次数标记条件，就不多想了。

121. 买卖股票的最佳时机（easy）（只能买卖一次股票，求最大利润）

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。你只能选择某一天买入这只股票，并选择在未来的某一个不同的日子卖出该股票。设计一个算法来计算你所能获取的最大利润。（只能买卖一次股票，求最大利润）

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

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

"""
middle 一维dp
2021-07-19
https://leetcode-cn.com/problems/gu-piao-de-zui-da-li-run-lcof/solution/mian-shi-ti-63-gu-piao-de-zui-da-li-run-dong-tai-2/
"""
# dp[i] 为 第i天卖出的最大利润
# 扩展可以交易两次（买卖算一次交易）求最大值
class Solution:
    def maxProfit(self, prices):
        if not prices:return 0
        dp = [0 for _ in range(len(prices))]
        cost = prices[0]
        for i in range(1, len(prices)):
            cost = min(cost, prices[i])
            dp[i] = max(dp[i-1], prices[i]-min(cost, prices[i]))
        return max(dp)

空间优化

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        cost, profit = float("+inf"), 0
        for price in prices:
            cost = min(cost, price)
            profit = max(profit, price - cost)
        return profit

如果是该套模板，则为

class Solution(object):
    def maxProfit(self, prices):
        # 在价格最低的时候买入，差价最大的时候卖出
        if len(prices) < 2: return 0
        cost = prices[0]
        profit = 0
        for price in prices:
            cost = min(cost, price) # 找到最低那天的价格
            profit = max(profit, price-cost)
        return profit

    # dp
    # 只要考虑当天买和之前买哪个收益更高，当天卖和之前卖哪个收益更高
    #     dp = [[0, 0] for i in range(len(prices))]
    #     if not prices:return 0
    #     dp[-1][1] = -float("inf")
    #     for i in range(len(prices)):
    #         dp[i][1] = max(dp[i - 1][1], -prices[i])
    #         dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i])
    #     return dp[-1][0]

122. 买卖股票的最佳时机 II（easy）（可以买卖多次股票，求最大利润）

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

（可以买卖多次股票，求最大利润）

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

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/solution/tan-xin-suan-fa-by-liweiwei1419-2/

public class Solution {

    public int maxProfit(int[] prices) {
        int len = prices.length;
        if (len < 2) {
            return 0;
        }

        // 0：持有现金
        // 1：持有股票
        // 状态转移：0 → 1 → 0 → 1 → 0 → 1 → 0
        int[][] dp = new int[len][2];

        dp[0][0] = 0; //持有现金
        dp[0][1] = -prices[0]; //持有股票，第一天买入股票，持有现金数为负

        for (int i = 1; i < len; i++) {
            // 这两行调换顺序也是可以的
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]); //持有现金，股票要卖出
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]); //持有股票，现金要减少
        }
        return dp[len - 1][0];
    }
}

python版

"""
    # 0 持有现金
    # 1 持有股票，只有从第一天开始交易以后才有此状态，没有交易前i<0时，该状态都是不存在-int('inf')
"""
class Solution:
    def maxProfit(self, prices):
        if not prices:return 0
        if len(prices)==1:return 0
        n = len(prices)
        dp = [[0 for _ in range(2)] for _ in range(n)]
        dp[-1][1] = -float("inf")
        for i in range(n):
            # [0]现金状态，从持有股票的状态转来，再加上卖出股票的利润
            dp[i][0] = max(dp[i-1][0], dp[i-1][1]+prices[i])
            # [1]持股状态，从现金状态转来，再减去买入股票的价格
            dp[i][1] = max(dp[i-1][1], dp[i-1][0]-prices[i])
        return dp[-1][0]

    # 贪心做法，每天都可以买卖
    #     sum_num = 0
    #     for i in range(n - 1):
    #         if prices[i] < prices[i + 1]:
    #             sum_num += prices[i + 1] - prices[i]
    #     return sum_num

309. 最佳买卖股票时机含冷冻期（middle）（可以买卖多次股票，但是卖出之后有一天冷冻期，求最大利润）

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

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

（可以买卖多次股票，但是卖出之后有一天冷冻期，求最大利润）

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

class Solution:
    def maxProfit(self, prices):
        if not prices: return 0
        if len(prices) == 1: return 0
        n = len(prices)
        dp = [[0 for _ in range(2)] for _ in range(n)]
        dp[-1][1] = -float('inf')
        dp[-2][1] = -float('inf')
        for i in range(n):
            # 买股票，可以什么都不做，可以从持有现金状态减去附加条件，转为持有股票状态
            # i-2, 因为有一天冷冻期，需要从i-2日的现金状态转移
            dp[i][1] = max(dp[i-1][1], dp[i-2][0]-prices[i])

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

714. 买卖股票的最佳时机含手续费（middle）（可以买卖多次股票，但是交易股票有手续费，求最大利润）

整数 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, fee):
        if not prices: return 0
        n = len(prices)
        dp = [[0 for _ in range(2)] for _ in range(n)]
        # print(dp)
        # dp[0][0] = 0
        # dp[0][1] = -prices[0]-fee
        dp[-1][1] = -float("inf") # 还没有开始交易，不可能持有股票
        # dp[0][1] = -float("inf")
        for i in range(n):
            # 从持有现金的状态，转为持有股票的状态
            dp[i][1] = max(dp[i-1][1], dp[i-1][0]-prices[i]-fee)
            # 从持有股票的状态，转为持有现金的状态
            dp[i][0] = max(dp[i-1][0], dp[i-1][1]+prices[i])
        return dp[-1][0]

901. 股票价格跨度（middle）（单调栈）

考察单调栈

123. 买卖股票的最佳时机 III（hard）（可以买卖 2 次股票，求最大利润）

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

（可以买卖 2 次股票，求最大利润）

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

https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iii/solution/tong-su-yi-dong-de-dong-tai-gui-hua-jie-fa-by-marc/

dp[i][0][1]，交易次数是0，你股票是持有状态，这种也都是负无穷。在考虑交易次数的题中，需要这个边界条件。

"""
    # 0 持有现金
    # 1 持有股票，只有从第一天开始交易以后才有此状态，没有交易前i<0时，该状态都是不存在-int('inf')
"""
class Solution:
    def maxProfit(self, prices):
        if not prices:return 0
        if len(prices)==1:return 0
        n = len(prices)
        dp = [[[0, 0] for _ in range(3)] for _ in range(n)]
        # print(dp)
        for j in range(3): # 存在0\1\2笔交易数状态
            dp[-1][j][1] = -float("inf")
        # 一次都不交易，持有股票也是不存在的状态
        for i in range(n):
            dp[i][0][1] = -float("inf")
        for i in range(n):
            for j in range(1,3):# 最多只能买卖2次
                #
                dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1]+prices[i])
                # [1]，从现金状态买入股票，转为持有股票状态
                # 买入一次，减去一次交易机会
                dp[i][j][1] = max(dp[i-1][j][1], dp[i-1][j-1][0]-prices[i])
        return dp[-1][2][0]

188. 买卖股票的最佳时机 IV（hard）（可以买卖 <=k 次股票，求最大利润）

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

（可以买卖 <=k 次股票，求最大利润）

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

"""
    # 0 持有现金
    # 1 持有股票，只有从第一天开始交易以后才有此状态，没有交易前i<0时，该状态都是不存在-int('inf')
"""
class Solution:
    def maxProfit(self, k, prices):
        if not prices:return 0
        if len(prices)==1:return 0
        n = len(prices)

        # 说明我可以一天买，一天卖，退化成122的贪心做法，可以交易无限次
        if k >= (n // 2):
            sum_num = 0
            for i in range(n - 1):
                if prices[i] < prices[i + 1]:
                    sum_num += prices[i + 1] - prices[i]
            return sum_num

        dp = [[[0, 0] for _ in range(k+1)] for _ in range(n)]
        # print(dp)
        # -1天，没有开始交易，所以持股也是不存在的状态
        for j in range(k+1):
            dp[-1][j][1] = -float("inf")
        # 一次都不交易，持有股票也是不存在的状态
        for i in range(n):
            dp[i][0][1] = -float("inf")
        for i in range(n):
            for j in range(1, k+1):# 最多只能买卖k次
                #
                dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1]+prices[i])
                # [1]，从现金状态买入股票，转为持有股票状态
                # 买入一次，减去一次交易机会
                dp[i][j][1] = max(dp[i-1][j][1], dp[i-1][j-1][0]-prices[i])
        return dp[-1][k][0]

参考：

fucking-algorithm/动态规划系列/团灭股票问题.md

leetcode 买卖股票合集 - 木吉子的文章 - 知乎（主要参考的这一篇，很棒！）

leetcode股票买卖题目汇总

股票问题系列通解（转载翻译）

sdbhewfoqi

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【leetcode总结】解析dp股票系列:)

121. 买卖股票的最佳时机（easy）122. 买卖股票的最佳时机 II（easy）309.最佳买卖股票时机含冷冻期（middle）714.买卖股票的最佳时机含手续费（middle）901.股票价格跨度（middle）fucking-algorithm/动态规划系列/团灭股票问题.mdleetcode 买卖股票合集 - 木吉子的文章 - 知乎leetcode股票买卖题目汇总...
复制链接

扫一扫