leetcode 121. Best Time to Buy and Sell Stock

Say you have an array for which the ith element is the price of a given stock on day i.

If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.

Example 1:
Input: [7, 1, 5, 3, 6, 4]
Output: 5

max. difference = 6-1 = 5 (not 7-1 = 6, as selling price needs to be larger than buying price)
Example 2:
Input: [7, 6, 4, 3, 1]
Output: 0

In this case, no transaction is done, i.e. max profit = 0.

主要是找出买入卖出的时机，其实只需要知道卖出的时间即可。这样可以将时间复杂度控制在O(n)
我的直观解法是，用一个变量pre记录访问到当前元素前的最小值，这样如果在当前位置卖出，那么买入点应该是之前最下值处。

public class Solution {
    public int maxProfit(int[] prices) {
        if(prices==null||prices.length==0) return 0;
        int res = 0;
        int pre = prices[0];
        for(int i=1; i< prices.length; i++){
            int cur = prices[i] - pre;
            res = Math.max(res, cur);
            if(prices[i] < pre) pre = prices[i];
        }
        return res;
    }
}

目前Top answer给出的是另一种解法

Kadane's Algorithm - Since no one has mentioned about this so far :) (In case if interviewer twists the input)
The logic to solve this problem is same as "max subarray problem" using Kadane's Algorithm. Since no body has mentioned this so far, I thought it's a good thing for everybody to know.

All the straight forward solution should work, but if the interviewer twists the question slightly by giving the difference array of prices, Ex: for {1, 7, 4, 11}, if he gives {0, 6, -3, 7}, you might end up being confused.

Here, the logic is to calculate the difference (maxCur += prices[i] - prices[i-1]) of the original array, and find a contiguous subarray giving maximum profit. If the difference falls below 0, reset it to zero.

    public int maxProfit(int[] prices) {
        int maxCur = 0, maxSoFar = 0;
        for(int i = 1; i < prices.length; i++) {
            maxCur = Math.max(0, maxCur += prices[i] - prices[i-1]);
            maxSoFar = Math.max(maxCur, maxSoFar);
        }
        return maxSoFar;
    }
*maxCur = current maximum value

*maxSoFar = maximum value found so far

这里核心是下面这句

 maxCur = Math.max(0, maxCur += prices[i] - prices[i-1]);

maxCur也是在当前点卖出的收益，那么一个计算方法是，如果在下一个点卖出那么可以根据收益的增加来更新下一个点的收益。还是觉得我的解法跟直观