算法训练（leetcode）第三十六天 | 188. 买卖股票的最佳时机 IV、309. 买卖股票的最佳时机含冷冻期、714. 买卖股票的最佳时机含手续费

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

leetcode题目地址

与前一题123. 买卖股票的最佳时机 III 是相同的思路，只是状态数变多了。123. 买卖股票的最佳时机 III 的题目要求至多买卖2次，共有4种状态；本题要求至多买卖k次，则共有2*k种状态：

• 0：无操作（防止数组越界）
• 1：第一次持有/买入
• 2：第一次不持有/卖出
• 3：第二次持有/买入
• 4：第二次不持有/卖出
  …
• 2*k-1：第k次持有/买入
• 2*k：第k次不持有/卖出

可以看到每一次买都对应一次卖，因为只有卖出了才会有利润。

dp[i][j]代表第i天第j个状态的最高利润

1. 每次持有/买入（j%2==1）的状态转移方程：
   • 当天未买入，保持前一天的持有状态：dp[ i ][ j ] = dp[ i-1 ][ j ]
   • 当天买入，则当天该状态更新为前一天的前一个卖出状态减去当天的价格：dp[ i ][ j ] = dp[ i-1 ][ j-1 ] - prices[ i ]

整理上述规则得出每次持有/买入（j%2==1）的状态转移方程：dp[ i ][ j ] = max( dp[ i-1 ][ j ], dp[ i-1 ][ j-1 ] - prices[ i ] )

2. 每次不持有/卖出（j%2==0）的状态转移方程：
   • 当天未卖出，保持前一天的不持有状态： dp[ i ][ j ] = dp[ i-1 ][ j ]
   • 当天卖出，则当天该状态更新为前一天的前一个买入状态加上当天的价格：dp[ i ][ j ] = dp[ i-1 ][ j-1 ] + prices[ i ]
     整理上述规则得出每次持有/买入（j%2==0）的状态转移方程：dp[ i ][ j ] = max( dp[ i-1 ][ j ], dp[ i-1 ][ j-1 ] + prices[ i ] )

tips： 可以发现状态转换都是基于前一天的当前状态或前一天的前一个状态，因此状态0是为了防止第一次买入状态越界，无实际意义。

时间复杂度： $O(n\ast k)$
空间复杂度： $O(n\ast k)$

// c++
class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        int len = prices.size();
        vector<vector<int>> dp(len, vector<int>(2*k+1, 0));
        
        // 初始化
        for(int j=1; j<=2*k; j++){
            if(j%2==1) dp[0][j] = -prices[0];
        }
        for(int i=1; i<len; i++){
            for(int j=1; j<=2*k; j++){
                // 第j/2+1次持有/买入
                if(j%2==1){
                    // 前一天就持有：dp[i-1][j]
                    // 前一天不持有，当天买入：dp[i-1][j-1]-prices[i]
                    // 二者取最大
                    dp[i][j] = max(dp[i-1][j], dp[i-1][j-1]-prices[i]);
                }else{
                    // 第j/2次不持有/卖出
                    // 前一天就不持有：dp[i-1][j]
                    // 前一天持有，当天卖出：dp[i-1][j-1]+prices[i]
                    dp[i][j] = max(dp[i-1][j], dp[i-1][j-1]+prices[i]);
                }
            }
        }
        /*
        // 输出dp数组
        for(int i=0; i<len; i++){
            for(int j=0; j<2*k+1; j++)
                cout<<dp[i][j]<<" ";
            cout<<endl;
        }
        */
        return dp[len-1][2*k];
    }
};

309. 买卖股票的最佳时机含冷冻期

leetcode题目地址

本题和前面几题大差不差。

先分析题目共有如下几种状态：

• 0：前一天卖出，当天冻结
• 1：当天持有/买入
  • 1-1：前一天冻结，当天买入
  • 1-2：前一天买入/持有，当天保持持有状态
• 2：当天不持有/卖出
  • 2-1：前一天买入/持有，当天卖出
  • 2-2：前一天卖出/不持有，当天保持不持有状态

dp[i][j]表示第i天的第j个状态的最大利润

• 0：当天冻结，则利润为前一天卖出/不持有的利润
  • dp[ i ][ 0 ] = dp[ i-1 ][ 2 ]
• 1：当天持有/买入
  • 1-1：当天买入，则利润为前一天冻结的利润减去当天买入价格
    • dp[ i ][ 1 ] = dp[ i-1 ][ 0 ] - prices[ i ]
  • 1-2：当天保持前一天的持有状态
    • dp[ i ][ 1 ] = dp[ i-1 ][ 1 ]
• 2：当天不持有/卖出
  • 2-1：前一天买入/持有，当天卖出，则利润为前一天持有的利润加当天卖出的价格
    • dp[ i ][ 2 ] = dp[ i-1 ][ 1 ] + prices[ i ]
  • 2-2：前一天卖出/不持有，当天保持不持有状态，则利润为前一天卖出/不持有的利润
    • dp[ i ][ 2 ] = dp[ i-1 ][ 2 ]

时间复杂度： $O(n)$
空间复杂度： $O(n)$

// c++
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        vector<vector<int>> dp(prices.size(), vector<int>(3, 0));
        // 冻结
        dp[0][0] = 0;
        // 持有/买入
        dp[0][1] = -prices[0];
        // 不持有/卖出
        dp[0][2] = 0;
        for(int i=1; i<prices.size(); i++){
            dp[i][0] = dp[i-1][2];
            dp[i][1] = max(dp[i-1][1], dp[i-1][0]-prices[i]);
            dp[i][2] = max(dp[i-1][2], dp[i-1][1]+prices[i]);
        }
        return dp[prices.size()-1][2];
    }
};

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

leetcode题目地址

本题其实整体比较简单，只有两个状态：买入和卖出，在买入卖出的整体流程中需要减去一个手续费。
0：持有/买入
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-1 ][ 0 ] + prices[ i ])

本题的状态转移方程只需要在上边的方程基础上考虑手续费在买入时扣除还是卖出时扣除，二者在初始化时是有区别的。

时间复杂度： $O(n)$
空间复杂度： $O(n)$

买入时扣除手续费

// c++
class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        vector<vector<int>> dp(prices.size(), vector<int>(2, 0));
        // 第一天买入，同时扣除手续费
        dp[0][0] = -prices[0]-fee;
        // 第一天卖出
        // dp[0][1] = 0;
        dp[0][1] = max(0, -fee); // 这里的-fee是当天买入再卖出：-prices[0]-fee+prices[0]
        for(int i=1; i<prices.size(); i++){
            dp[i][0] = max(dp[i-1][0], dp[i-1][1]-prices[i]-fee);
            dp[i][1] = max(dp[i-1][1], dp[i-1][0]+prices[i]);
        }
        return dp[prices.size()-1][1];
    }
};

卖出时扣除手续费

// c++
class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        vector<vector<int>> dp(prices.size(), vector<int>(2, 0));
        // 第一天买入，不扣手续费
        dp[0][0] = -prices[0];
        // 第一天卖出，扣除手续费
        // dp[0][1] = 0;
        dp[0][1] = max(0, -fee); // 这里的-fee是当天买入再卖出：-prices[0]+prices[0]-fee
        for(int i=1; i<prices.size(); i++){
            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]-fee);
        }
        return dp[prices.size()-1][1];
    }
};