股票买卖 6题：

121-只允许买卖一次

n * 2 空间的dp表：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        const int n = prices.size();
        if (n == 0) return 0;
        // 初始化第0天的情况
        vector<vector<int>> dp(n, vector<int>(2, 0));
        dp[0][0] = 0;
        dp[0][1] = -prices[0];

        for(int i = 1; i < n; i++) {
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]);
            dp[i][1] = max(dp[i-1][1], -prices[i]); //-prices[i]之前不需要加dp[i-1][0]，因为只允许买一次，之前都是0
        }

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

简化空间开销：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        const int n = prices.size();
        if(n == 0) return 0;

        int pre_0 = 0, pre_1 = -prices[0];
        int cur_0, cur_1;
        for(int i = 1; i < n; i++) {
            pre_0 = max(pre_0, pre_1 + prices[i]);
            pre_1 = max(pre_1, - prices[i]);
        }
        return pre_0;
    }
};

122-买卖无限次

比121还容易（事实上，121容易写错写成122） ，只要加上 “pre_0-”就可以了

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        const int n = prices.size();
        if(n == 0) return 0;

        int pre_0 = 0, pre_1 = -prices[0];
        for(int i = 1; i < n; i++) {
            pre_0 = max(pre_0, pre_1 + prices[i]);
            pre_1 = max(pre_1, pre_0 - prices[i]);
        }
        return pre_0;
    }
};

另一种写法，从i=0开始，注意两者的细微差别 

    int maxProfit(vector<int>& prices) {
        const int n = prices.size();
        int pre_0 = 0, pre_1 = INT_MIN;
        for(int i = 0; i < n; i++) {
            pre_0 = max(pre_0, pre_1 + prices[i]);
            pre_1 = max(pre_1, pre_0 - prices[i]);
        }
        return pre_0;
    }

123-买卖限制2次

原始dp解法：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        const int n = prices.size();
        if(n == 0) return 0;

        const int K = 2;
        int dp[n+1][K+1][2];
        // 初始化第0天，还没开始交易
        for (int i = 0; i <= K; i++) { //第0天的
            dp[0][i][0] = 0;
            dp[0][i][1] = -prices[0] - 1;
        }
        for (int i = 0; i <= n; i++) { //允许交易次数为0的
            dp[i][0][0] = 0;
            dp[i][0][1] = -prices[0] - 1;
        }

        for (int i = 1; i <= n; i++) {
            for (int k = K; k >= 1; k--) {
                dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i-1]);
                dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i-1]);
            }
        }
        return dp[n][K][0];
    }
};

优化空间尝试：部分case过不了。。TODO

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        const int n = prices.size();
        if (n == 0) return 0;

        const int K = 2;
        int dp[K + 1][2];

        dp[0][0] = 0; dp[0][1] = -prices[0] - 1;
        // 初始为第0天-最大交易k天的值
        for (int i = 1; i <= K; i++) {
            dp[i][0] = 0;
            dp[i][1] = -prices[i] - 1;
        }

        for (int i = 0; i < n; i++) {
            for (int k = K; k >= 1; k--) {
                dp[k][0] = max(dp[k][0], dp[k][1] + prices[i]);
                dp[k][1] = max(dp[k][1], dp[k-1][0] - prices[i]);
            }
        }
        return dp[K][0];
    }
};

 

188-限制买卖k次-注意k与天数n的关系，做特殊处理--k过大等于没有限制

class Solution {
public:
    int maxProfit(int k, vector<int>& prices) {
        const int n = prices.size();
        if(n == 0 || k == 0) return 0;
        //特殊处理，否则有些case无法通过
        if(k * 2 >= n) return maxProfit(prices);

        int dp[n+1][k+1][2];
        //初始化，之后都与只允许两次的一样
        for(int i = 0; i <= k; i++) {
            dp[0][i][0] = 0;
            dp[0][i][1] = INT_MIN;
        }
        for(int i = 0; i <= n; i++) {
            dp[i][0][0] = 0;
            dp[i][0][1] = INT_MIN;
        }

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

    int maxProfit(vector<int>& prices) {
        const int n = prices.size();
        int pre_0 = 0, pre_1 = -prices[0];
        for(int i = 1; i < n; i++) {
            pre_0 = max(pre_0, pre_1 + prices[i]);
            pre_1 = max(pre_1, pre_0 - prices[i]);
        }
        return pre_0;
    }
};

309-卖掉之后间隔1天才能买

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        const int n = prices.size();
        if(n < 1) return 0;

        int dp_0_pre = 0, dp_0 = 0, dp_1 = INT_MIN;
        for(int i = 0; i < n; i++) {
            int tmp = dp_0; //把dp_0存起来，最后再给dp_0_pre
            dp_0 = max(dp_0, dp_1 + prices[i]);
            dp_1 = max(dp_1, dp_0_pre - prices[i]);
            dp_0_pre = tmp;
        }
        return dp_0;
    }
};

714-加手续费

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

        int dp_0 = 0, dp_1 = INT_MIN;
        for(int i = 0; i < n; i++) {
            dp_0 = max(dp_0, dp_1 + prices[i]);
            dp_1 = max(dp_1, dp_0 - prices[i] - fee);
        }
        return dp_0;
    }
};