LeetCode: Best Time to Buy and Sell Stock I & II & III

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.

最开始nc，只想到了brute force算法。想着最大减最小就是结果，但是如果最大值出现在最小值之前就不能算了。所以想到brute force解法。对于每个数，在它后面找一个最大的数，相减得到的结果作为在这个时候买入的最优结果。最后从所有最优中找到一个最大的。虽然加入了一些优化，但是总体的时间复杂度为O(n^2)。

public int maxProfit(int[] prices) {
        if (prices.length == 0) return 0;
        int profit = 0;
        int lowPrice = prices[0];
        for (int i=0; i<prices.length-1; i++) {
            if (i>0 && prices[i] >= lowPrice) continue;
            for (int j=i+1; j<prices.length; j++) {
                int p = prices[j] - prices[i];
                if ( p > profit) {
                    profit = p;
                    lowPrice = prices[i];
                }
            }
        }
        return profit;
    }

后来经点拨，想到用dp思想。比如说我在第i时刻得到的最好的结果可以由之前的结果得到。

ith时刻的最好结果 = max（i-1 时刻最好结果，i与前i-1个元素最小的一个的差）。

后来我一想，不对呀，压根不用重新弄一个profit数组存下每个时刻最优的profit。这个算法只用从前到后扫描一遍。所以时间复杂度O(n)。

 public int maxProfit(int[] prices) {
        if (prices.length == 0) return 0;
        int profit = 0;
        int lowestPrice = prices[0];
        for (int i=0; i<prices.length; i++) {
            if(prices[i] < lowestPrice) {
                lowestPrice = prices[i];
                continue;
            }
            else {
                profit = Math.max(profit, prices[i]-lowestPrice);
            }
        }
        
        return profit;
    }

 

---

 

Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times). However, you may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

这回可以做任意次数的交易。受上一题的影响，我还是用dp。

我先记录下在每一时刻最优的profit。

ith 最大profit = i-j 时刻最大profit + 从j到i做一次交易的最大的profit。

这样感觉时间复杂度是O(n^2).

 public int maxProfit(int[] prices) {
        if (prices.length == 0) return 0;
        int[] profit = new int[prices.length];
        for (int i=0; i<prices.length; i++) {
            if (i>0 && prices[i] <= prices[i-1]) {
                profit[i] = profit[i-1];
                continue;
            }
            int pmax = 0;
            int p = 0;
            for (int j=0; j<i; j++) {
                p = 0;
                if (prices[i]-prices[j]>0) p += prices[i] - prices[j];
                if (j > 0) p += profit[j-1];
                if (p>pmax) pmax = p;
            }
            profit[i] = pmax;
            
        }
        return profit[prices.length-1];
    }

后来经点拨，发现了一个更简单的算法。就在数组中，每一次递增，我都是从初始的时刻买入，最后时刻卖出。这样可以得到每一次价格上升的利润。

这样可以只扫描一次数组，因此时间复杂度为O(n)。

public int maxProfit(int[] prices) {
        if (prices.length == 0) return 0;
        int profit = 0;
        for (int i=1; i<prices.length; i++) {
            if (prices[i]>prices[i-1]) {
                profit += prices[i] - prices[i-1];
            }
        }
        return profit;
    }

但不知道为什么，这样的时间算下来要比第一种要慢。。。

 

---

Design an algorithm to find the maximum profit. You may complete at most two transactions.

只做两次交易。

我的想法还是用dp。我给每个时刻附两个值，一个是在这个时刻之前只做了一次交易的最大的profit（first），一个是在这之前做了两次交易的最大的profit（second）。first的计算方法和第一题一样，时间复杂度为O(n)。

second[i] = first[j-1] + 从j到i最大的profit。对于任意的j < i.所以算下来时间复杂度应该为O(n^2)。

public int maxProfit(int[] prices) {
        if (prices.length == 0) return 0;
        
        int[] first = new int[prices.length];
        int[] second = new int[prices.length];
        
        int minPrices = prices[0];
        for (int i=1; i<prices.length; i++) {
            if (prices[i] < minPrices) {
                minPrices = prices[i];
                first[i] = first[i-1];
            }
            else {
                first[i] = prices[i] - minPrices;
            }
            
            if(prices[i] < prices[i-1]) {
                second[i] = second[i-1];
                continue;
            }
            else {
                int p2 = 0;
                int pmax = 0;
                for (int j=0; j<i; j++) {
                    p2 = 0;
                    if (prices[i] > prices[j]) p2 += prices[i] - prices[j];
                    if (j>0) p2 += first[j-1];
                    if (p2 > pmax) pmax = p2;
                }
                second[i] = pmax;
            }
        }
        
        return Math.max(first[prices.length-1], second[prices.length-1]);
    }

但是这个方法在[10000, 9999, 9998, ........]超时了。但是在这种情况下时间复杂度应该为O(n)呀，为啥会超时。。。

后来经点拨，学会了一种O(n)的算法。

上一种解法中second的计算方法就是算[0...j-1][j...i]两段最大的profit相加。但是在算第二段的时候需要遍历[j...i]得到minPrice。

现在我不用计算每一个i对应的[j...i]，我用O(n)的算法得到[j...n]的就行了。我想计算[0...n]的最大profit，我分别计算[0...j-1]和[j...n]就行。

[0...j-1]的解法和第一题一样，O(n)。[j...n]和[0...j-1]一样，只是从最后往前算，还是O(n)。所以总的时间复杂度为O(n)。

public int maxProfit(int[] prices) {
        if (prices.length < 2) return 0;
        int[] profit = new int[prices.length];
        int maxProfit = 0;
        
        int minPrices = prices[0];
        for (int i=1; i<prices.length; i++) {
            if (prices[i] < minPrices) {
                minPrices = prices[i];
                profit[i] = profit[i-1];
            }
            else {
                profit[i] = Math.max(prices[i] - minPrices, profit[i-1]);
            }
        }
        
        int maxPrices = prices[prices.length-1];
        maxProfit = profit[prices.length-1];
        for (int i=prices.length-1; i>0; i--) {
            int p = profit[i-1];
            if (prices[i] > maxPrices) {
                maxPrices = prices[i];
            }
            else {
                p += maxPrices - prices[i]; 
            }
            if (p > maxProfit) {
                maxProfit = p;
            }
        }
        
        return maxProfit;
    }