代码随想录算法训练营第四十三天| 121. 买卖股票的最佳时机、122.买卖股票的最佳时机II、 123.买卖股票的最佳时机III

121. 买卖股票的最佳时机

题目链接：121. 买卖股票的最佳时机
文档讲解：代码随想录
状态：做出来了

贪心思路： 因为股票就买卖一次，那么贪心的想法很自然就是取最左最小值，取最右最大值，那么得到的差值就是最大利润。

动态规划思路：
每天的状态要么是持有股票要么是不持有，那么手头的钱就可以分为：dp[i][0]表示第i天持有当前股票的最大利润、dp[i][0]表示第i天不持有当前股票的最大利润。那么这个状态如何变化的呢？

dp[i][0]持有： 既然持有的话，说明第i-1天是持有且没有卖，或者第i-1天不持有，但是买入第i天的股票了。所以dp[i][0] = max(dp[i-1][0],-price[i])
为啥不是dp[i-1][1]-price[i]呢？因为题中股票只能买卖一次，所以是初始资金0-price[i]！

dp[i][1]不持有： 既然不持有的话，说明第i-1天是持有但是卖掉了，或者第i-1天也不持有。所以dp[i][1] = max(dp[i-1][1], dp[i-1][0] + price[i])

那么如何初始化呢？
第0天如果持有股票，那肯定是买入了，所以dp[0][0] = -price[0]。
第0天如果不持有股票，那肯定是没买入，所以dp[0][0] = 0。

题解：

    //贪心
    public int maxProfit(int[] prices) {
        int minIn = Integer.MAX_VALUE;
        int res = 0;
        for (int price : prices) {
            minIn = Math.min(minIn, price);
            res = Math.max(res, price - minIn);
        }
        return res;
    }

    //    动态规划
    public int maxProfit2(int[] prices) {
        int n = prices.length;
        int[][] dp = new int[n][2];

        // 第0天持有股票的利润是购买第0天的股票后的负值
        dp[0][0] = -prices[0];
        // 第0天不持有股票的利润是0
        dp[0][1] = 0;

        for (int i = 1; i < n; i++) {
            // 对于第i天，持有股票的状态，最大利润是以下两者中的较大值：
            // 1. 第i-1天已经持有股票的利润（即dp[i-1][0]）
            // 2. 第i天买入股票后的利润，因为只能买卖一次，所以是初始资金0减去当前价格（即-price[i]）
            dp[i][0] = Math.max(dp[i - 1][0], -prices[i]);

            // 对于第i天，不持有股票的状态，最大利润是以下两者中的较大值：
            // 1. 第i-1天已经不持有股票的利润（即dp[i-1][1]）
            // 2. 第i天卖出股票后的利润，即第i-1天持有股票的利润加上今天卖出的价格（即dp[i-1][0] + prices[i]）
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
        }

        // 返回第n-1天时持有或不持有股票状态中的最大值
        // 因为只能买卖一次，所以最终结果可能是持有股票但还未卖出的状态（dp[n-1][0]）
        // 也可能是已经卖出股票后的状态（dp[n-1][1]）
        return Math.max(dp[n - 1][0], dp[n - 1][1]);//其实本题中最后不持有股票状态所得金钱一定比持有股票状态得到的多,所以也可以dp[n-1][1]
    }

    //优化
    public int maxProfit3(int[] prices) {
        int[] dp = new int[2];
        // 记录一次交易，一次交易有买入卖出两种状态
        // 0代表持有，1代表卖出
        dp[0] = -prices[0];
        dp[1] = 0;
        // 可以参考斐波那契问题的优化方式
        // 我们从 i=1 开始遍历数组，一共有 prices.length 天，
        // 所以是 i<=prices.length
        for (int i = 1; i <= prices.length; i++) {
            // 前一天持有；或当天买入
            dp[0] = Math.max(dp[0], -prices[i - 1]);
            // 如果 dp[0] 被更新，那么 dp[1] 肯定会被更新为正数的 dp[1]
            // 而不是 dp[0]+prices[i-1]==0 的0，
            // 所以这里使用会改变的dp[0]也是可以的
            // 当然 dp[1] 初始值为 0 ，被更新成 0 也没影响
            // 前一天卖出；或当天卖出, 当天要卖出，得前一天持有才行
            dp[1] = Math.max(dp[1], dp[0] + prices[i - 1]);
        }
        return dp[1];
    }

122.买卖股票的最佳时机II

