Best Time to Buy and Sell Stock系列

I题

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.

Subscribe to see which companies asked this question

解答：

采用动态规划解法，遍历数组更新当前最小值，并用当前值减去最小值与当前最大利润进行比较，更新最大利润。

public class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int min = Integer.MAX_VALUE;
        int profit = 0;
        for (int i : prices) {
            min = Math.min(min, i);
            profit = Math.max(i - min, profit);
        }
        return profit;
    }
}

II

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

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).

Subscribe to see which companies asked this question

解答：

采用贪心算法，记录相邻两天的差值，大于零则加到利润总量中。（本题满足贪心算法可以得到最优解的特性是重点）

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

Best Time to Buy and Sell Stock with Cooldown

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

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) with the following restrictions:

• You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
• After you sell your stock, you cannot buy stock on next day. (ie, cooldown 1 day)

Example:

prices = [1, 2, 3, 0, 2]
maxProfit = 3
transactions = [buy, sell, cooldown, buy, sell]

解答：

设置三个数组，buy sell和rest。

buy[i]表示第i天以buy状态结束时至今可以获得的最大profit；

sell[i]表示第i天以sell状态结束至今可以获得的最大profit；

rest[i]表示第i天以rest状态结束至今可以获得的最大profit。

根据定义可得：

buy[i]  = max(rest[i-1]-price, buy[i-1]) //前者表示在前一天rest的情况下今天购入，后者表示在前一天处于buy状态的情况下保持buy状态（即不操作）
sell[i] = max(buy[i-1]+price, sell[i-1]) //前者表示在前一天处于buy状态的情况下今天卖出，后者表示前一天已经处于sell状态的情况下保持sell状态（即不操作）
rest[i] = max(sell[i-1], buy[i-1], rest[i-1]) //rest表示没有任何操作，所以其值应为前一天处于sell，buy和rest状态中的最大值

上述等式考虑了两个规则，即buy必须在rest之后，sell必须在buy之后，由一式和二式可以得到。但还有一个特殊情况[buy,rest,buy]需要考虑，从上述三式不能明显得出这种特殊情况不存在。

由buy[i] <= rest[i]，故rest[i] = max(sell[i-1], rest[i-1])，由此式可以得到[buy,rest,buy]不可能发生。

由rest[i] <= sell[i]，故rest[i] = sell[i-1]。

于是上述三个等式可以化为两个：

buy[i] = max(sell[i-2]-price, buy[i-1])
sell[i] = max(buy[i-1]+price, sell[i-1])

第i天状态只和第i-1天和i-2天有关，所以空间可以由O(n)缩小为O(1)。

具体代码如下：

public int maxProfit(int[] prices) {
    int sell = 0, prev_sell = 0, buy = Integer.MIN_VALUE, prev_buy;
    for (int price : prices) {
        prev_buy = buy;
        buy = Math.max(prev_sell - price, prev_buy);
        prev_sell = sell;
        sell = Math.max(prev_buy + price, prev_sell);
    }
    return sell;
}

III

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

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

Note:
You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

问题分析：

最初的想法是在prices数组中寻找一个分割点，把数组分割为两部分。然后利用第一个问题的方法去分别寻找两部分的结果，将结果相加，得出的最大结果即为最终的最大利润。代码如下：

public class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int rst = 0;
        for (int i = 0; i < n; i++) {
            int temp = helper(prices, 0, i) + helper(prices, i + 1, n - 1);
            if (rst < temp) {
                rst = temp;
            }
        }
        return rst;
    }
    public int helper(int[] prices, int i, int j) {
        if (i > j) return 0;
        int min = Integer.MAX_VALUE;
        int rst = 0;
        for (int k = i; k <= j; k++) {
            min = Math.min(prices[k], min);
            rst = Math.max(prices[k] - min, rst);
        }
        return rst;
    }
}

这段代码在lintcode上通过了所有test case，但是在leetcode上超时了。时间复杂度为O(n^2).

利用数组dp[k][i]来表示以在prices下标i之前（包含i）进行k次交易得到的最大利润。则可以得到递推公式为

