Day49｜动态规划part10：188.买卖股票的最佳时机IV、121. 买卖股票的最佳时机、122.买卖股票的最佳时机II

188. 买卖股票的最佳时机IV

leetcode链接：188 题「买卖股票的最佳时机 IVopen in new window」

视频链接：动态规划来决定最佳时机，至多可以买卖K次！| LeetCode：188.买卖股票最佳时机4

给你一个整数数组 prices 和一个整数 k ，其中 prices[i] 是某支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说，
你最多可以买 k 次，卖 k 次。

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

示例 1：

输入：k = 2, prices = [2,4,1]
输出：2
解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，
  这笔交易所能获得利润 = 4-2 = 2 。

示例 2：

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

接下来的解法来自labuladong的算法 ，从最难的188题入手，限制最多。用状态机的形式进行状态转移。

对于每天的股票，有三种选择：买，卖，不买也不卖。我们用 buy, sell, rest 表示这三种选择。但每次这三种状态不是随便选的:

• 因为 sell 必须在 buy 之后（对于交易次数设置为无限次时，只能先卖掉手里的再买）
• buy 必须在 sell 之后（手里有股票了才能卖）。
• 那么 rest 操作还应该分两种状态，一种是 buy 之后的 rest（持有了股票），一种是 sell 之后的 rest（没有持有股票）。
• 交易次数 k 的限制，就是说你 buy 还只能在 k > 0 的前提下操作

1. 确定dp数组的含义及下标

我们的dp数组应该是几维的？这个问题的「状态」有三个，第一个是天数，第二个是允许交易的最大次数，第三个是当前的持有状态（即之前说的 rest 的状态，我们不妨用 1 表示持有，0 表示没有持有）。然后我们用一个三维数组就可以装下这几种状态的全部组合：

dp[i][k][0 or 1]
0 <= i <= n - 1, 1 <= k <= K
n 为天数，大 K 为交易数的上限，0 和 1 代表是否持有股票。
此问题共 n × K × 2 种状态，全部穷举就能搞定。

for 0 <= i < n:
    for 1 <= k <= K:
        for s in {0, 1}:
            dp[i][k][s] = max(buy, sell, rest)

比如说 dp[3][2][1] 的含义就是：今天是第三天，我现在手上持有着股票，至今最多进行 2 次交易。再比如 dp[2][3][0] 的含义：今天是第二天，我现在手上没有持有股票，至今最多进行 3 次交易。

我们想求的最终答案就是：dp[n - 1][k][0] ，因为最后一天卖出肯定比不卖出赚的多，因此求的不是dp[n-1][k][1] 。

2. 确定递推公式

我们可以画出如下的状态转移图：

因此我们可以分两种状态：dp[i][k][0]和dp[i][k][1] 。

dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
              max( 今天选择 rest,        今天选择 sell       )

解释：今天我没有持有股票，有两种可能，我从这两种可能中求最大利润：

1、我昨天就没有持有，且截至昨天最大交易次数限制为 k；然后我今天选择 rest，所以我今天还是没有持有，最大交易次数限制依然为 k。

2、我昨天持有股票，且截至昨天最大交易次数限制为 k；但是今天我 sell 了，所以我今天没有持有股票了，最大交易次数限制依然为 k。

dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
              max( 今天选择 rest,         今天选择 buy         )

解释：今天我持有着股票，最大交易次数限制为 k，那么对于昨天来说，有两种可能，我从这两种可能中求最大利润：

1、我昨天就持有着股票，且截至昨天最大交易次数限制为 k；然后今天选择 rest，所以我今天还持有着股票，最大交易次数限制依然为 k。

2、我昨天本没有持有，且截至昨天最大交易次数限制为 k - 1；但今天我选择 buy，所以今天我就持有股票了，最大交易次数限制为 k。

• 状态 k 的定义并不是「已进行的交易次数」，而是「最大交易次数的上限限制」。
• 在 sell 的时候给 k 减小 1 和在 buy 的时候给 k 减小 1 是并不是等效，因为交易是从 buy 开始，如果 buy 的选择不改变交易次数 k 的话，会出现交易次数超出限制的的错误。也就是说买的时候k - 1卖的时候不减。

这是一个反向的过程，是推图的入边而不是出边。

3. 确定dp初始化

dp[-1][...][0] = 0
解释：因为 i 是从 0 开始的，所以 i = -1 意味着还没有开始，这时候的利润当然是 0。

dp[-1][...][1] = -infinity
解释：还没开始的时候，是不可能持有股票的。
因为我们的算法要求一个最大值，所以初始值设为一个最小值，方便取最大值。

dp[...][0][0] = 0
解释：因为 k 是从 1 开始的，所以 k = 0 意味着根本不允许交易，这时候利润当然是 0。

dp[...][0][1] = -infinity
解释：不允许交易的情况下，是不可能持有股票的。
因为我们的算法要求一个最大值，所以初始值设为一个最小值，方便取最大值。

至于-1 怎么编程表示出来呢，负无穷怎么表示呢？这都是细节问题，有很多方法实现。

4. 确定遍历顺序

因此天数是从小到大的，因此遍历顺序肯定是从前往后。

5. 循环打印dp数组

这样我们就确定了买卖股票问题的框架，其他的题目都是这题的特殊情况。

121. 买卖股票的最佳时机

这题就是上面说的只交易一次，就是k = 1的情况。

leetcode链接：力扣题目链接

视频链接：：动态规划之 LeetCode：121.买卖股票的最佳时机1

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 
卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：

输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，
最大利润 = 6-1 = 5 。
     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

示例 2：

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

暴力解法

