vlambda博客
学习文章列表

给定一个数组，它的第i个元素是一支给定股票第i天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

示例 2:

示例 3:

提示：

• 1<=prices.length<=3*10^4

• 0<=prices[i]<=10^4

前面刚讲过，其中也有动态规划解决的方式，这两题非常相似，不同的是第490题最多只能有一笔交易，而这题可以有多笔交易。所以这题我们也可以参照第490题来解。

定义dp[i][0]表示第i+1天交易完之后手里没有股票的最大利润，dp[i][1]表示第i+1天交易完之后手里持有股票的最大利润。

当天交易完之后手里没有股票可能有两种情况，一种是当天没有进行任何交易，又因为当天手里没有股票，所以当天没有股票的利润只能取前一天手里没有股票的利润。一种是把当天手里的股票给卖了，既然能卖，说明手里是有股票的，所以这个时候当天没有股票的利润要取前一天手里有股票的利润加上当天股票能卖的价格。这两种情况我们取利润最大的即可，所以可以得到

dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i]);

当天交易完之后手里持有股票也有两种情况，一种是当天没有任何交易，又因为当天手里持有股票，所以当天手里持有的股票其实前一天就已经持有了。还一种是当天买入了股票，当天能卖股票，说明前一天手里肯定是没有股票的，我们取这两者的最大值，所以可以得到

dp[i][1]=max(dp[i-1][1],dp[i-1][0]-prices[i]);

动态规划的递推公式有了，那么边界条件是什么，就是第一天

如果买入：dp[0][1]=-prices[0];

如果没买：dp[0][0]=0;

有了递推公式和边界条件，代码很容易就写出来了。

 1public int maxProfit(int[] prices) {
 2    if (prices == null || prices.length < 2)
 3        return 0;
 4    int length = prices.length;
 5    int[][] dp = new int[length][2];
 6    //初始条件
 7    dp[0][1] = -prices[0];
 8    dp[0][0] = 0;
 9    for (int i = 1; i < length; i++) {
10        //递推公式
11        dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
12        dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
13    }
14    //最后一天肯定是手里没有股票的时候，利润才会最大，
15    //只需要返回dp[length - 1][0]即可
16    return dp[length - 1][0];
17}

代码优化

 1public int maxProfit(int[] prices) {
 2    if (prices == null || prices.length < 2)
 3        return 0;
 4    int length = prices.length;
 5    //初始条件
 6    int hold = -prices[0];//持有股票
 7    int noHold = 0;//没持有股票
 8    for (int i = 1; i < length; i++) {
 9        //递推公式转化的
10        noHold = Math.max(noHold, hold + prices[i]);
11        hold = Math.max(hold, noHold - prices[i]);
12    }
13    //最后一天肯定是手里没有股票的时候利润才会最大，
14    //所以这里返回的是noHold
15    return noHold;
16}

下面我随便画了一个股票的曲线图，可以看到如果股票一直上涨，只需要找到股票上涨的最大值和股票开始上涨的最小值，计算他们的差就是这段时间内股票的最大利润。如果股票下跌就不用计算，最终只需要把所有股票上涨的时间段内的利润累加就是我们所要求的结果

 1public int maxProfit(int[] prices) {
 2    if (prices == null || prices.length < 2)
 3        return 0;
 4    int total = 0, index = 0, length = prices.length;
 5    while (index < length) {
 6        //如果股票下跌就一直找，直到找到股票开始上涨为止
 7        while (index < length - 1 && prices[index] >= prices[index + 1])
 8            index++;
 9        //股票上涨开始的值，也就是这段时间上涨的最小值
10        int min = prices[index];
11        //一直找到股票上涨的最大值为止
12        while (index < length - 1 && prices[index] <= prices[index + 1])
13            index++;
14        //计算这段上涨时间的差值，然后累加
15        total += prices[index++] - min;
16    }
17    return total;
18}

1public int maxProfit(int[] prices) {
2    int total = 0;
3    for (int i = 0; i < prices.length - 1; i++) {
4        //原数组中如果后一个减去前一个是正数，说明是上涨的，
5        //我们就要累加，否则就不累加
6        total += Math.max(prices[i + 1] - prices[i], 0);
7    }
8    return total;
9}

这题使用动态规划很容易理解，具体也可以看下。但这道题还可以使用贪心算法，只要是上涨的就要累加，但我们要明白累加的意义，他并不是说一定要当天买当天卖，比如从a到d一直是上涨的，我们一直累加其实就相当于在a的时候买，在d的时候卖。