LeetCode 刷题 [C++] 第122题. 买卖股票的最佳时机 II (贪心算法与动态规划)

题目描述

给定一个数组，它的第 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

方法一：贪心算法

贪心算法本质为在每一步总是做出在当前看来最好的选择。
这道题「贪心」的地方在于，对于「明天的股价 - 今天的股价」，得到的结果有3种可能：正数、0、负数。贪心算法的决策是：只加正数。

解题步骤：

1. 令temp为第i日买入与第 i+1 日卖出赚取的利润，即 temp = prices[i+1] - prices[i] ；
2. 当该天利润为正 temp > 0，则将利润加入总利润 res；当利润为 0 或为负，则直接跳过；
3. 遍历完成后，返回总利润 res。

具体实现代码如下：

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

复杂度分析：
时间复杂度：O(N)，这里N表示股价数组的长度；
空间复杂度：O(1)。
AC结果：

方法二：动态规划

题目中规定不能够同时参与多笔交易，那么当天交易完成后，手中持有股票只可能是 0 支或者 1 支。这里我们可以使用动态规划的思路来解决。

第 1 步：定义状态

• 令 dp[i][0] 表示第 i 天交易完成手中不持有股票的最大金额数；
• 令 dp[i][1] 表示第 i 天交易完成后手中持有一支股票的最大金额数。

第 2 步：状态转移方程
dp[i][0] 表示第 i 天交易完成手中不持有股票的最大金额数，出现这样的情况可能是：

• 第 i−1 天不持有股票，第 i 天无交易；
• 第 i−1 天持有股票，但是第 i 天将其卖出，获取利润。

那么 dp[i][0] 的转移方程如下：
dp[i][0]=max(dp[i−1][0],dp[i−1][1]+prices[i])
而 dp[i][1] 表示第 i 天交易完成后手中持有一支股票的最大金额数，同样可能出现的情况如下：

• 第 i−1 天持有股票，第 i 天无交易；
• 第 i−1 天不持有股票，第 i 天买入。

此时 dp[i][1] 的转移方程如下：
dp[i][1]=max(dp[i−1][1],dp[i−1][0]−prices[i])

第 3 步：确定初始值
起始的时候：

• 如果什么都不做，dp[0][0] = 0；
• 如果持有股票，当前拥有的现金数是当天股价的相反数，即 dp[0][1] = -prices[i]；

第 4 步：确定输出值
终止的时候，上面也分析了，输出 dp[len - 1][0]，因为一定有 dp[len - 1][0] > dp[len - 1][1]。

具体实现代码如下：

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

AC结果：

优化：
在前面的方法中，我们可以发现当天的状态值只与前一天的状态值有关。那么这里可以进行优化，用两个变量来存储前一天的状态值，用以计算后面一天状态值。然后去维护更新这两个变量。

具体的代码实现如下：

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

复杂度分析：

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

AC结果：