LeetCode-动态规划买卖股票的最佳时机

Posted 2021-02-27 Flix

题目描述

给定一个数组，它的第?i 个元素是一支给定股票第 i 天的价格。
如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。
注意：你不能在买入股票前卖出股票。
示例：

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

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

题目链接： https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/

思路1

暴力法。使用两层循环，当外层循环到i时，内层判断prices[i]与price[0...i-1]之间的差值，并记录最大差值。代码如下：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.empty()) return 0;

        int curMax = 0;
        for(int i=0; i<prices.size(); i++){
            for(int j=0; j<i; j++){
                if(prices[i]>prices[j]){
                    curMax = max(prices[i]-prices[j], curMax);
                }
            }
        }
        return curMax;
    }
};
// 超时

• 时间复杂度：O(n^2)
• 空间复杂度：O(1)
  该方法由于超时未通过。

思路2

想要获取最大利润，我们需要在最低点买入，然后在之后的最高点卖出。所以使用一个变量minPrice记录当前的最低点，遍历数组prices：

• 如果prices[i]<minPrice，说明有了更低的价格，则我们在prices[i]买入，也就是将minPrice更新为prices[i];
• 如果prices[i]>=minPrice，则我们可以在prices[i]的价格将其卖出，记录最大的差价。

代码如下：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.empty()) return 0;

        int curMax = 0;
        int minPrice = 0x7fffffff;
        for(int i=0; i<prices.size(); i++){
            if(minPrice>prices[i]){
                minPrice = prices[i];
            }else{
                curMax = max(prices[i]-minPrice, curMax);
            }
        }
        return curMax;
    }
};

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

思路3

动态规划。为了获得最大的利润，我们在当前位置i买入时，将i之后最高的价格减去位置i的价格即可，所以使用dp[i]表示位置i之后价格的最大值，则递推公式为dp[i] = max(prices[i+1], dp[i+1])，从后往前递推，则在位置i的最大利润为dp[i]-prices[i]，记录最大利润返回即可。代码如下：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.empty()) return 0;

        int curMax = 0;
        int len = prices.size();
        vector<int> dp(len, 0);
        dp[len-1] = prices[len-1];
        for(int i=prices.size()-2; i>=0; i--){
            dp[i] = max(prices[i+1], dp[i+1]);
            curMax = max(dp[i]-prices[i], curMax);
        }
        return curMax;
    }
};

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

思路4

可以将思路3的dp数组用一个变量highestPrice来替代，这样就可以把空间复杂度降为O(1)。代码如下：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.empty()) return 0;

        int curMax = 0;
        int len = prices.size();
        int highestPrice = prices[len-1];
        for(int i=prices.size()-2; i>=0; i--){
            highestPrice = max(prices[i+1], highestPrice);
            curMax = max(highestPrice-prices[i], curMax);
        }
        return curMax;
    }
};

这样就类似于思路2了，思路2是从前往后记录最小值，思路4是从后往前记录最大值。

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