动态规划之买卖股票问题

买卖股票问题比较多，基本问题类型如下：

随着k取值的不同，以及手续费，冷冻期的问题，可能会有许多变形，我将其总结为贪心算法和动态规划，当k=1或k无限制时，即只能买卖一次或者无限制时，可以用贪心算法。

1、

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

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

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if (len(prices)==0):
            return 0
        value = prices[0]
        res=0
        for i in range(len(prices)):
            value = min(value,prices[i])
            res   = max(res,prices[i]-value)
        return res

利用value值维护当前时刻的最低买入价格，res更新卖出股票时的最大收益值

 

2、

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

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

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

问题分析如上，直接记录当前天数和前一天的差值，如果为正，说明可以买卖，是正收益，然后将结果res更新

3、

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

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

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

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if len(prices)==0:
            return 0
        max_k=2
        n = len(prices)
        dp = [[[0]*2 for _ in range(max_k+1)] for _ in range(n)]

        for k in range(max_k+1): #base case i=0
            dp[0][k][0] = 0
            dp[0][k][1] = -prices[0]

        for  i in range(1,n):
            for k in range(1,max_k+1):
                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])
        return dp[n-1][max_k][0]
'''
dp[i][k][0 or 1]
0 <= i <= n-1, 1 <= k <= K
n 为天数， ⼤ K 为最多交易数
此问题共 n × K × 2 种状态， 全部穷举就能搞定。
for 0 <= i < n:
    for 1 <= k <= K:
        for s in {0, 1}:
        dp[i][k][s] = max(buy, sell, rest)
'''

问题的核心还是弄明白dp数组的表示含义，dp[i][j][0/1]表示在第i天能够交易k次额最大利润，0或者1表示当前的持有状态

有几个关键问题要明白，首先初始化，i是从0到n-1一共n天，k是从0到k因此k初始化应该为max_k+1，s的状态只能取0或者1

而后是初始状态，当i=0时，即第一天的时候，应该为：

dp[0][k][0] = 0
dp[0][k][1] = -prices[0]

接下来对于dp数组的遍历，i应该从开始到n-1，k从max到1,因为k=0的情况没有初始化，因此应该先计算 dp[i][k][0]，即将【k-1】放到k之后进行计算

 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])

4、

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

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

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

class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:
        if k == 0 or len(prices) < 2:
           return 0
        n = len(prices)
        res = []
        if k > n // 2: 
           max_profit = 0
           for i in range(1,n):
               profit = prices[i] - prices[i - 1]
               if profit > 0:
                   max_profit += profit
           return max_profit

        max_k=k
        dp = [[[0]*2 for _ in range(max_k+1)] for _ in range(n)]

        for k in range(max_k+1): #base case i=0
            dp[0][k][0] = 0
            dp[0][k][1] = -prices[0]


        for  i in range(1,n):
            for k in range(1,max_k+1):
                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])
        return dp[n-1][max_k][0]

真香，大杂烩，应该能看清吧，贪心算法加dp求解，判读长度大于n/2的话，就无限期交易，贼贪婪，可以避免数组过大报内存