股票类型题

dp[n][0/1]表示第n持有和不持有的利益，每天都有两个状态；
转移方程

1.今天不持有 可能是 今天刚卖出 或者 之前就不持有(保持状态)
dp[i][0] = max(dp[i-1][1]+prices[i],dp[i-1][0]);
2.今天持有股票 可能是 保持之前持有的状态 或者 今天刚买入 ，因为只能交易一次，所以今天买入直接去-prices[i]即可
dp[i][1] = max(dp[i-1][1],-prices[i]);

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        if(len<2) return 0;
        vector<vector<int>> dp(len,vector<int>(2,0));
        dp[0][1] = -prices[0];
        dp[0][0] = 0;
        
        for(int i=1;i<len;i++){
            dp[i][0] = max(dp[i-1][1]+prices[i],dp[i-1][0]); 
            dp[i][1] = max(dp[i-1][1],-prices[i]); 
        }
        return dp[len-1][0];
    }
};

新状态只和相邻的一个状态有关，其实不用整个 dp 数组，只需要一个变量储存相邻的那个状态就足够了，这样可以把空间复杂度降到 O(1):

// k == 1
int maxProfit_k_1(int[] prices) {
    int n = prices.length;
    // base case: dp[-1][0] = 0, dp[-1][1] = -infinity
    int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
    for (int i = 0; i < n; i++) {
        // dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
        dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]);
        // dp[i][1] = max(dp[i-1][1], -prices[i])
        dp_i_1 = Math.max(dp_i_1, -prices[i]);
    }
    return dp_i_0;
}

不设置交易次数限制的情况
状态定义是一样的，不同的地方在状态转移方程这里，

今天持有股票可能是 保持之前持有的状态 or上一天持有的卖掉了
dp[i][1] = max(dp[i-1][1],dp[i-1][0]-prices[i]);

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        if(len<2) return 0;
        vector<vector<int>> dp(len,vector<int>(2,0));

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

        for(int i=1;i<len;i++){
            dp[i][1] = max(dp[i-1][1],dp[i-1][0]-prices[i]);
            dp[i][0] = max(dp[i-1][0],dp[i-1][1]+prices[i]);
        }

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

k=2 最多交易两次时

这里多了一个状态，交易次数，题目规定最多只能交易两次，所以我们需要考虑交易次数，使用三维数组进行存储dp[n][k][0/1] k表示操作次数

所以状态遍历时，还需要遍历K次，更新每次交易不同的收益

# dp[i][k][j] 
# i 第 i 天， k 股票操作了几次 ， j 是否有股票
# 最多可以完成两笔交易：k可以为 012 次操作 ， j可以为0/1,0没有股票 1有股票

注意 买 卖 都进行一次算一次操作 k + 1,单独 买入 不算完成一次操作

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        if(len<2) return 0;
        // 天数  操作次数  状态0-1
        vector<vector<vector<int>>> dp(len,vector<vector<int>>(3,vector<int>(2,0)));

        for(int i=0;i<=2;i++){
            dp[0][i][1] = -prices[0];
            dp[0][i][0] = 0;
        }
		// 卖出为完成一次交易 , 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]);

        for(int i=1;i<len;i++){
            for(int k=0;k<=2;k++){
                if(k==0)
                    //0次交易没有股票 == i-1天 0次交易 没股票
                    dp[i][k][0] = dp[i-1][k][0];
                else
                // k次交易没有股票 == max(i-1天 k次交易 没股票,i-1天 k-1次交易有股票+当天价格(卖出))
                    dp[i][k][0] = max(dp[i-1][k][0],dp[i-1][k-1][1]+prices[i]);

                dp[i][k][1] = max(dp[i-1][k][1],dp[i-1][k][0]-prices[i]);
            }
        }
        return max(dp[len-1][2][0],max(dp[len-1][1][0],dp[len-1][0][0]));
    }
};

冷冻期

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        if(len<2) return 0;
        vector<vector<int>> dp(len,vector<int>(2,0));

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

        dp[1][1] = max(-prices[0],-prices[1]);
        dp[1][0] = max(0,dp[0][1]+prices[1]);
        
        for(int i=2;i<len;i++){
            dp[i][1] = max(dp[i-1][1],dp[i-2][0]-prices[i]);
            dp[i][0] = max(dp[i-1][0],dp[i-1][1]+prices[i]);
        }

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

手续费

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        
        int len = prices.size();
        if(len<2) return 0;
        vector<vector<int>> dp(len,vector<int>(2,0));

        dp[0][1] = -prices[0]-fee;
        dp[0][0] = 0;

        for(int i=1;i<len;i++){
            dp[i][1] = max(dp[i-1][1],dp[i-1][0]-prices[i]-fee);
            dp[i][0] = max(dp[i-1][0],dp[i-1][1]+prices[i]);
        }

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

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

class Solution {
public:
    int maxProfit1(vector<int>& prices) {
        int len = prices.size();
        if(len<2) return 0;
        int maxval=0,sum=0;
        for(int i=1;i<len;i++){
            sum += prices[i] - prices[i-1];
            maxval = max(maxval,sum);
            sum = max(0,sum);
        }
        return maxval;
    }

    int greedy(vector<int>& prices){
        int max = 0;
        for(int i = 1;i < prices.size();i++){
            if(prices[i] > prices[i-1])
                max += prices[i] - prices[i-1];
        }
        return max;
    }

    int maxProfit(int k,vector<int>& prices) {
    int len = prices.size();
    if(len<2) return 0;
    if(k==1) return maxProfit1(prices);
    if(k >= len/2 +1 ) return greedy(prices);
    
    // 天数  操作次数  状态0-1
    vector<vector<vector<int>>> dp(len,vector<vector<int>>(k+1,vector<int>(2,0)));
    for(int i=0;i<=k;i++){
        dp[0][i][1] = -prices[0];
        dp[0][i][0] = 0;
    }
    
    // 卖出为完成一次交易 , 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]);

    for(int i=1;i<len;i++){
        for(int j=0;j<=k;j++){
            if(j==0)
        //0次交易没有股票 == i-1天 0次交易 没股票
                dp[i][j][0] = dp[i-1][j][0];
            else
        // k次交易没有股票 == max(i-1天 k次交易 没股票,i-1天 k-1次交易有股票+当天价格(卖出))
                dp[i][j][0] = max(dp[i-1][j][0],dp[i-1][j-1][1]+prices[i]);

            dp[i][j][1] = max(dp[i-1][j][1],dp[i-1][j][0]-prices[i]);
        }
    }
    int maxval = 0;
    for(int i=0;i<=k;i++){
        maxval = max(maxval,dp[len-1][i][0]);
    }

    return maxval;
}
};