买卖股票的最佳时机 II

1.问题描述

1. 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

   设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

   注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

   示例 1:

   输入: [7,1,5,3,6,4]
   输出: 7
   解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
   随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。

   示例 2:

   输入: [1,2,3,4,5]
   输出: 4
   解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
   注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
   因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

   示例 3:

   输入: [7,6,4,3,1]
   输出: 0
   解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

   提示：

   • 1 <= prices.length <= 3 * 10 ^ 4
   • 0 <= prices[i] <= 10 ^ 4

2.求解

贪心算法

贪心算法 在每一步总是做出在当前看来最好的选择。

• 「贪心算法」 和 「动态规划」、「回溯搜索」 算法一样，完成一件事情，是 分步决策 的；

• 「贪心算法」 在每一步总是做出在当前看来最好的选择，我是这样理解 「最好」 这两个字的意思：

  • 「最好」 的意思往往根据题目而来，可能是 「最小」，也可能是 「最大」；
  • 贪心算法和动态规划相比，它既不看前面（也就是说它不需要从前面的状态转移过来），也不看后面（无后效性，后面的选择不会对前面的选择有影响），因此贪心算法时间复杂度一般是线性的，空间复杂度是常数级别的；

• 这道题 「贪心」 的地方在于，对于 「今天的股价 - 昨天的股价」，得到的结果有 3 种可能：① 正数，② 000，③负数。贪心算法的决策是： 只加正数 。

/*
 *执行用时：1 ms, 在所有 Java 提交中击败了99.54% 的用户
 *内存消耗：38.7 MB, 在所有 Java 提交中击败了62.30% 的用户
 */
public int maxProfit(int[] prices) {
    int ans = 0;
    int n = prices.length;
    for (int i = 1; i < n; ++i) {
        ans += Math.max(0, prices[i] - prices[i - 1]);
    }
    return ans;
}

动态规划

• 使用dp[i][0]表示第i天手里没有股票的收益

  dp[i][1]表示第i天手里有股票的收益

  则初始化dp[0][0] = 0，dp[0][1] = -prices[0]，第一天买入了股票，是负收益

• 第i天手里没有股票的收益如何计算，它应该取（前一天手里没有股票的收益，前一天有股票卖出了的收益）中的最大值

  第i天手里有股票的收益收益如何计算，应该取（前一天手里有股票的收益，前一天没有股票然后买入了股票的收益）中的最大值

• 最后结果返回最后最后一天手里没有股票的收益

    /*
     *执行用时：4 ms, 在所有 Java 提交中击败了12.95% 的用户
     *内存消耗：38.5 MB, 在所有 Java 提交中击败了83.04% 的用户
     */
	public int maxProfit(int[] prices) {
        int n = prices.length;
        int dp[][] = new int[n][2];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for(int i = 1; i < n; i++){
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
        } 
        return dp[n - 1][0];
    }

• 时间复杂度：O(N)，这里 N 表示股价数组的长度；
• 空间复杂度：O(N)，虽然是二维数组，但是第二维是常数，与问题规模无关。

动态规划优化空间

• 如果不想知道具体的买卖细节，只想知道最大的利润是多少，可以使用贪心算法或者使用滚动变量的动态规划
• 由于本题中的动态方程的值只参考上一行，因此我们可以考虑只记录本次和上次的情况

代码如下

    /*
     *执行用时：2 ms, 在所有 Java 提交中击败了26.63% 的用户
     *内存消耗：38.3 MB, 在所有 Java 提交中击败了87.69% 的用户
     */
    public int maxProfit(int[] prices) {
        int len = prices.length;
        if(len < 2){
            return 0;
        }

        // cash：持有现金
        // hold：持有股票
        // 状态转移：cash → hold → cash → hold → cash → hold → cash
        // 定义第一天的cash和hold
        int cash = 0;
        int hold = - prices[0];

        // 定义前一天的情况
        int preCash = 0;
        int preHold = - prices[0];
        for(int i = 1; i < len; i++){
            cash = Math.max(preCash,preHold + prices[i]);
            hold = Math.max(preHold, preCash - prices[i]);
            preCash = cash;
            preHold = hold;
        }
        return cash;
    }

• 时间复杂度：O(N)，这里 N 表示股价数组的长度；
• 空间复杂度：O(1)，分别使用两个滚动变量，将一维数组状态优化到常数大小。