算法(24)-股票买卖

解题思路参考buladong解题，详细信息可以关注该公众号。

1.动态规划框架

动态规划–解决买卖k问题，k取不同的值，团灭：
LeetCode-121 一次买卖
LeetCode-122 不限次数
LeetCode-309 不限次数+冷冻期
LeetCode-714 不限次数+手续费
LeetCode-123 两次买卖
LeetCode-188 k次买卖

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

利用动态规划来解决问题，确定每一天有多少可能的状态，再找出状态对应的选择。

每天选择可能有三种：买入，卖出，无操作。但是，三种选择的发生是有条件的。（卖出操作的前提是你持有股票）

每天的状态变量有3个：天数，允许交易的最大次数，当前的持有状态(持有股票1/未持有0)。三维数组可以装下所有状态。
$dp[i][k][0or1]$, 到第i天，最多进行k次，手上持有/未持有股票，获得的最多利润。
要求解的是$dp[n-1][K][0]$的值。

k 买入算是一次操作，收益一开始是0，一次买卖：买入时0-买入时价格，卖出时：0-买入时价格+卖出时价格

状态转移方程：
$$dp[i][k][0]=max(dp[i-1][k][0],dp[i-1][k][1]+prices[i])$$
今天未持有：昨天未持有/昨天持有卖掉
$$dp[i][k][1]=max(dp[i-1][k][1],dp[i-1][k-1][0]-prices[i])$$
今天持有：昨天持有/昨天持有卖掉

初始状态base case：
未开始未持有，收益为0：$dp[-1][k][0]=0$
未开始以持有，不可能，收益为负无穷：max 的时候取不到$dp[-1][k][1]=-\infty$
允许的最大交易次数为0，未持有无收益：$dp[i][0][0]=0$
允许的最大交易次数为0，持有不可能设为负无穷：$dp[i][0][1]=-\infty$

用这个思路来解决 以上的题

LeetCode-121 一次买卖

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]),dp[i-1][0][0] =0
# k = 1 不可以变，因此上面状态变量减少为两个
# dp[i][0] = max(dp[i-1][0], dp[i-1][1]+prices[i])
# dp[i][1] = max(dp[i-1][1], 0-prices[i]),		dp[i-1][0][0] =0
# dp[i][1]的更新会影响dp[i+1][0]的更新

def maxProfit(self, prices):
    n = len(prices)
    if n == 0 :
        return 0
    dp=[[0,0] for i in range(n)]
    for i in range(0,n):
        if i == 0:
            dp[0][0] = 0
            dp[0][1] = -prices[0]
        else:
            dp[i][0] =  max(dp[i-1][0], dp[i-1][1]+prices[i])
            dp[i][1] =  max(dp[i-1][1], 0-prices[i])   # dp[i-1][0]未持有收益为0
    return dp[n-1][0]

LeetCode-122 不限次数

$k=\infty$

# dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1]+prices[i])
# dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0]-prices[i])
# k =  \infty k-1 = k  k 状态又可以去除
# 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]),		dp[i-1][0]为进行了很多次操作用于的收益
# dp[i][1]的更新会影响dp[i+1][0]的更新
def maxProfit(self, prices):
    n = len(prices)
    if n == 0:
        return 0
    dp = [[0,0] for i in range(n)]
    for i in range(n):
        if i == 0:
            dp[0][0] = 0
            dp[0][1] = -prices[0]
        else:
            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]

LeetCode-309 不限次数+冷冻期

卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

# dp[i][0] = max(dp[i-1][0], dp[i-1][1]+prices[i])
# dp[i][1] = max(dp[i-1][1], dp[i-2][0]-prices[i]),		前两天卖出操作今天买入    
# 初始值得设定上
def maxProfit(self, prices):
    """
    :type prices: List[int]
    :rtype: int
    """
    n = len(prices)
    if n == 0:
        return 0
    dp = [[0,0] for i in range(n)]
    for i in range(n):
        if i == 0:
            dp[0][0] = 0
            dp[0][1] = -prices[0]
        elif i == 1:
            dp[1][0] = max(dp[0][0], dp[0][1] + prices[1])
            dp[1][1] = max(dp[0][1], dp[0][0] - prices[1])
        else:
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
            dp[i][1] = max(dp[i-1][1], dp[i-2][0] - prices[i])
    return dp[n-1][0]

LeetCode-714 不限次数+手续费

给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；非负整数 fee 代表了交易股票的手续费用。
你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。
返回获得利润的最大值。
注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

每笔交易减去一个手续费即可，在买入的时候多减掉一个手续费，相当于股票的买入价格提高了

    def maxProfit(self, prices, fee):
        """
        :type prices: List[int]
        :type fee: int
        :rtype: int
        """
        n = len(prices)
        if n == 0:
            return 0
        dp = [[0,0] for i in range(n)]
        for i in range(n):
            if i == 0:
                dp[0][0] = 0
                dp[0][1] = -prices[0]-fee   # 注意这个值
            else:
                dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
                dp[i][1] = max(dp[i-

LeetCode-123 两次买卖

k = 2需要考虑状态，唯一的区别就是base case 设定

# dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1]+prices[i])
# dp[i][1] = max(dp[i-1][k][1], dp[i-1][k-1][0]-prices[i]),		   
# 需要遍历k,最多进行两次，当然我也可以不买卖
def maxProfit(self, prices):
    """
    :type prices: List[int]
    :rtype: int
    """
    k = 2       # 注意k 要能取得到
    n = len(prices)
    if n == 0:
        return 0
    dp=[[[0,0] for j in range(k+1)] for i in range(n)]
    for i in range(n):
        for j in range(k+1):
            if i == 0 or j ==0:
                dp[i][j][0] = 0
                dp[i][j][1] = -prices[0]     # 通用初始化
            else:
                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])
    return dp[n-1][k][0] 
        

LeetCode-188 k次买卖

k取任意确定的数字时，解题框架于=与k = 2 时一致。当k 过大时，会造超内存错误。根据买卖至少需要两天，可以限制最大交易次数不应该超过n/2,如果超过了就相当于k = 无穷的情况。整合一下前面的方法即可。

class Solution(object):
    def maxProfit(self, k, prices):
        """
        :type k: int
        :type prices: List[int]
        :rtype: int
        """
        n = len(prices)
        if n == 0:
            return 0
        if k > n//2:
            dp = [[0,0] for i in range(n)]
            for i in range(n):
                if i == 0:
                    dp[0][0] = 0
                    dp[0][1] = -prices[0]
                else:
                    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]
        else:
            dp=[[[0,0] for j in range(k+1)] for i in range(n)]
            for i in range(n):
                for j in range(k+1):
                    if i == 0 or j == 0:
                        dp[i][j][0] = 0
                        dp[i][j][1] = -prices[0]
                    else:
                        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])
            return dp[n-1][k][0]

2.贪心特解

这两种特殊情况还是特殊解来的快，框架反而繁杂。

LeetCode-121 一次买卖

关键找到每一天之前的最低价格，两者相减，求增益最大。

def maxProfit(self, prices):
    n = len(prices)
    if n == 0:
        return 0
    min_val = prices[0]
    res = 0
    for i in range(1,n):
        res = max(res, prices[i]-min_val)
        min_val = min(min_val, prices[i])
    return res

LeetCode-122 不限次数

不限次数，每一个谷底买入下一个峰值卖出，多次操作，和值最大。累加收益。

def maxProfit(self, prices):
    n = len(prices)
    if n == 0:
        return 0
    res = 0 
    for i in range(1,n):
        if prices[i]>prices[i-1]:
            res += prices[i]-prices[i-1]
    return res