Leetcode 121. Best Time to Buy and Sell Stock

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)

Input: [7, 6, 4, 3, 1]
Output: 0

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

 1 class Solution {
 2 public:
 3     int maxProfit(vector<int>& prices) {
 4         int n=prices.size(),i,maxprofit=0,minprice=INT_MAX;
 5         for(i=0;i<n;i++){
 6             if(maxprofit<prices[i]-minprice){
 7                 maxprofit=prices[i]-minprice;
 8             }
 9             if(minprice>prices[i]){
10                 minprice=prices[i];
11             }
12         }
13         return maxprofit;
14     }
15 };

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

 1 class Solution {
 2 public:
 3     int maxProfit(vector<int>& prices) {
 4         int i,n=prices.size(),curprofit=0,maxprofit=0;
 5         for(i=1;i<n;i++){
 6             curprofit=max(0,curprofit+prices[i]-prices[i-1]);
 7             maxprofit=max(maxprofit,curprofit);
 8         }
 9         return maxprofit;
10     }
11 };