leetcode系列题：买卖股票的最佳时机_一、买卖股票的最佳时机(含 续费) 【问题描述】给定 个整数数组 prices,其

历史题目及代码汇总

初级：一次交易

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

思路：一次遍历，找到减去之前最小值结果最大的数。

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        length = len(prices)
        if length < 2:
            return 0
        minVal = prices[0]
        result = float('-inf')
 
        for price in prices:
            result = max(result,price - minVal)
            minVal = min(minVal,price)
 
        return result

---

入门：无限次交易

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

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

思路：一个十分符合直觉的思路：只要递增就买入，只要递减就卖出。这样，只需要给出每两天之间的价格差即可。

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

---

登堂：2次交易

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

思路一：给出四个状态，分别表示第一次买入、第一次卖出、第二次买入、第二次卖出的收益情况，这样就可以一次遍历给出十分符合直觉的解法。

class Solution:
    ##四个状态分别表示第一次被买入、第一次被卖出、第二次被买入、第二次被卖出
    def maxProfit(self, prices: List[int]) -> int:        
        first_buy = float('-inf')
        first_sell = 0
        second_buy = float('-inf')
        second_sell = 0
        for price in prices:
            first_buy = max(first_buy,-price)
            first_sell = max(first_sell,first_buy + price)
            second_buy = max(second_buy,first_sell - price)
            second_sell = max(second_sell,second_buy + price)
        return second_sell

除此之外还有一种相对来说没有那么好理解的解法。创建两个数组forwards和backwards，forward中，保存的是第1天到当前天最大的收益，其中max里的两个选择，表示的是"今天卖了"或者"今天没卖，之前某天卖了"。也就是说，无论是哪种情况，当前这一天都是没有持有股票的，最多就是当前这一天做了卖股票这个动作。backwards中同理。因此，不会出现穿越买卖的情况。那就有问题了，不会同一天又买股票又卖股票吗？不会。同一天又买又卖，就相当于没买没卖。

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        if n < 2:
            return 0
        forward = [0] * n
        backward = [0] * n
        minVal = prices[0]
        maxVal = prices[-1]
 
        ##第一遍前向遍历，找到第1天到当前天最大的收益
        for i in range(1,n):
            forward[i] = max(forward[i - 1],prices[i] - minVal)
            minVal = min(minVal,prices[i])
        ##第二遍后向遍历，找到当前天到最后一天的最大收益
        for i in range(n - 2,-1,-1):
            backward[i] = max(backward[i + 1],maxVal - prices[i])
            maxVal = max(maxVal,prices[i])
        result = [forward[i] + backward[i] for i in range(n)]
        return max(result)

---

入室：k次交易
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。 设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。 注意: 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

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

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

在理解了上一题思路的基础上，很容易可以对四状态法进行扩展。

class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:
        ##只需要对两次的情况做一个简单的推广
        ##首先处理边界情况
        length = len(prices)
        if k == 0 or length < 2:
            return 0
 
        ##当k的次数足够大时可以视为正无穷，因为每天限制只能做一次交易
        if k >= length // 2:
            temp = [prices[i] - prices[i - 1] for i in range(1,length)]
            temp = [i for i in temp if i > 0]
            return sum(temp)
 
        ##否则，建立一个大小为k的数组
        ##buys = [float('-inf')] * k是因为buys描述的是手中持有股票的状态，初始情况下这种状态是不可能的
        ##实际上，把sell和buys都初始化为float('-inf')，也是可以的
        sells = [0] * k
        buys = [float('-inf')] * k
        for i in range(length):
            price = prices[i]
            buys[0] = max(buys[0],-price)
            sells[0] = max(sells[0],buys[0] + price)
            for j in range(1,k):
                buys[j] = max(buys[j],sells[j - 1] - price)
                sells[j] = max(sells[j],buys[j] + price)
        return sells[-1]

---

应用1：买卖股票的最佳时机含手续费

给定一个整数数组 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.

本题是无限次交易的变种。回顾之前前两个题目中的思路，假设我们让sell和buy分别表示卖出状态下的最大收益、拥有股票状态下的最大收益（由于这里不涉及交易次数，因此不需要像k次交易中一样设定矩阵；由于要获得最大收益，最后一天结束后不可能持有股票），那么显然，第i天的状态转移方程是：

buy = max(buy,sell - prices[i])
sell = max(sell,buy + prices[i])

可以轻松地写出代码

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        buy = float('-inf')
        sell = 0
        for price in prices:
            buy = max(buy,sell - price)
            sell = max(sell,buy + price)
        return sell

这不是我们在无限次交易中的写法，因为那里有更加简洁的写法，不过思想是一致的。在本题中，只需要一个小小的改动：没错，把手续费减掉就行了。

class Solution:
    def maxProfit(self, prices: List[int], fee: int) -> int:
        buy = float('-inf')
        sell = 0
        for price in prices:
            buy = max(buy,sell - price)
            sell = max(sell,buy + price - fee)
        return sell

这样就大功告成了。

---

应用2：最佳买卖股票时机含冷冻期

给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。
设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

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

这个题依然是无限次交易的变种。区别在于，某一天的buy值，不能由过去一天的sell值来更新，而是要根据再往前一天的sell值更新，因为有冷冻期。
所以，只需要加上一个变量，存储前天的sell值即可。

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        buy = float('-inf')
        sell = 0
        pre = 0
        for price in prices:
            temp = sell
            buy = max(buy,pre - price)
            sell = max(sell,buy + price)
            pre = temp
        return sell

---

解题套路及思路讲解

这里讲的非常好，对后面几个题里的方案思路进行了一个整合，有助于理解和进行举一反三。虽然动态规划的形式不同，但是思路是一脉相承的。