题目链接：122.买卖股票的最佳时机II
文档讲解：代码随想录
状态：还行

思路：
贪心的思路，在贪心章节有讲。
动态规划思路：和上一题不同的地方在于，这道题买卖不限次数，所以在上一题的基础上，dp[i][0] = max(dp[i-1][0],dp[i-1][1]-price[i])

题解：

    //动态规划
    public int maxProfit2(int[] prices) {
        // 检查输入数组是否为空或长度为0
        if (prices == null || prices.length == 0) {
            return 0;
        }

        // 初始化两个变量:
        // noStock表示当前不持有股票的最大利润
        // hasStock表示当前持有股票的最大利润
        int noStock = 0;
        int hasStock = -prices[0]; // 第一天买入股票

        // 从第二天开始遍历股票价格数组
        for (int i = 1; i < prices.length; i++) {
            // 更新不持有股票的最大利润:
            // 1. 前一天也不持有股票，利润保持不变
            // 2. 前一天持有股票，今天卖出，利润为 hasStock + prices[i]
            noStock = Math.max(noStock, hasStock + prices[i]);

            // 更新持有股票的最大利润:
            // 1. 前一天也持有股票，利润保持不变
            // 2. 前一天不持有股票，今天买入，利润为 noStock - prices[i]
            hasStock = Math.max(hasStock, noStock - prices[i]);
        }

        // 返回最终不持有股票的最大利润，因为最终状态应该是不持有股票
        return noStock;
    }

123.买卖股票的最佳时机III

题目链接：123.买卖股票的最佳时机III
文档讲解：代码随想录
状态：不会

思路： 关键在于至多买卖两次，这意味着可以买卖一次，可以买卖两次，也可以不买卖。

一天一共就有五个状态：

0. 没有操作 （其实我们也可以不设置这个状态）
1. 第一次持有股票
2. 第一次不持有股票
3. 第二次持有股票
4. 第二次不持有股票

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

操作一：第i天买入股票了，那么dp[i][1] = dp[i-1][0] - prices[i]
操作二：第i天没有操作，而是沿用前一天买入的状态，即：dp[i][1] = dp[i - 1][1]
那么dp[i][1]究竟选 dp[i-1][0] - prices[i]，还是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])

同理可推出剩下状态部分：

dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);

dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i])

dp数组如何初始化？
第0天没有操作，这个最容易想到，就是0，即：dp[0][0] = 0;
第0天做第一次买入的操作，dp[0][1] = -prices[0];
第0天做第一次卖出的操作，当天买入，当天卖出，所以dp[0][2] = 0;
第0天第二次买入操作，当天买入，卖出，再买入，dp[0][3] = -prices[0];
同理第二次卖出初始化dp[0][4] = 0；

题解：

// 版本一
class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;
        // 边界判断, 题目中 length >= 1, 所以可省去
        if (prices.length == 0) return 0;

        /*
         * 定义 5 种状态:
         * 0: 没有操作, 1: 第一次买入, 2: 第一次卖出, 3: 第二次买入, 4: 第二次卖出
         */
        int[][] dp = new int[len][5];
        dp[0][1] = -prices[0];
        // 初始化第二次买入的状态是确保 最后结果是最多两次买卖的最大利润
        dp[0][3] = -prices[0];

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

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

// 版本二: 空间优化
   public int maxProfit(int[] prices) {
        // 初始化第一次买卖的状态
        int hasStock1 = -prices[0];
        int noStock1 = 0;
        // 初始化第二次买卖的状态
        int hasStock2 = -prices[0];
        int noStock2 = 0;

        // 遍历股票价格数组
        for (int i = 1; i < prices.length; i++) {
            // 更新第一次买卖持有股票的最大利润
            // !!在第一次买入股票时，我们应该考虑在之前没有任何交易的情况下直接买入股票的情况，即0 - prices[i]。
            hasStock1 = Math.max(hasStock1, 0 - prices[i]);
            // 更新第一次买卖不持有股票的最大利润
            noStock1 = Math.max(noStock1, hasStock1 + prices[i]);
            // 更新第二次买卖持有股票的最大利润
            // !!第二次买入股票操作时，用的是第一次交易的最大利润，即noStock1。
            hasStock2 = Math.max(hasStock2, noStock1 - prices[i]);
            // 更新第二次买卖不持有股票的最大利润
            noStock2 = Math.max(noStock2, hasStock2 + prices[i]);
        }
        // 返回第二次买卖不持有股票的最大利润
        return noStock2;
    }