LeetCode Best Time to Buy and Sell Stock专题

最新推荐文章于 2021-02-02 13:55:50 发布

友谊无价

最新推荐文章于 2021-02-02 13:55:50 发布

阅读量156

点赞数

分类专栏： LeetCode 文章标签：算法

本文链接：https://blog.csdn.net/qq_24294439/article/details/107505043

版权

LeetCode 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

LeetCode 121. Best Time to Buy and Sell Stock

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

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

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

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

思路：贪心， O(n)

记录一下最低的买入价格，每天尝试卖出是否获得更高收益，并记录下来即可

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() <= 1) return 0;
        int ans = 0, pre = prices[0];
        for (auto &p:prices) {
            ans = max(ans, p - pre);
            pre = min(p, pre);
        }
        return ans;
    }
};

LeetCode 122. Best Time to Buy and Sell Stock II

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

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

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

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

思路：贪心， O(n)

遍历一次数组，低进高出，把正的价格差相加起来就是最终利润。

可以拆分成以下几种情况，

递增，如[1,2,3]，那么1买3卖与每天都买入卖出等价
递减，如[3,2,1]，赚钱是赚不了的
先高再低，如[1,3,2]，那么只能在1买3卖捞一笔
先低再高，如[2,1,3]，那么同样只能在1买3卖捞一笔

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

LeetCode 123. Best Time to Buy and Sell Stock III

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

设计一个算法来计算你所能获取的最大利润。你最多可以完成两笔交易。

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

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

思路：贪心， O(n)

正向枚举一下i，left[i]记录的是第i天结束的最大收益

反向枚举一下i，right[i]记录的是第i+1天开始的最大收益

再遍历一下left[i] + right[i]即可

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.empty()) return 0;
        vector<int> left(prices.size() + 1), right(prices.size() + 1);
        for (int i = 1, low = prices[0]; i <= prices.size(); i ++) {
            left[i] = max(left[i-1], prices[i-1] - low);
            low = min(low, prices[i-1]);
        }

        for (int i = prices.size() - 1, hight = prices.back(); i >= 1; i --) {
            right[i] = max(hight - prices[i-1], right[i+1]);
            hight = max(hight, prices[i-1]);
        }
        int ans = 0;
        for (int i = 1; i <= prices.size(); i ++) {
            //printf("%d %d\n",left[i], right[i]);
            ans = max(ans, left[i] + right[i]);
        }
        return ans;
    }
};

LeetCode 188. Best Time to Buy and Sell Stock IV

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

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。

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

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

思路：DP， O(kn^2) 优化到 O(kn)

f[k][i]:表示最多完成k笔交易，前i天结束的最大收益，分析可知状态转移方程如下：

f[k][i]=max(f[k][i-1], f[k-1][1] + price[i] - price[1], ...,f[k-1][j] + price[i] - price[j])

对于其中的 max(f[k-1][j] - price[j]) + nums[i] 可以在遍历的时候用个max_value变量记录下来，优化到内层的j的循环

class Solution {
public:
    int maxProfit(int K, vector<int>& prices) {
        if (!prices.size())
            return 0;
        K = min(K, int(prices.size()) / 2);
        vector<vector<int>> dp(2, vector<int>(prices.size(), 0)); // 滚动数组优化
        for (int k = 1; k <= K; k ++) {
            int max_delta = dp[0][0] - prices[0];
            for (int i = 1; i < prices.size(); i ++) {
                dp[1][i] = max(dp[1][i-1], max_delta + prices[i]);
                max_delta = max(max_delta, dp[0][i] - prices[i]);
            }
            dp[0] = dp[1];
        }
        return dp[0][prices.size()-1];
    }
};