LeetCode-Python-121. 买卖股票的最佳时机

最新推荐文章于 2025-05-27 13:15:42 发布

原创最新推荐文章于 2025-05-27 13:15:42 发布 · 3.2k 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#动态规划

Leetcode 同时被 2 个专栏收录

821 篇文章

订阅专栏

Python

664 篇文章

订阅专栏

本文探讨了计算股票交易最大利润的算法，通过三种不同的思路，包括直觉的线性扫描方法、动态规划策略以及进一步优化的单一变量跟踪方法，详细解析了如何在给定的股票价格数组中找到最佳的买卖时机。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。

注意你不能在买入股票前卖出股票。

示例 1:

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

示例 2:

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

第一种思路：

直白的麻瓜解法，线性扫描，如果右侧的最大元素减去当前元素的值大于目前的profit，就把profit刷新。

缺点很慢。

class Solution(object):
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        profit = 0
        for index in range(len(prices)-1):
            sub = max(prices[index+1:]) - prices[index]
            if sub > profit:
                profit = sub
        return profit

第二种思路：

动态规划。

用一个变量minelement记录下左侧的最小值，

当扫描到第i个元素时，如果在这一天卖股票，盈利就是dp[i] = prices[i] - minelement

如果在这一天不卖股票，盈利还是dp[i] = dp[i - 1]

所以 dp[i] = max(dp[i-1], prices[i] - minelement)

class Solution(object):
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        if not prices:
            return 0
        profit = 0
        dp = [0]
        minelement = prices[0]
        for i in range(1, len(prices)):
            minelement = min(minelement, prices[i])
            dp.append(max(dp[i - 1], prices[i] - minelement))
            if dp[-1] > profit:
                profit = dp[-1]
        return profit

下面的写于2019.7.3

class Solution(object):
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
#         dp[i][k][0/1]表示第i天交易次数还剩k手上拿着1或者没拿0股票的状态
        # 比如：
        # dp[2][1][1]表示第二天，还可以交易一次，手上持有股票
        # dp[3][5][0]表示第三天，还可以交易五次，手上没拿股票
        # 求dp[len(prices) - 1][0][0]
        
#         dp[i][k][0] = max(dp[i – 1][k][0], dp[I – 1][k][1] + prices[i]) 
#         上式对应第i天如果还有k次交易次数,并且没有持有股票，可能是前一天就没股票，也可能是前一天持有股票今天卖掉了
#         dp[i][k][1] = max(dp[i - 1][k][1], dp[i - 1][k - 1][0] - prices[i])
#           上式对应前一天就持有股票，或者前一天没持有但是今天买进股票
#         第一题 k = 1

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

#         当i = 0时，
#         dp[0][0] = 0
#         dp[0][1] = -prices[0]
#         当k = 0时，
#           因为交易次数为0，所以盈利为0
        dp = [[0 for _ in range(2)] for _ in range(len(prices))]
        for i, price in enumerate(prices):
            if i == 0:
                dp[0][0] = 0
                dp[0][1] = -price
            else:
                dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i])
                dp[i][1] = max(dp[i - 1][1],  - prices[i])
                
        return dp[len(prices) - 1][0] if prices else 0

第三种思路：

在第二种思路上进一步优化，因为本题只需要返回最后i = n时的最大利润，中间结果是不需要保存的，所以可以不用dp数组记录中间答案，只需保留最大值即可。

class Solution(object):
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        # if not prices:
        #     return 0
        minelement = 2 << 31
        profit = 0
        for i in range(len(prices)):
            minelement = min(minelement, prices[i])
            profit = max(profit, prices[i] - minelement)
        return profit