Leetcode No.121 买卖股票的最佳时机

Problem

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

示例 1: 输入: [7,1,5,3,6,4] 输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
示例 2: 输入: [7,6,4,3,1]输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

Solving

方法一： 常规暴力遍历
两层循环，第一层遍历买入，第二层遍历卖出，计算收益，寻找最大收益！
（简单容易理解，但效率低）

方法二： 遍历+预判
买入时如果后一天比前一天低，舍弃前一天，卖出时如果后一天比前一天高，舍弃前一天。
(优点，可以减少进入循环体的次数，缺点则是判断条件多，受数组排序影响大，执行效率不均衡)

方法三: 一次遍历
对每一天的价格与前面出现过的最低价格相比，计算收益，寻找最大收益。
(只需一次遍历，时间复杂度降低一个数量级，效率变快)

方法四： 一次遍历+预判
结合第二种方法和第三种方法的思想，在确定历史最低价格时，先排除前面几天价格高的

Code（c++）

方法一：

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

执行用时 :1076 ms
内存消耗 :14.5 MB

方法二：

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

执行用时 :1248 ms
内存消耗 :14.3 MB

方法三:

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int maxprofit = 0;
        int minprice = 1e9;
        int start = 0;
        for(start; start<prices.size(); ++start){
            maxprofit = max(maxprofit, prices[start]-minprice); // 计算当前价格与历史低价的收益与之前最大收益
            minprice = min(prices[start], minprice);
        }
        return maxprofit;
    }
};

执行用时 :8 ms
内存消耗 :14.1 MB

方法四：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int maxprofit = 0;
        int minprice = 1e9;
        int start = 0;
        for(start; start+1<prices.size(); ++start){  // 预判过程
            if (prices[start]>prices[start+1])
                continue;
            break;
        }
        for(start; start<prices.size(); ++start){  //遍历过程
            maxprofit = max(maxprofit, prices[start]-minprice); // 计算当前价格与历史低价的收益与之前最大收益
            minprice = min(prices[start], minprice);
        }
        return maxprofit;
    }
};

执行用时 :4 ms
内存消耗 :14.5 MB

当然，受测试用例的影响，执行时间和占用内存不绝对准确，但从中还是可以看出一次遍历比二次遍历速度还是快很多！