dp[k][i] = max(dp[k][i - 1], max(dp[k - 1][j] + prices[i] - prices[j])), 其中j的取值范围为[0, i - 1].

= max(dp[k][i - 1], prices[i] + max(dp[k -1][j] - prices[j]))

= max(dp[k][i - 1], prices[i] + max(prev[k - 1])), 在内层循环中只需要每次更新这个值即可。

根据实际意义，dp[0][i]和dp[i][0]均为0.　

具体代码如下：

public class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length <= 1) return 0;
        int k = 2;
        int[][] dp = new int[k + 1][prices.length];
        for (int t = 1; t <= k; t++) {
            int tmp = Integer.MIN_VALUE;
            for (int i = 1; i < prices.length; i++) {
                tmp = Math.max(tmp, dp[t - 1][i - 1] - prices[i - 1]);
                dp[t][i] = Math.max(dp[t][i - 1], prices[i] + tmp);
            }
        }
        return dp[k][prices.length - 1];
    }
}

问题优化：

考虑此时能否把二维数组简化为一维数组，发现tmp既与i的上一个状态有关，还与t的上一个状态有关。此时不方便简化。

仔细分析发现在递推公式dp[k][i] = max(dp[k][i - 1], max(dp[k - 1][j] + prices[i] - prices[j]))中j取i时也可行。也就意味着在内部循环式变为

1）tmp = Math.max(tmp, dp[t - 1][i] - prices[i])

2）dp[t][i] = Math.max(dp[t][i - 1], prices[i] + tmp)

此时将数组简化为一维数组dp[i]每次用i - 1的状态更新i的状态即可，具体代码如下：

public class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length <= 1) return 0;
        int k = 2;
        int[] dp = new int[prices.length];
        for (int t = 1; t <= k; t++) {
            int tmp = dp[0] - prices[0];
            for (int i = 1; i < prices.length; i++) {
                tmp = Math.max(tmp, dp[i] - prices[i]);
                dp[i] = Math.max(dp[i - 1], prices[i] + tmp);
            }
        }
        return dp[prices.length - 1];
    }
}

进一步优化：

考虑问题的继续优化，dp[i]只与dp[i - 1]有关，并且k = 2时外层循环只有两次，所以只需要四个变量来记录变化即可。

此时只需要对prices进行遍历，更新这四个变量即可。具体意义为：

1）buy1：当前购买了第一支股票的最大获利；

2）sell1：当前售出了第一支股票的最大获利；

3）buy2：当前购买了第二支股票的最大获利；

4）sell2：当前售出了第二支股票的最大获利。

public class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length <= 1) return 0;
        int buy1 = Integer.MIN_VALUE;
        int buy2 = Integer.MIN_VALUE;
        int sell1 = 0;
        int sell2 = 0;
        for (int i : prices) {
            buy1 = Math.max(buy1, - i);
            sell1 = Math.max(sell1, i + buy1);
            buy2 = Math.max(buy2, sell1 - i);
            sell2 = Math.max(sell2, i + buy2);
        }
        return sell2;
    }
}

IV

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

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

问题解答：

这里用III中的普适方法会有一个test case出现MLE的问题，原因是k值过大。在这里对于k值比二分之一数组长度大时，问题可以简化为问题II。采用quickSolve方法解决此时的问题，代码如下：

public class Solution {
    public int maxProfit(int k, int[] prices) {
        if (prices == null || prices.length <= 1) return 0;
        if (k >= prices.length / 2) return quickSolve(prices);
        int[][] dp = new int[k + 1][prices.length];
        for (int t = 1; t <= k; t++) {
            int tmp = dp[t - 1][0] - prices[0];
            for (int i = 1; i < prices.length; i++) {
                dp[t][i] = Math.max(dp[t][i - 1], prices[i] + tmp);
                tmp = Math.max(tmp, dp[t - 1][i] - prices[i]);
            }
        }
        return dp[k][prices.length - 1];
    }
    public int quickSolve(int[] prices) {
        int rst = 0;
        for (int i = 1; i < prices.length; i++) {
            if (prices[i] > prices[i - 1]) {
                rst += prices[i] - prices[i - 1];
            }
        }
        return rst;
    }
}