1. 题目描述

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

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

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

示例 1:

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

示例 2:

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

示例 3:

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

提示：

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

    2. 解题思路

    （1）差价对比
    最直接的思路就是，当今天的价格高于昨天的价格就卖掉，赚今天和昨天的差价。

复杂度分析：

  • 时间复杂度：O(n)，其中n是数组的长度，我们需要将数组遍历一遍
  • 空间复杂度：O(1)，这里我们只需要额外的常数储存空间来储存今天和昨天的股票的差价

（2）动态规划
每个点的状态描述：手里有股票或者没股票。

1）dp[i][0]表示：第 i 天手里没股票，至今（第 i 天）的最大收益。第 i 天手里没股票，有两种可能：

  • 昨天也没持有股票：dp[i-1][0]
  • 昨天买了股票，今天卖了: dp[i-1][1] + prices[i]
  • dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])

2）dp[i][1]表示：第 i 天手里有股票，至今（第 i 天）的最大收益。第 i 天手里有股票，有两种可能：

  • 昨天也有股票：dp[i-1][1]
  • 昨天卖了，今天买了: dp[i-1][0] - prices[i]
  • dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i])

最终目标是求出：dp[prices.length-1][0]和dp[prices.length-1][1]的较大者，前者肯定>=后者，求dp[prices.length-1][0]即可。

对于开始：

  • day 0 没买:dp[0][0] = 0
  • day 0 买了:dp[0][1] = -prices[0]


复杂度分析：**

  • 时间复杂度：O(n)，其中 n 为数组的长度。一共有 2n 个状态，每次状态转移的时间复杂度为 O(1)，因此时间复杂度为 O(2n)=O(n)。
  • 空间复杂度：O(n)，我们需要开辟O(n) 空间存储动态规划中的所有状态。

    3. 代码实现

    （1）差价对比
    （2）动态规划 ```javascript /**
    • @param {number[]} prices
    • @return {number} */ function maxProfit(prices) { const len = prices.length; if (len < 2) { return 0; }; const dp = new Array(len); dp[0] = [0, -prices[0]]; for (let i = 1; i < len; i++) { dp[i] = new Array(2); 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[len - 1][0]; }

```

4. 提交结果

（1）差价对比
image.png
（2）动态规划
image.png