【面试系列】买卖股票的最佳时机系列

买卖股票的最佳时机：
原题链接

思路：

• 思路$1$：
  考虑枚举第$k$天买入，那么$[k+1,n]$天都可以卖出，所以考虑第$k$天后，大于第$k$天价格的最大价格。那么就是一个经典的单调栈问题，求每个数字后的最大数。
  该解决方法可以返回第$k$天买入后，之后卖出可获得的最大利润。
  时间复杂度：$O(n)$，空间复杂度：$O(n)$

• 思路$2$：
  根据思路$1$，那么时间复杂度不可再优，考虑如何优化空间复杂度。
  思路$1$是从前往后看，我们可以考虑从后往前看，即枚举第$k$天卖出，那么需要$[1,k-1]$天中最小的那天买入即可，维护一个最小的买入时间。
  时间复杂度：$O(n)$，空间复杂度：$O(1)$

代码：

• 代码$1$：

class Solution {
public:
    int maxProfit(vector<int>& p) {
        vector<int> stk;
        stk.push_back(p[0]);
        
        int res = 0;
        for(int i = 1; i < p.size(); ++i) {
            while(!stk.empty() && stk.back() >= p[i]) stk.pop_back();
            if(!stk.empty()) res = max(res, p[i] - stk[0]);
            stk.push_back(p[i]);
        }
        return res;
    }
};

• 代码$2$：

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

---

买卖股票的最佳时机II
原题链接

思路：
本题一天内可以多次买入卖出股票，那么我们就可以做一个短视的人，只要当前这天卖出相对于前一天可以获得正利润，那么我们就当前天卖出，也就是我们第$k$天是否买入取决于第$k+1$天卖出后是否可以获得正利润，如果可以我们第$k$天就买入，然后在第$k+1$天卖出。
最后的代码实现上，我们只需要和$0$取个$max$，如果是$0$说明第$k$天没必要买入。

代码：

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

---

买卖股票的最佳时机III
原题链接

思路
由于最多只有两次买售，且两次买售不能在同一天，因此可以考虑每次买入卖出的情况。
我们设置$dp[n][4]$，$dp[i][0],dp[i][1],dp[i][2],dp[i][3]$分别表示在第$i$天时的第一次买入，第一次卖出，第二次买入，第二次卖出。那么状态转移如下：

• $dp[i][3]=max(dp[i-1][3],dp[i-1][2]+p[i])$
• $dp[i][2]=max(dp[i-1][2],dp[i-1][1]-p[i])$
• $dp[i][1]=max(dp[i-1][1],dp[i-1][0]+p[i])$
• $dp[i][0]=max(dp[i-1][0],-p[i])$

其中初始化时，由于可能出现递减的情况，
那么最差的情况就是不进行买售，此时利润为$0$。
因此初始化为： d p [ 0 ] = { − p [ 0 ] , 0 , − p [ 0 ] , 0 } dp[0]=\{-p[0],0,-p[0],0\} dp[0]={−p[0],0,−p[0],0}，之后从$1$开始遍历
最后返回$dp[3]$即可

那么由于每次只会用到前一次的答案，所以自然会想到滚动数组模拟
所以我们可以去掉一维，然后倒序枚举状态转移即可。

代码：

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