LeetCode解题报告—— Best Time to Buy and Sell Stock

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. 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 (i.e., you must sell the stock before you buy again).

Example 1:

Input: [3,3,5,0,0,3,1,4]
Output: 6
Explanation: Buy on day 4 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
             Then buy on day 7 (price = 1) and sell on day 8 (price = 4), profit = 4-1 = 3.

Example 2:

Input: [1,2,3,4,5]
Output: 4
Explanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
             Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are
             engaging multiple transactions at the same time. You must sell before buying again.

Example 3:

Input: [7,6,4,3,1]
Output: 0
Explanation: In this case, no transaction is done, i.e. max profit = 0.

思路

这个题目有一系列的变形，唯一改变的是交易的次数，比如这题中限定的最多transaction是2，当然也可以限定为k。

解法还是dp，dp[k, i] 代表在price[i]之前 (price[0] ~ price[i])完成最多k个transaction所获得的最大利润，注意这里不是说以price[i]为结束，只是限定了k个transaction的大致范围，很有可能在k个transaction中是不包含price[i]的。那么得出：

dp[k, i] = max(dp[k, i-1], price[i] - price[ii] + dp[k-1, ii]) 　　　　　　其中 ii在[0, i-1]范围内

　　　= max(dp[k, i-1], price[i] + max(dp[k-1, ii] - price[ii]))　　　   其中 ii 在[0, i-1]范围内

dp[0, i] = 0

dp[k, 0] = 0

解决 k transaction 的代码如下，计算过程我看的有点蒙。

注意的是自低向上的计算过程，先计算 dp[1][1]~dp[1][n]，也就是先从k=1，最多只有一笔交易的情况出发，然后去计算dp[2][1]~dp[2][n]......直到dp[k][1]~dp[k][n]。在计算dp[1][1]~dp[1][n]时，假设当前计算的是dp[1][i]，会利用到dp[1][i-1]，即第一笔交易是在0~i-1内的price完成，和price[i]没有关系。还要计算另一种情况，就是i计算在内，因为i是末位，所以只可能在price[i]卖出，但是和这个相对应的买入位不确定，所以要遍历i之前所有可能的买入位，即计算所有的 price[i]-price[ii]，其中ii在0~i-1之间，那么之前的k-1笔交易只可能是在0~ii之内的，至于这里为什么包括ii，而不是ii-1，我猜是因为可以在同一天先卖后买，比如说我在第ii-1天先将手中持有的stcock卖出，再买入。

明白了上面之后，在计算dp[1][1]~dp[1][n]，时如果确定了i，那么要计算所有的 price[i]-price[ii]，取其price[i]-price[ii]+dp[0][ii-1]最大的一个，，ii在0~i-1之间，当i递增变为i+1时，又得计算所有的 price[i+1]-price[ii]，其中ii在0~i之间，这样会重复计算的，所以要利用之前的计算结果，可以重复利用的是dp[0][i-1]-price[ii]这里，因为ii在0~i-1遍历，所以比如0~1，0~2以及0~3，计算0~3只需要计算dp[0][2]-price[2]的值，和之前0~2的计算结果直接相比即可。

感觉描述得有点乱，就是说在dp[i][j]，i固定的情况下，dp[i-1][jj]-price[jj]的值由jj决定，当j增大时，比如从4到5，那么jj就是在 0~3和0~4中，这两个计算中0~3的计算是重复的，当j=4时我们只需要计算dp[1][3]-price[3]后再直接和上一次的结果比，再取较大的即可。这样我们在计算dp[1][1]到dp[1][n]时只需要计算开始处的dp[0][0]-price[0]再往后后项依赖前项递推即可。

/**
 * dp[i, j] represents the max profit up until prices[j] using at most i transactions. 
 * dp[i, j] = max(dp[i, j-1], prices[j] - prices[jj] + dp[i-1, jj]) { jj in range of [0, j-1] }
 *          = max(dp[i, j-1], prices[j] + max(dp[i-1, jj] - prices[jj]))
 * dp[0, j] = 0; 0 transactions makes 0 profit
 * dp[i, 0] = 0; if there is only one price data point you can't make any transaction.
 */
public int maxProfit(int k, int[] prices) {
    int n = prices.length;
    if (n <= 1)
        return 0;
    
    //if k >= n/2, then you can make maximum number of transactions.
    if (k*2 >=  n) {
        int maxPro = 0;
        for (int i = 1; i < n; i++) {
            if (prices[i] > prices[i-1])
                maxPro += prices[i] - prices[i-1];
        }
        return maxPro;
    }
    
    int[][] dp = new int[k+1][n];
　　
    for (int i = 1; i <= k; i++) {
        int localMax = dp[i-1][0] - prices[0];
        for (int j = 1; j < n; j++) {
            dp[i][j] = Math.max(dp[i][j-1],  prices[j] + localMax);
            localMax = Math.max(localMax, dp[i-1][j] - prices[j]);
        }
    }
    return dp[k][n-1];
}

算法要点：

1. dp[i, j] represents the max profit up until prices[j] using at most i transactions。这个含义要注意，即到了第j天时最多用掉了i笔交易所获得的最大利润

2. 基于以上的定义，计算

dp[i, j] = max(dp[i, j-1], prices[j] - prices[jj] + dp[i-1, jj]) { jj in range of [0, j-1] }

时 jj 的范围每次都是从0 到j-1

3. localMax那块的计算逻辑

转载于:https://www.cnblogs.com/f91og/p/9457178.html