之前我们已经把力扣上股票系列的题目都讲过的，但没有来一篇股票总结，来帮大家高屋建瓴，所以总结篇这就来了！

121 卖股票的最佳时机

最原始的题。条件为：只能买卖一次

【贪心解法】
取最左最小值，取最右最大值，那么得到的差值就是最大利润，代码如下：


for (int i = 0; i < prices.length(); i++) {
    low = min(low, prices[i]);  // 取最左最小价格
    result = max(result, prices[i] - low); // 直接取最大区间利润
}
return result;

【动态规划】

dp[i][0] 表示第i天持有股票所得现金。
dp[i][1] 表示第i天不持有股票所得现金。

如果第i天持有股票即dp[i][0]，那么可以由两个状态推出来

第 i - 1 天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金即：dp[i - 1][0]
第 i 天买入股票，所得现金就是买入今天的股票后所得现金即：-prices[i] 所以dp[i][0] = max(dp[i - 1][0], -prices[i]);

如果第i天不持有股票即dp[i][1]，也可以由两个状态推出来

第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金即：dp[i - 1][1]
第i天卖出股票，所得现金就是按照今天股票佳价格卖出后所得现金即：prices[i] + dp[i - 1][0] 所以dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);

代码如下：

public int maxProfit(int[] prices) {
    // 判空
    if (prices == null || prices.length == 0) return 0;

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

    return dp[prices.length - 1][1];
}

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

122 买卖股票的最佳时机II

可以多次买卖

【贪心解法】
收集每天的正利润便可，代码如下：

int result = 0;
for (int i = 1; i < prices.size(); i++) {
    result += max(prices[i] - prices[i - 1], 0);
}
return result;
}

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

【动态规划】
dp数组定义：

dp[i][0] 表示第i天持有股票所得现金
dp[i][1] 表示第i天不持有股票所得最多现金

如果第i天持有股票即dp[i][0]，那么可以由两个状态推出来

第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金即：dp[i - 1][0]
第i天买入股票，所得现金就是昨天不持有股票的所得现金减去今天的股票价格即：dp[i - 1][1] - prices[i]

注意这里和 121. 买卖股票的最佳时机 唯一不同的地方，就是推导dp[i][0]的时候，第i天买入股票的情况。
在 121. 买卖股票的最佳时机中，因为股票全程只能买卖一次，所以如果买入股票，那么第i天持有股票即dp[i][0]一定就是 -prices[i]。
而本题，因为一只股票可以买卖多次，所以当第i天买入股票的时候，所持有的现金可能有之前买卖过的利润。
代码如下：（注意代码中的注释，标记了和121.买卖股票的最佳时机唯一不同的地方）

public int maxProfit(int[] prices) {
// 动态规划
/*int[][] dp = new int[prices.length][2];
dp[0][0] = -prices[0];
dp[0][1] = 0;
for (int i = 1; i < prices.length; i++){
    dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1 ] - prices[i]);// 唯一不同的地方
    dp[i][1] = Math.max(dp[i - 1][0] + prices[i], dp[i - 1][1]);

    return dp[prices.length - 1][1];
}

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

123 买卖股票的最佳时机III

最多买卖两次

【动态规划】

一天一共就有五个状态，

没有操作
第一次买入
第一次卖出
第二次买入
第二次卖出

dp[i][j]中 i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天状态j所剩最大现金。

188 买卖股票的最佳时机IV

最多买卖k次

使用二维数组 dp[i][j] ：第i天的状态为j，所剩下的最大现金是dp[i][j]
j的状态表示为：

0 表示不操作
1 第一次买入
2 第一次卖出
3 第二次买入
4 第二次卖出
.....

可以发现规律：除了0以外，偶数就是卖出，奇数就是买入。

确定递推公式

达到dp[i][1]状态，有两个具体操作：

操作一：第i天买入股票了，那么dp[i][1] = dp[i - 1][0] - prices[i]
操作二：第i天没有操作，而是沿用前一天买入的状态，即：dp[i][1] = dp[i - 1][1]

dp[i][1] = max(dp[i - 1][0] - prices[i], dp[i - 1][1]);
同理dp[i][2]也有两个操作：

操作一：第i天卖出股票了，那么dp[i][2] = dp[i - 1][1] + prices[i]
操作二：第i天没有操作，沿用前一天卖出股票的状态，即：dp[i][2] = dp[i - 1][2]

dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])
同理可以类比剩下的状态，代码如下：

// 递推公式
for (int i = 1; i < len; i++) {
    for (int j = 0; j < 2 * k; j += 2) {
        dp[i][j + 1] = Math.max(dp[i - 1][j] - prices[i], dp[i - 1][j + 1]);
        dp[i][j + 2] = Math.max(dp[i - 1][j + 1] + prices[i], dp[i - 1][j + 2]);
    }
}

整体代码如下：

public int maxProfit(int k, int[] prices) {
    int len = prices.length;
    int[][] dp = new int[len][2 * k + 1];

    // 初始化
    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) {
            dp[i][j + 1] = Math.max(dp[i - 1][j] - prices[i], dp[i - 1][j + 1]);
            dp[i][j + 2] = Math.max(dp[i - 1][j + 1] + prices[i], dp[i - 1][j + 2]);
        }
    }

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

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

可以多次买卖，但是卖出后有冷冻期

（最后由于截图原因，正确return的是[1] [2] [3]）

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

可以多次买卖，但是卖出有手续费

同样两个状态，持有与不持有，本题只需要在计算卖出操作的时候减去手续费就可以了，代码几乎是一样的。
唯一差别在于递推公式部分，这里重申一下dp数组的含义：
dp[i][0] 表示第i天持有股票所省最多现金。 dp[i][1] 表示第i天不持有股票所得最多现金
如果第i天持有股票即dp[i][0]，那么可以由两个状态推出来

第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金即：dp[i - 1][0]
第i天买入股票，所得现金就是昨天不持有股票的所得现金减去今天的股票价格即：dp[i - 1][1] - prices[i]

所以：dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
在来看看如果第i天不持有股票即dp[i][1]的情况，依然可以由两个状态推出来

第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金即：dp[i - 1][1]
第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金，注意这里需要有手续费了即：dp[i - 1][0] + prices[i] - fee

所以：dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);
以上分析完毕，代码如下：

public int maxProfit(int[] prices, int fee) {
    int len = prices.length;
    int[][] dp = new int[len][2];
    dp[0][0] = 0;
    dp[0][1] = -prices[0];

    for (int i = 1; i < len; i++){
        dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i] - fee);// 不持有股票
        dp[i][1] = Math.max(dp[i - 1][0] - prices[i], dp[i - 1][1]); // 持有股票
    }

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

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

总结

至此，股票系列正式结束！
从买卖一次到买卖多次，从最多买卖两次到最多买卖k次，从冷冻期再到手续费，最后再来一个股票大总结，可以说对股票系列完美收官了。
详见详见：

学习资料：

股票问题总结篇

买卖股票时机系列问题 总结篇