代码随想录算法训练营Day49|LC121 买卖股票的最佳时机&122 买卖股票的最佳时机II

一句话总结：贪心就很容易了，但这里是动态规划的主场！

原题链接：121 买卖股票的最佳时机

老题新做。这题本来用贪心思想一趟遍历就可以解决：

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int ans = 0;
        int mn = 10001;
        for (int i = 0; i < n; ++i) {
            mn = Math.min(mn, prices[i]);
            ans = Math.max(ans, prices[i] - mn);
        }
        return ans;
    }
}

现在改用动态规划算法，那么通过动规五部曲逐步分析如下：

1. 确定dp数组与其下标含义：需要用一个长度为2的数组来表示不同的状态：dp[i][0]表示第i天持有一只股票的最大收益，dp[i][1]表示第i天手上没有股票的最大收益。可以明确的一点是，最后收益最大时一定是dp[prices.length - 1][1]。
2. 确定递推公式：dp[i][0]可从以下两种状态转移过来：

   1. 第i - 1天即持有股票，那么保持原状，dp[i][0] = dp[i - 1][0]；
   2. 第i - 1天手上未持有股票，那么需要购买股票，dp[i][0] = -priices[i]；
   3.  dp[i][0]一定是从这两种状态转移而来，因此收益取其较大者，即有dp[i][0] = Math.max(dp[i - 1][0], -prices[i])。 

3. dp数组的初始化：从两个递推公式可以看出，该dp数组的递推依赖于dp[0][0]和dp[1][0]，因此需要对该两者初始化。第0天手上持有一支股票，那么其最大收益即为-prices[0]，于是dp[0][0]即可初始化为：dp[0][0] = -prices[0]；第0天手上没有股票，那么收益为0，即dp[1][0] = 0。
4. dp数组的遍历顺序：从前面的递推公式可以看出，第i天的状态计算依赖于第i - 1天的状态，因此需要从前往后遍历。
5. 举例推导dp数组。

由此可得代码如下：

class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) return 0;
        int length = prices.length;
        // dp[i][0]代表第i天持有股票的最大收益
        // dp[i][1]代表第i天不持有股票的最大收益
        int[][] dp = new int[length][2];
        int result = 0;
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < 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[length - 1][1];
    }
}

此代码存在明显优化空间：根据滚动数组原理， 可将dp数组省略掉，最后只需要两个变量即可完成。最后整体代码如下：

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int buy = -prices[0];
        int seal = 0;;
        for (int i = 1; i < n; ++i) {
            buy = Math.max(buy, -prices[i]);
            seal = Math.max(seal, prices[i] + buy);
        }
        return seal;
    }
}

原题链接：122 买卖股票的最佳时机II

首先也是贪心的解法，一趟遍历即可搞定：

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int ans = 0;
        for (int i = 1; i < n; ++i) {
            ans += prices[i] > prices[i - 1] ? prices[i] - prices[i - 1] : 0;
        }
        return ans;
    }
}

 动规分析过程：与上一题极度相似。有差别的点在于解除了只能买卖一次的限制，因此在第2步确定dp数组的递推公式时，需要将前几天的收益考虑进来，即dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] - prices[i])。其他部分与前一题完全一致。

最后整体代码如下：

class Solution {
    public int maxProfit(int[] prices) {
        int buy = -prices[0], seal = 0;
        for (int i = 1; i < prices.length; ++i) {
            buy = Math.max(buy, seal - prices[i]);
            seal = Math.max(seal, buy + prices[i]);
        }
        return seal;
    }
}