首先就是暴力解法，两个for循环，寻找最大的间距（这里注意左边的一定要比右边小）

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int maxValue = 0;
        for(int i = 0; i < prices.size(); i++){
            for(int j = i + 1; j < prices.size(); j++){
                maxValue = max(prices[j] - prices[i],maxValue);
            }
        }
        return maxValue;
    }
};

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

最后直接超时了，直接看动态规划解法。

贪心解法

这题是可以贪心做的，直觉就是取最小的买入，然后result = max(result, prices[i] - low); // 直接取最大区间利润保证利润为正：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int low = INT_MAX;
        int result = 0;
        for (int i = 0; i < prices.size(); i++) {
            low = min(low, prices[i]);  // 取最左最小价格
            result = max(result, prices[i] - low); // 直接取最大区间利润
        }
        return result;
    }
};

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

动态规划

1. 确定DP数组下标及其含义

因为这题k = 1，因此可以把k那一维简化变为二维数组：

故dp[i][0]/dp[i][1]表示今天是第i天，我手上是否持有股票，的最大利润

2. 确定dp的递推公式

之前是：
dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])

现在去掉了k的维：
dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
dp[i][1] = max(dp[i-1][1], -prices[i])

这里为什么是-price[i] ?
-prices[i]只出现在k = 1的情况。因为如果只有一次交易的话，那每天的dp[i][1]状态（第i天手持股票）只会是因为我在当天购买了股票，使得我目前的资本为-prices[I]，所以是负数。每天的dp[i][1]状态不会依赖于dp[i-1][0]， 也就是当k =1的时候dp[i][1] 不等于dp[i-1][0] - prices[I]。

3. dp数组的初始化

之前是：dp[-1][...][0] = dp[...][0][0] = 0
dp[-1][...][1] = dp[...][0][1] = -infinity

去掉了k维后：
dp[0][0] = 0;
dp[0][1] = -infinity

4. 遍历顺序

因为跨度是时间，从前往后。

5. 打印dp数组

最终代码：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        vector<vector<int>> dp (prices.size(),vector<int>(2));
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for(int i = 1; i < prices.size(); i++){
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]);
            dp[i][1] = max(dp[i-1][1], -prices[i]);
        }
        return dp[prices.size() - 1][0];
    }
};

还可以不使用dp数组，直接使用2个变量节省空间：

// 空间复杂度优化版本
int maxProfit_k_1(vector<int>& prices) {
    int n = prices.size();
    // base case: dp[-1][0] = 0, dp[-1][1] = -infinity
    int dp_i_0 = 0, dp_i_1 = INT_MIN;
    for (int i = 0; i < n; i++) {
        // dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
        dp_i_0 = max(dp_i_0, dp_i_1 + prices[i]);
        // dp[i][1] = max(dp[i-1][1], -prices[i])
        dp_i_1 = max(dp_i_1, -prices[i]);
    }
    return dp_i_0;
}

这个解法了解就行了，先解决一般的解法再说。

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

这题相比k是无限制的。

leetcode链接：「买卖股票的最佳时机 IIopen in new window」

视频链接：动态规划来决定最佳时机，至多可以买卖K次！| LeetCode：188.买卖股票最佳时机4

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。
你也可以先购买，然后在 同一天 出售。

返回 你能获得的 最大 利润 。

示例 1：

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

示例 2：

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
     总利润为 4 。
  
示例 3：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。

贪心解法

这题在贪心部分就已经做过了，贪心思想就是当天比前一天大就卖出，最终代码：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
      int result = 0;
      for(int i = 1; i < prices.size(); i++){
          if(prices[i] - prices[i - 1] > 0){
              result += prices[i] - prices[i - 1];
          }
      }
      return result;
    }
};

动态规划

1. 确定dp数组下标及其含义

这题相当于k为正无穷的情况。如果 k 为正无穷，那么就可以认为 k 和 k - 1 是一样的。因为也就不需要记录k这个状态了， 因此故dp[i][0]/dp[i][1] 表示今天是第i天，我手上是否持有股票，的最大利润

2. 确定dp递推公式

之前是：
dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
又因为k可以看作和k - 1一样，可以看成：
dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
            = max(dp[i-1][k][1], dp[i-1][k][0] - prices[i])

现在去掉了k的维：
dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i])

这里就不是-price[i]了，因为k - 1不等于0。

3. dp数组的初始化：

之前是：
dp[0][0] = 0;
dp[0][1] = -infinity

在代码中表现为；
        dp[0][0] = 0;
        dp[0][1] = -prices[0];

4. 遍历顺序

从前往后

5. 打印dp数组

最终代码 ：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        vector<vector<int>> dp (prices.size(),vector<int>(2));
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for(int i = 1; i < prices.size(); i++){
            dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]);
            dp[i][1] = max(dp[i-1][1], dp[i-1][0] -prices[i]);//原来是-prices[i]
        }
        return dp[prices.size() - 1][0];
    }
};

这里就改了第9行的递推公式。

空间简化版：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        // base case: dp[-1][0] = 0, dp[-1][1] = -infinity
        int dp_i_0 = 0, dp_i_1 = INT_MIN;
        for (int i = 0; i < n; i++) {
            // dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
            dp_i_0 = max(dp_i_0, dp_i_1 + prices[i]);
            // dp[i][1] = max(dp[i-1][1], dp[i-1][0]-prices[i])
            dp_i_1 = max(dp_i_1, dp_i_0-prices[i]);
        }
        return dp_i_0;
    }
};

总结

• 买卖股票问题，有的能用贪心解决效率更高，但动态规划是统一方法，必须掌握，贪心不一定能想到
• 买卖股票问题有很多变种，记住最复杂的：dp[i][k][0]，三位数组，其他的都是在上面做加减法。