LeetCode刷题流程：动态规划-股票问题121.122.123.188（非累积，累积，非累积+累积，非累积+多次累积）

详细解答与dp序列初始化请见Carl大佬：点击链接

动态规划序列含义：

dp[持有股票][不持股票]

持有股票： 应该为最便宜的股票，（积累问题$\to$）或者是在上一次（不一定刚刚就是上一支就卖出）交易卖出获得利润之后买入剩下最多的钱；

不持股票： 将上一次（不一定刚刚就是上一支就买入）交易买入的股票卖出，能够获得的最大利润。

---

121：整个过程只进行一次交易获得最大利润，因此只需要考虑买入最低价格，卖出最高价格即可。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        vector<vector<int>>dp(prices.size(),vector<int>(2,0));
        dp[0][0]-=prices[0];
        for(int m=1;m<prices.size();++m)
        {
            dp[m][0]=max(dp[m-1][0],-prices[m]);
            dp[m][1]=max(dp[m-1][1],dp[m-1][0]+prices[m]);//非累积，最大利润问题
        }
        return dp[prices.size()-1][1];
    }
};

122：多次交易，获得最大利润。由于是多次交易，买入需要考虑上一次交易卖出时手中剩余的钱，考虑剩余的钱是由于需要在整个交易过程当中累积造成的。如果不考虑上一次交易手中剩余的钱，那么就是121的问题。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        vector<vector<int>>dp(prices.size(),vector<int>(2,0));
        dp[0][0]-=prices[0];
        for(int m=1;m<prices.size();++m)
        {
            dp[m][0]=max(dp[m-1][0],dp[m-1][1]-prices[m]);
            dp[m][1]=max(dp[m-1][1],dp[m-1][0]+prices[m]);//累积，最大利润问题
        }
        return dp[prices.size()-1][1];
    }
};

123：两次交易，获得最大利润。在这里，第二次交易是在第一次交易利润的基础上累积得到的，那么第一次不允许累积，那么第一次就是121问题，第二次就是串联在第一次交易之后的122问题。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        vector<vector<int>>dp(prices.size(), vector<int>(4, 0));
        dp[0][0] -= prices[0]; dp[0][2] -= prices[0];
        for (int m = 1; m < prices.size(); ++m)
        {
            dp[m][0] = max(dp[m - 1][0], -prices[m]);
            dp[m][1] = max(dp[m - 1][1], dp[m - 1][0] + prices[m]);//没有累积的过程，只是找到最大的利润
            dp[m][2] = max(dp[m-1][2],dp[m-1][1]-prices[m]);
            dp[m][3] = max(dp[m - 1][3], dp[m - 1][2] + prices[m]);//在前面的没有累积的过程当中增加一次累积，这次累积代表第二次交易
            //因此，这道题可以理解为非累积（最大利润）+在非累积（最大利润）基础上累积
            //就是将两种题目组合在一起，也就是LeetCode股票问题121+122
        }
        return dp[prices.size() - 1][3];
    }
};

188：同123

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