LeetCode123-买卖股票的最佳时机 III

好久没刷LeetCode了

今天上午做了一道题

被折磨的要死

十分尴尬

看来接下来一段时间要经常练了

这东西可不能丢啊

好了，再来推荐一部动画啊

大家看了封面应该很容易猜到了

就是小时候我们经常看的《四驱兄弟》

哈哈哈哈哈，最近一直在看

还是很好看啊，笑得合不拢嘴

被我爸妈知道了，估计又要笑我幼稚鬼了哈哈哈哈哈

---

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

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

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

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

示例 1:

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

示例 2:

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

示例 3:

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

思路：

这道题算是买卖股票的最佳时机题目系列的最难一道题了，它和第122题买卖股票的最佳时机II很相像，唯一的区别就是：在第122题中，交易股票的次数是不限制的，而在此题中确实限制在两次的。正是这两次的限制，导致这道题的难度上升了。如果对第122题不太熟悉的朋友，可以先看看这篇文章。

https://blog.csdn.net/weixin_36431280/article/details/90899007

这道题我尝试了好几种方法，有些方法虽然是超出时间限制了，但我觉得方法还是可以借鉴的，所以想分享出来。

方法一：简单二分法

既然限制次数是两次，那我就可以使用二分法将prices区间分为两段，分别求左右两段区间内一次股票交易获得的最大利润即可。有些读者可能会疑惑：题目限制次数为两次，那么也可能是一次，即只需要一次股票交易就能获得最大利润。但是读者可以好好想想，其实还是能分为两段的，其中一段是最大利润，另一段利润为0即可。大致如下：

而只求一段区间内一次交易获得的最大利润正是第121题干的事儿，对第121题不太熟悉的朋友可以看看我写的这篇文章：

https://blog.csdn.net/weixin_36431280/article/details/90812473

既然之前就写好了方法，那这道题就好办了，只需要一次遍历，不停的划分左右区间就可以求解每次遍历得到的最大值，最后取所有值的最大值即可。

代码如下：

class Solution(object):
    # 本题可采用二分法计算
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        candidate = []
        # 记录出售股票所获得的最大收益
        max_profit = 0
        if len(prices) <= 1:
            return max_profit
        for index in range(len(prices)):
            left = self.single_profit(prices[:index])
            right = self.single_profit(prices[index:])
            max_profit = max(max_profit, left+right)
        return max_profit
            

    # 获取一段区间内完成一笔交易的最大利润
    def single_profit(self, prices):
        # 定义获取的最大利润
        max_profit = 0
        if len(prices) <= 1:
            return max_profit

        # 分别定义股票的最小价格以及最高价格
        min_price = prices[0]
        max_price = 0
        for price in prices:
            max_price = max(max_price, price-min_price)
            min_price = min(min_price, price)
        return max_price


if __name__ == "__main__":
    prices = [3,3,5,0,0,3,1,4]
    max_profit = Solution().maxProfit(prices)
    print(max_profit)

思路特别清新，但是跑起来就是超出时间限制，让我特别头疼。

方法二：进阶版二分法

其实也不算是严格的二分法，就是分两次遍历。第一次遍历是从头至尾遍历，记录每个区间内一次股票交易获得最大利润，并保存至一个数组内，方便第二轮遍历取值，这就有点像动态规划内的思想了，此处就是可以节省时间了。第二次遍历就是从尾向头遍历，选出相应坐标右边区间内一次交易的最大值，左边区间交易的最大值就可以直接从第一次遍历得到的数组获取，两者相加，即可得到两次交易的最大值。

代码如下：

class Solution(object):
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        min_price, total_max_profit = float('inf'), 0
        # 记录顺序区间内每个坐标对应的利润最大值
        first_profit = [0]*len(prices)
        # 从左至右比遍历，获取顺序区间内一次交易利润的最大值
        for i in range(len(prices)):
            min_price = min(min_price, prices[i])
            total_max_profit = max(total_max_profit, prices[i]-min_price)
            first_profit[i] = total_max_profit
        max_price, max_profit = float('-inf'), 0
        # 从右至左遍历，获取逆序区间内一次交易利润的最大值，两者相加得到两次利润的最大值
        for i in range(len(prices)-1, 0, -1):
            max_price = max(max_price, prices[i])
            max_profit = max(max_profit, max_price-prices[i])
            total_max_profit = max(total_max_profit, max_profit+first_profit[i-1])
        return total_max_profit


if __name__ == "__main__":
    prices = [3,3,5,0,0,3,1,4]
    max_profit = Solution().maxProfit(prices)
    print(max_profit)

不过执行效率也不是很高，在30%左右。

方法三：动态规划法

此方法就是正儿八经的用动态规划方法求解，不过说实话，我也没太看懂，但执行效率是真的高，我还是贴出来分享给大家。这是我之前写的关于动态规划方法求解的文章，大家可以先看看，相信会有所收获。

https://blog.csdn.net/weixin_36431280/article/details/86616672

代码如下：

class Solution(object):
    def maxProfit(self, prices):
        if not prices: return 0
        n = len(prices)
        dp = [[0] * n for _ in range(3)]
        for k in range(1, 3):
            pre_max = -prices[0]
            for i in range(1, n):
                pre_max = max(pre_max, dp[k - 1][i - 1] - prices[i])
                dp[k][i] = max(dp[k][i - 1], prices[i] + pre_max)
        return dp[-1][-1]


if __name__ == "__main__":
    prices = [3,3,5,0,0,3,1,4]
    max_profit = Solution().maxProfit(prices)
    print(max_profit)

代码很简洁，执行效率在70%左右，还是不错了。