leetcode股票问题

leetcode上刷题时，股票问题大概有五六道题，看到了一位大佬写的很好的解题思路和总结，拿过来借鉴
借鉴：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/solution/yi-ge-fang-fa-tuan-mie-6-dao-gu-piao-wen-ti-by-l-3/

大佬写的题解，很棒！
--------------手动分割线------------------
以下是我这个小菜鸡的刷题代码：

dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
              max(   选择 rest  ,           选择 sell      )

解释：今天我没有持有股票，有两种可能：
要么是我昨天就没有持有，然后今天选择 rest，所以我今天还是没有持有；
要么是我昨天持有股票，但是今天我 sell 了，所以我今天没有持有股票了。

dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
              max(   选择 rest  ,           选择 buy         )

解释：今天我持有着股票，有两种可能：
要么我昨天就持有着股票，然后今天选择 rest，所以我今天还持有着股票；
要么我昨天本没有持有，但今天我选择 buy，所以今天我就持有股票了。

解题重点是列出状态转移框架：

1.(121) 买卖股票的最佳时机I

只有一次买入卖出的机会:

//c++
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int dp_i_0=0,dp_i_1=INT_MIN;
        for(int i=0;i<prices.size();i++){
            dp_i_0=max(dp_i_0,dp_i_1+prices[i]);
            dp_i_1=max(dp_i_1,-prices[i]);
        }
        return dp_i_0;       
    }
};

2.（122)买卖股票的最佳时机 II

不限制买卖次数：

//C++
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        //可以进行无数次的交易
        
        int s=prices.size();
        int dp_i_0=0,dp_i_1=INT_MIN;
        
        for(int i=0;i<s;i++){
            int temp=dp_i_0;
            dp_i_0=max(dp_i_0,dp_i_1+prices[i]);
            dp_i_1=max(dp_i_1,temp-prices[i]);
           
        }
        return dp_i_0;

    }
};

3.(309)最佳买卖股票时机含冷冻期

开始限制执行一次交易后必须冷冻一天。

//C++
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int s=prices.size();
        int dp_i_0=0;
        int dp_i_1=INT_MIN;
        int dp_pre_0=0; //代表dp[i-2][0]
        
        for(int i=0;i<s;i++){
            int temp=dp_i_0;
            
            dp_i_0=max(dp_i_0,dp_i_1+prices[i]);
            dp_i_1=max(dp_i_1,dp_pre_0-prices[i]);
            
           dp_pre_0=temp;
            
        }
        return dp_i_0;

    }
};

4.(714) 买卖股票的最佳时机含手续费

在交易的过程中要额外收费

//C++
class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int s=prices.size();
        int dp_i_0=0;
        int dp_i_1=INT_MIN;
        
        for(int i=0;i<s;i++){
            int temp=dp_i_0;
            dp_i_0=max(dp_i_0,dp_i_1+prices[i]);
            dp_i_1=max(dp_i_1,temp-prices[i]-fee);
            
        }
        return dp_i_0;

    }
};

5.（123） 买卖股票的最佳时机 III

问题变复杂，开始限制交易次数，此次交易次数限制为2

#Python
class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        s=len(prices)
        dp=[[[0]*2 for _ in range(3)] for _ in range(s)]
        if not dp:
            return 0  #考虑dp内容为空
        
        for i in range(s):
            for kc in range(2,0,-1):
                if i==0:
                    dp[0][kc][0]=0
                    dp[0][kc][1]=-prices[0]
                    continue     
            
                dp[i][kc][0]=max(dp[i-1][kc][0],dp[i-1][kc][1]+prices[i])
                dp[i][kc][1]=max(dp[i-1][kc][1],dp[i-1][kc-1][0]-prices[i])
            
        return dp[s-1][2][0]

6.(188) 买卖股票的最佳时机 IV

限制交易次数，交易次数变多。所以增加判断，如果允许交易次数很多（>len(prices)//2)，则视为不限制交易次数。

#Python
class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:
        s=len(prices)
        if k>s//2: #交易次数过多
            dp_i_0=0
            dp_i_1=float('-inf')
            
            for i in range(s):
                temp=dp_i_0
            
                dp_i_0=max(dp_i_0,dp_i_1+prices[i])
                dp_i_1=max(dp_i_1,temp-prices[i])
            return dp_i_0
            
   
      #交易次数少
        dp=[[[0]*2 for _ in range(k+1)] for _ in range(s)]   #初始化dp数组     
        for i in range(s):
            for k_day in range(k,0,-1): #枚举所有情况
                if i==0:
                    dp[0][k_day][0]=0
                    dp[0][k_day][1]=-prices[0]
                    continue   #初始条件
                dp[i][k_day][0]=max(dp[i-1][k_day][0],dp[i-1][k_day][1]+prices[i])
                dp[i][k_day][1]=max(dp[i-1][k_day][1],dp[i-1][k_day-1][0]-prices[i]) #两个状态转移
                
        return dp[s-1][k][0]