[LeetCode] 121、买卖股票的最佳时机

题目描述

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

如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。

注意你不能在买入股票前卖出股票。

输入: [7,1,5,3,6,4]
输出: 5 (6 - 1 = 5)

参考答案

注：股票系列问题按照：121、122、309、714、123、188的顺序看。（通用模板在188题处）

保存并不断更新之前的最小值（最低股价）

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int maxDiff = 0;
        int length = prices.size();
        if(length < 2)
            return maxDiff;
        
        int preMin = INT_MAX;  // 保存之前最低的价格（第一次保存成了最高的价格，导致出错）
        for(int i = 1; i < length; i++){
            preMin = min(preMin, prices[i-1]);
            maxDiff = max(maxDiff, prices[i] - preMin);
        }
        
        return maxDiff;
    }
};

一个通用方法团灭 6 道股票问题

// 状态转移方程
// dp[i][1][0] = max(dp[i-1][1][0], dp[i-1][1][1] + prices[i])
// dp[i][1][1] = max(dp[i-1][1][1], dp[i-1][0][0] - prices[i]) 
//             = max(dp[i-1][1][1], -prices[i])
// 解释：k = 0 的 base case，所以 dp[i-1][0][0] = 0。
//
// 现在发现 k 都是 1，不会改变，即 k 对状态转移已经没有影响了。
// 可以进行进一步化简去掉所有 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])

// 在循环中处理basecase
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int length = prices.size();
        if(length <= 1)
            return 0;
        
        int dp[length][2];
        memset(dp, 0, sizeof(dp));
        for (int i = 0; i < length; i++) {
            if (i - 1 == -1) {
                dp[i][0] = 0;
                // 解释：
                //   dp[i][0] 
                // = max(dp[-1][0], dp[-1][1] + prices[i])
                // = max(0, -infinity + prices[i]) = 0
                dp[i][1] = -prices[i];
                //解释：
                //   dp[i][1] 
                // = max(dp[-1][1], dp[-1][0] - prices[i])
                // = max(-infinity, 0 - prices[i]) 
                // = -prices[i]
                continue;
            }
            
            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[length - 1][0];
    }
};

// 提前处理basecase
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int length = prices.size();
        if(length <= 1)
            return 0;
        
        int dp[length][2];
        memset(dp, 0, sizeof(dp));
        dp[0][0] = 0, dp[0][1] = -prices[0];
        for (int i = 1; i < length; 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[length - 1][0];
    }
};

// 注意一下状态转移方程，新状态只和相邻的一个状态有关，其实不用整个 dp 数组，
// 只需要一个变量储存相邻的那个状态就足够了，这样可以把空间复杂度降到 O(1)。
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int length = prices.size();
        if(length <= 1)
            return 0;
        
        // 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 < length; 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;
    }
};

// 或者提前处理i == 0时的basecase （推荐这种解法，更好理解）
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int length = prices.size();
        if(length <= 1)
            return 0;
        
        // base case: dp[-1][0] = 0, dp[-1][1] = -infinity
        int dp_i_0 = 0, dp_i_1 = -prices[0];
        for (int i = 1; i < length; 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;
    }
};