[Leetcode][Dynamic programming] 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 the day i.
If you were only permitted to complete only one transaction (i.e. buy one and sell one stock), design an algorithm to find the maximum profit.

我最初的设想是运用最原始的dynamic programming来解决这个问题，这个解决方案的时间和空间复杂度都是O(n^2) (需要n^2次循环和n^2大小的二维数组)。我的代码如下：

public class Solution {
    /**
     * Bottom-up approach
     * Profit(selldatelimit, buydatelimit) = max{Profit(selldate-1, buydate), Profit(selldate, buydate+1), p[selldate] - p[buydate]} this is the maximum profit we can get from the time range of buydatelimit to the selldatelimit
     * Profit(selldatelimit, buydatelimit) = 0 if selldate = buydate
     * Profit(selldatelimit, buydatelimit) doesn't exist if selldatelimit < buydatelimit
     * i = selldatelimit
     * j = buydatelimit
     * i >= j
     */
    public int maxProfit(int[] prices) {
        int l = prices.length;
        if (l == 0) {
            return 0;
        }
        int[][] profit = new int[l][l];
        for (int c = 0; c <= l - 1; c++) {
            for (int j = 0; j <= l - 1 - c; j++) {
                int i = j + c;
                if (i == j) {
                    profit[i][j] = 0; 
                    //buy and sell at the same day, profit is 0
                }
                else {
                    profit[i][j] = profit[i][j+1] > profit[i-1][j] ? profit[i][j+1] : profit[i-1][j];
                    profit[i][j] = profit[i][j] > (prices[i] - prices[j]) ? profit[i][j] : prices[i] - prices[j];
                    //profit[i][j] is the largest one among the three ones
                }
            }
        }

        return profit[l - 1][0]; 
        //return the largest profit we can get from the time range of the first day to the last day
    }
}

然而这个方法在提交的时候报错： Time Limit Exceeded. 报错的时候提示的输入数组是一个非常大的数组。

出错的原因很可能是因为O(n^2)的时间和空间复杂度导致的执行速度太慢超出了时间限制。所以我参考了discussion里的解法。总结出如下方法:
1. 因为此题的目的是求出在只能买卖一次的情况下如何获取最大利润，所以其根本目的是求出在prices[]数组中任意两个数据之间的差值的最大值。（当然卖出时间要大于买入时间）
2. 那么基本的想法就是如果prices[i] > prices[i-1],最大差值就应当是历史最优利润或者当前价格减去历史最低价格(max{profit, prices[i]-minimal_price})
如果prices[i] < prices[i-1],那么最大差值应当是历史最优利润，此时应当更新历史最低价格。

那么在这种情况下，程序应当如下：

public class Solution {
    public int maxProfit(int[] prices) {
        /**
         * basic idea:
         * Since we can only complete at most one transaction, we only need to find out the maximum interval between any two prices in side the prices array. 
         * So the largest profit must be the historical maximum interval until day N-1 or the interval between price of Day N and the historical minimum price.
         * Then we may have to renew the mimimum price or the maximum interval.
         */
        int l = prices.length;
        if (l == 0 || l == 1){
            return 0;
        }
        int minprice = prices[0];
        int maxprofit = 0;
        for (int i = 1; i < l; i ++){
            maxprofit = maxprofit > prices[i] - minprice ? maxprofit : prices[i] - minprice;
            minprice = minprice < prices[i] ? minprice : prices[i];
        }
        return maxprofit;
    }
}

其中的三元运算符起到判断大小的作用。此种方法对应的程序的时间复杂度为O(n)而空间复杂度为O(1)。