第46天-DP-第九章 ● 123.买卖股票的最佳时机III ● 188.买卖股票的最佳时机IV

1. 买卖股票的最佳时机 III (最多两笔交易)

由于最多可以买卖两次，因此会有多种状态

• 第一次持有股票 dp[i][0]， 第一次不持有股票dp[i][1]
• 第二次持有股票 dp[i][2], 第二次不持有股票 dp[i][3]

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        // 1.dp数组一共有四种状态
        vector<vector<int>> dp(len, vector<int>(4));
        // 2.确定递推公式

        // 3.初始化
        dp[0][0] = -prices[0];          // 第一次持有
        dp[0][2] = -prices[0];          // 在第一天买入后卖出又买入
        // dp[0][1] dp[0][3]   第一次不持有, 第二次持有和不持有都是0
    

        for(int i=1; i<len; i++){
            // 第一次持有   本来就持有dp[i-1][0] 或者 本来不持有-prices[i]
            dp[i][0] = max(dp[i-1][0], -prices[i]);
            // 第一次不持有,  原本就不持有dp[i-1][1] 或者是 原本持有后卖出dp[i-1][0] + prices[i]
            dp[i][1] = max(dp[i-1][1], dp[i-1][0] + prices[i]);

            // 第二次持有, (只有当第一次持有后卖出才可以) 原本就持有dp[i-1][2] 或者 第一次持有后卖出后 dp[i][1] - prices[i]
            dp[i][2] = max(dp[i-1][2], dp[i][1] - prices[i]);

            // 第二次不持有, 要么原本就不持有， 或者持有后卖出
            dp[i][3] = max(dp[i-1][3], dp[i][2] + prices[i]);
        }

        return dp[len-1][3];
    }
};

2. 买卖股票的最佳时机 IV (最多完成k次交易)

• LeetCode链接
  
• dp[i][j] 第一次解答错误，是因为不持有后购买股票的金钱数与上一轮的前一次不购买相关，而不是与上一轮的同一次购买相关

    int maxProfit(int k, vector<int>& prices) {
        int len = prices.size();
        
        //1. dp的大小: (len(2k)) 
        vector<vector<int>> dp(len, vector<int>(2*k));

        // 2. 初始化值, 在第一次可以买卖股票的时候 即 dp[0] 阶段买卖, j是偶数的时候为持有股票
        for(int j=0; j<2*k; j+=2){
            dp[0][j] = -prices[0];
        }

        for(int i=1; i<len; i++){
            for(int j=0; j<2*k; j+=2){
                // 第i轮 第j次 持有股票, 本来就持有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[i][j] = max(dp[i - 1][j], - prices[i] + (j == 0 ? 0 : dp[i-1][j-1]));
                // 第i轮 第j次不持有股票， 本来不持有dp[i-1][j+1]， 本来持有后卖出dp[i-1][j]+prices[i]
                dp[i][j+1] = max(dp[i-1][j+1], dp[i-1][j] + prices[i]); 
            }
        }
        return dp[len-1][2*k-1];

    }

class Solution {
public:

    int maxProfit(int k, vector<int>& prices) {
        int len = prices.size();
        
        //1. dp的大小: (len(2k)) 
        vector<vector<int>> dp(len, vector<int>(2*k+1));

        // 2. 初始化值, 每个dp[i]的 k个不持有股票的状态都需要初始化
        for(int j=1; j<2*k; j+=2){
            dp[0][j] = -prices[0];
        }

        for(int i=1; i<len; i++){
            for(int j=0; j<2*k; j+=2){
                // 第i轮 第j次 持有股票, 本来就持有, 本来不持有后买入
                dp[i][j+1] = max(dp[i-1][j+1], dp[i-1][j]-prices[i]);
                // 第i轮 第j次不持有股票， 本来不持有， 本来持有后卖出
                dp[i][j+2] = max(dp[i-1][j+2], dp[i-1][j+1] + prices[i]); 
            }
        }

        // for(int i=1; i<len; i++){
        //     for(int j=0; j<k; j+=2){
        //         // 第i轮 第j次 持有股票, 本来就持有, 本来不持有后买入
        //         dp[i][j] = max(dp[i-1][j], dp[i-1][j+1]-prices[i]);
        //         // 第i轮 第j次不持有股票， 本来不持有， 本来持有后卖出
        //         dp[i][j+1] = max(dp[i-1][j+1], dp[i][j] + prices[i]); 
        //     }
        // }

        return dp[len-1][2*k];

    }

    int maxProfit1(int k, vector<int>& prices) {
        int n = prices.size();
        if (k >= n / 2) {
            // 如果 k >= n/2，则相当于可以进行任意次交易
            int maxProfit = 0;
            for (int i = 1; i < n; i++) {
                if (prices[i] > prices[i-1]) {
                    maxProfit += prices[i] - prices[i-1];
                }
            }
            return maxProfit;
        }
        vector<vector<vector<int>>> dp(n, vector<vector<int>>(k+1, vector<int>(2, 0)));
        for (int i = 0; i < n; i++) {
            for (int j = 1; j <= k; j++) {
                if (i == 0) {
                    dp[i][j][1] = -prices[i];
                } 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];
    }
};