LeetCode刷题之买卖股票的最佳时机

1. 买卖股票的最佳时机

题121 买卖股票的最佳时机

1.1 描述

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：

输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 =6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

示例 2：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。

1.2 分析

获得最大利润，那就是要在最低的价格买入，最高的价格卖出，而且必定是先买入，后卖出。由于限定了是这笔交易，即只能交易一次，那就不能进行多次交易。
当知道今天的股票交易价格的时候，可以和前一天的交易价格比，更低价格的那天，是更合适的买入机会，即更低的价格，是成本。
与之相对应，卖的时候要价格更高的时候，是卖出的合适机会。我们可以记录每一天的买入、卖出的价格，把价格记录到结果中。

1.3 解答

 class Test {
	public int maxProfit(int[] prices) {
	  int cost = Math.MAX_VALUE;
	  int profit = 0;
	  for (int price : prices) {
	  	cost = Math.min(cost, price);
	  	profit = Math.max(profit, price - cost);
	  }
	  return profit;
	}
}

2.买卖股票的最佳时机II

题122 买卖股票的最佳时机II

2.1 描述

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。

返回 你能获得的 最大 利润 。

示例 1：

输入：prices = [7,1,5,3,6,4]
输出：7
解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 =5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。
总利润为 4 + 3 = 7 。

示例 2：

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 =5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
总利润为 4 。

示例 3：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。

2.2 分析

这个问题和前一天问题最大的不同在于，可以进行多次买卖。那么每天都有两种情况，如果今天卖出股票，有多少profit，如果今天持有股票，又有多少profit？那么可以创建一个二维数组来表示，即dp[i][0]表示第i天的时候，卖出股票获得的最大利润是多少，dp[i][1]表示今天继续持有股票，当前的利润最大是多少？
若当前卖出股票，最大利润如何计算？即用当前的价格，减去前一天持有股票的成本，这个成本就是上一题讨论的前n天中相对成本较低的时候。
与之相对应，继续持有股票，那么今天的利润是前一天持有股票的相反数，即只花了钱买股票，没有卖出。

对于第i天，计算不持有股票时的最大利润dp[i][0]，取前一天不持有股票的最大利润dp[i-1][0]和前一天持有股票的最大利润加上当天卖出股票的价格dp[i-1][1] + prices[i]的较大值。

对于第i天，计算持有股票时的最大利润dp[i][1]，取前一天持有股票的最大利润dp[i-1][1]和前一天不持有股票的最大利润减去当天买入股票的价格dp[i-1][0] - prices[i]的较大值。

直到最后一天，股票一定要卖出了，再持有也是属于亏损了。
这里特别关照的是第一天的时候，卖出股票是没有可以卖的，因此这一天的利润就是0；第一天持有股票赚取的利润就是当天价格的相反数，因为只有花钱买了股票。

2.3 解答

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

2.4 拓展

由于当前的利润，只和前一天的结果相关，那么也可以不用开辟二维数组存放，直接给定变量即可。

class Solution {
	public int maxProfit(int[] prices) {
		int len = prices.length;
		if (len < 2) {
			return 0;
		}
		int cash = 0;
		int stock = -prices[0];
		int preCash = 0;
		int preStock = stock;
		for (int price : prices) {
			cash = Math.max(preCash, preStock + price);
			stock = Math.max(preStock, preCash - price);
			preCash = cash;
			preStock = stock;
		}
		
		return cash;
	}
}

2.5 拓展二

此题也可以用贪心算法来求解。

贪心算法（Greedy algorithm）是一种基于贪心策略的算法设计方法。在贪心算法中，每一步都选择当前状态下的最优解，以期望最终获得全局最优解。贪心算法的核心思想是：每一步都做出在当前状态下看起来最好的选择，而不考虑该选择对未来的影响。

贪心算法通常适用于满足贪心选择性质和最优子结构的问题。贪心选择性质指的是通过选择当前最优解，能够得到全局最优解。最优子结构指的是问题的最优解包含了子问题的最优解。这些性质保证了贪心算法的可行性和正确性。

今天的股价-昨天的股价，只有三种结果：

• 正数
• 负数
• 0
  那么要累计收益最大，那就只需要累加赚钱的情况，即所有都是赚钱的时候，那么就是利润最大的时刻。

贪心选择性质的证明：

借助 「差分」 这个概念，可以证明 「贪心算法」 的有效性。贪心算法是选择那些所有差分（严格）大于 0 的数，把它们相加即可。

使用反证法：

假设 「贪心算法」 得到的解并不是最优解，即我们还能够找到一个可行解比 「贪心算法」 得到的利润还多。差分数组中除了差分为正数的项以外，还有就是差分为 0 的项与差分为负数的项。「贪心算法」 是所有差分为正数的项的和。有以下 3种情况：

• 1. 如果可行解在 「贪心算法」 的基础上，选择了差分为 0的项，得到的结果与「贪心算法」得到的结果一样，因此加上差分为 0 的项不会比「贪心算法」得到的结果更好；
• 2. 如果可行解在 「贪心算法」 的基础上，选择了差分为负数的项，加上一个负数得到的结果一定比 「贪心算法」 得到的结果要少，加上差分为负数的项，一定比 「贪心算法」 得到的结果更少；
• 3. 如果可行解在 「贪心算法」 的基础上，去掉了任何一个差分为正数的项，同上，得到的结果一定比 「贪心算法」 得到的结果要小，因此，「贪心算法」 的所有组成项不能删去任何一个。

public class Solution {

    public int maxProfit(int[] prices) {
        int len = prices.length;
        if (len < 2) {
            return 0;
        }

        int res = 0;
        for (int i = 1; i < len; i++) {
            res += Math.max(prices[i] - prices[i - 1], 0);
        }
        return res;
    }
}