2.6 动态规划—lc炒股系列

1. 买卖股票的最佳时机 I

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。

leetcode 121.买卖股票的最佳时机

2. 算法思路

假设给定的数组为：[7, 1, 5, 3, 6, 4]。如果我们在图表上绘制给定数组中的数字，我们将会得到：

显然，如果在历史最低点买入，且在买入之后的最高点卖出，那么就能获得最大利润。我们只需用一个变量记录历史最低价格 $minprice$，那么我们在第 $i$ 天卖出股票能得到的利润就是 $prices[i]-minprice$。因此，我们只需要遍历价格数组一遍，记录历史最低点，然后在每一天考虑这么一个问题：如果我是在历史最低点买进的，那么我今天卖出能赚多少钱？当考虑完所有天数之时，我们就得到了最好的答案。

3. 代码实现

public class Solution{
	public int maxProfit(int prices[]){
		int minprice = Integer.MAX_VALUE;
		int maxprofit = 0;
		for(int i = 0; i < prices.length; i++){
			if(prices[i] < minprices)					//记录历史最低点
				minprice = prices[i];
			else if(prices[i] - minprice > maxprofit)	//记录当前历史最大利润
				maxprofit = prices[i] - minprice;
		}
		return maxprofit;
	}
}

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

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 。
示例 2:

输入: prices = [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3:

输入: prices = [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
leetcode 122.买卖股票的最佳时机II

2. 算法思路

方法一：动态规划

考虑到「不能同时参与多笔交易」，因此每天交易结束后只可能存在手里有一支股票或者没有股票的状态。定义状态 $dp[i][0]$ 表示第 $i$ 天交易完后手里没有股票的最大利润，$dp[i][1]$ 表示第 $i$ 天交易完后手里持有一支股票的最大利润（$i$ 从 $0$ 开始）。
考虑 $dp[i][0]$ 的转移方程，如果这一天交易完后手里没有股票，那么可能的转移状态为前一天已经没有股票，即 $dp[i-1][0]$，或者前一天结束的时候手里持有一支股票，即 $dp[i-1][1]$，这时候我们要将其卖出，并获得 $prices[i]$ 的收益。因此为了收益最大化，我们列出如下的转移方程： dp [ i ] [ 0 ] = max ⁡ { dp [ i − 1 ] [ 0 ] , dp [ i − 1 ] [ 1 ] + prices [ i ] } \textit{dp}[i][0]=\max\{\textit{dp}[i-1][0],\textit{dp}[i-1][1]+\textit{prices}[i]\} dp[i][0]=max{dp[i−1][0],dp[i−1][1]+prices[i]}再来考虑 $\text{dp}[i][1]$，按照同样的方式考虑转移状态，那么可能的转移状态为前一天已经持有一支股票，即 $\text{dp}[i-1][1]$，或者前一天结束时还没有股票，即 $\text{dp}[i-1][0]$，这时候我们要将其买入，并减少 $\text{prices}[i]$ 的收益。可以列出如下的转移方程：
dp [ i ] [ 1 ] = max ⁡ { dp [ i − 1 ] [ 1 ] , dp [ i − 1 ] [ 0 ] − prices [ i ] } \textit{dp}[i][1]=\max\{\textit{dp}[i-1][1],\textit{dp}[i-1][0]-\textit{prices}[i]\} dp[i][1]=max{dp[i−1][1],dp[i−1][0]−prices[i]}对于初始状态，根据状态定义我们可以知道第 0 天交易结束的时候 $\text{dp}[0][0]=0$，$\text{dp}[0][1]=-\text{prices}[0]$。因此，我们只要从前往后依次计算状态即可。由于全部交易结束后，持有股票的收益一定低于不持有股票的收益，因此这时候 $\text{dp}[n-1][0]$ 的收益必然是大于 $\text{dp}[n-1][1]$ 的，最后的答案即为 $\text{dp}[n-1][0]$。

class Solution{
	public int maxProfit(int[] prices){
		int n = prices.length;
		int[][] dp = new int[n][2];   			//状态数组
		dp[0][0] = 0;
		dp[0][1] = -prices[0];
		for(int i = 1; i < n; ++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], dp[i - 1][0] - prices[i]);
        }
		return dp[n - 1][0];
	}
}

方法二：贪心

由于股票的购买没有限制，因此整个问题等价于寻找 $x$ 个不相交的区间 $(l_i,r_i]$使得如下的等式最大化$$\sum _{i=1}^{x}a[r_i]-a[l_i]$$其中 $l_i$ 表示在第 $l_i$天买入，$r_i$ 表示在第 $r_i$天卖出。同时我们注意到对于 $(l_i,r_i]$ 这一个区间贡献的价值 $a[r_i]-a[l_i]$，其实等价于 $(l_i,l_i+1],(l_i+1,l_i+2]$,这若干个区间长度为 11 的区间的价值和，即$$a[r_i]-a[l_i]=(a[r_i]-a[r_i-1])+(a[r_i-1]-a[r_i-2])+\dots +(a[l_i+1]-a[l_i])$$因此问题可以简化为找 $x$ 个长度为 $1$ 的区间 $(l_i,l_i+1]$ 使得 $$\sum _{i=1}^{x}a[l_i+1]-a[l_i]$$价值最大化。
贪心的角度考虑我们每次选择贡献大于 0 的区间即能使得答案最大化，因此最后答案为

ans = ∑ i = 1 n − 1 max ⁡ { 0 , a [ i ] − a [ i − 1 ] } \textit{ans}=\sum_{i=1}^{n-1}\max\{0,a[i]-a[i-1]\} ans=i=1∑n−1​max{0,a[i]−a[i−1]}其中 $n$ 为数组的长度。
需要说明的是，贪心算法只能用于计算最大利润，计算的过程并不是实际的交易过程。考虑题目中的例子 $[1,2,3,4,5]$，数组的长度 $n=5$，由于对所有的 $1\le i<n$ 都有 $a[i]>a[i-1]$，因此答案为
$$\text{ans}=\sum _{i=1}^{n-1}a[i]-a[i-1]=4$$
但是实际的交易过程并不是进行 4 次买入和 4 次卖出，而是在第 1 天买入，第 5 天卖出。

class Solution{
	public int maxProfit(int[] prices){
		int ans = 0;
		int n = prices.length;
		for(int i = 1; i < n; i++)
			ans += Math.max(0, prices[i] - prices[i - 1];
		return ans;
	}
}

3. 买卖股票的最佳时机 III

1. 问题描述

给定一个数组，它的第 $i$ 个元素是一支给定的股票在第 $i$ 天的价格。设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔交易。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

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

示例 2：

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

示例 3：

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

2. 算法思路

由于我们最多可以完成两笔交易，因此在任意一天结束之后，我们会处于以下五个状态中的一种：
（1）未进行过任何操作；
（2）只进行过一次买操作；
（3）进行了一次买操作和一次卖操作，即完成了一笔交易；
（4）在完成了一笔交易的前提下，进行了第二次买操作；
（5）完成了全部两笔交易。
由于第一个状态的利润显然为 0，因此我们可以不用将其记录。对于剩下的四个状态，我们分别将它们的最大利润记为 ${\text{buy}}_1$，${\text{sell}}_1$，${\text{buy}}_2$以及 ${\text{sell}}_2$。
如果我们知道了第 $i-1$ 天结束后的这四个状态，那么如何通过状态转移方程得到第 $i$ 天结束后的这四个状态呢？
对于 ${\text{buy}}_1$ 而言，在第 $i$ 天我们可以不进行任何操作，保持不变，也可以在未进行任何操作的前提下以 $\text{prices}[i]$ 的价格买入股票，那么 ${\text{buy}}_1$的状态转移方程即为：
buy 1 = max ⁡ { buy 1 ′ , − prices [ i ] } \textit{buy}_1 = \max \{ \textit{buy}_1', -\textit{prices}[i] \} buy1​=max{buy1′​,−prices[i]}这里我们用 ${\text{buy}}_1^{\prime }$表示第 $i-1$ 天的状态，以便于和第 $i$ 天的状态 ${\text{buy}}_1$进行区分。
对于 ${\text{sell}}_1$而言，在第 $i$ 天我们可以不进行任何操作，保持不变，也可以在只进行过一次买操作的前提下以 $\text{prices}[i]$ 的价格卖出股票，那么 ${\text{sell}}_1$的状态转移方程即为：
sell 1 = max ⁡ { sell 1 ′ , buy 1 ′ + prices [ i ] } \textit{sell}_1 = \max \{ \textit{sell}_1', \textit{buy}_1' + \textit{prices}[i] \} sell1​=max{sell1′​,buy1′​+prices[i]}同理我们可以得到 ${\text{buy}}_2$和 ${\text{sell}}_2$对应的状态转移方程： buy 2 = max ⁡ { buy 2 ′ , sell 1 ′ − prices [ i ] } sell 2 = max ⁡ { sell 2 ′ , buy 2 ′ + prices [ i ] } \begin{aligned} & \textit{buy}_2 = \max \{ \textit{buy}_2', \textit{sell}_1' - \textit{prices}[i] \} \\ & \textit{sell}_2 = \max \{ \textit{sell}_2', \textit{buy}_2' + \textit{prices}[i] \} \end{aligned} ​buy2​=max{buy2′​,sell1′​−prices[i]}sell2​=max{sell2′​,buy2′​+prices[i]}​在考虑边界条件时，我们需要理解下面的这个事实：
无论题目中是否允许「在同一天买入并且卖出」这一操作，最终的答案都不会受到影响，这是因为这一操作带来的收益为零。
因此，在状态转移时，我们可以直接写成：
{ buy 1 = max ⁡ { buy 1 , − prices [ i ] } sell 1 = max ⁡ { sell 1 , buy 1 + prices [ i ] } buy 2 = max ⁡ { buy 2 , sell 1 − prices [ i ] } sell 2 = max ⁡ { sell 2 , buy 2 + prices [ i ] } \begin{cases} \textit{buy}_1 = \max \{ \textit{buy}_1, -\textit{prices}[i] \} \\ \textit{sell}_1 = \max \{ \textit{sell}_1, \textit{buy}_1 + \textit{prices}[i] \} \\ \textit{buy}_2 = \max \{ \textit{buy}_2, \textit{sell}_1 - \textit{prices}[i] \} \\ \textit{sell}_2 = \max \{ \textit{sell}_2, \textit{buy}_2 + \textit{prices}[i] \} \end{cases} ⎩ ⎨ ⎧​buy1​=max{buy1​,−prices[i]}sell1​=max{sell1​,buy1​+prices[i]}buy2​=max{buy2​,sell1​−prices[i]}sell2​=max{sell2​,buy2​+prices[i]}​例如在计算 ${\text{sell}}_1$时，我们直接使用 ${\text{buy}}_1$而不是 ${\text{buy}}_1^{\prime }$进行转移。${\text{buy}}_1$比 ${\text{buy}}_1^{\prime }$多考虑的是在第 $i$ 天买入股票的情况，而转移到${\text{sell}}_1$时，考虑的是在第 $i$ 天卖出股票的情况，这样在同一天买入并且卖出收益为零，不会对答案产生影响。同理对于${\text{buy}}_2$以及 ${\text{sell}}_2$，我们同样可以直接根据第 $i$ 天计算出的值来进行状态转移。
那么对于边界条件，我们考虑第 $i=0$ 天时的四个状态：起初我们手里本钱为0，${\text{buy}}_1$即为以 $\text{prices}[0]$ 的价格买入股票，因此${\text{buy}}_1=-\text{prices}[0]$；${\text{sell}}_1$即为在同一天买入并且卖出，因此 ${\text{sell}}_1=0$；${\text{buy}}_2$即为在同一天买入并且卖出后再以 $\text{prices}[0]$ 的价格买入股票，因此 ${\text{buy}}_2=-\text{prices}[0]$；同理可得 ${\text{sell}}_2=0$。我们将这四个状态作为边界条件，从 $i=1$ 开始进行动态规划，即可得到答案。
在动态规划结束后，由于我们可以进行不超过两笔交易，因此最终的答案在 0，${\text{sell}}_1$，${\text{sell}}_2$中，且为三者中的最大值。然而我们可以发现，由于在边界条件中 ${\text{sell}}_1$和 ${\text{sell}}_2$的值已经为 0，并且在状态转移的过程中我们维护的是最大值，因此 ${\text{sell}}_1$和 ${\text{sell}}_2$ 最终一定大于等于 0。同时，如果最优的情况对应的是恰好一笔交易，那么它也会因为我们在转移时允许在同一天买入并且卖出这一宽松的条件，从 ${\text{sell}}_1$转移至 ${\text{sell}}_2$，因此最终的答案即为 ${\text{sell}}_2$.。

Class Solution{
	public int maxProfit(int[] prices){
		int n = prices.length;
		int buy1 = -prices[0], sell1 = 0;
		int buy2 = -prices[0], sell2  = 0;
		for(int i = 1; i < n; ++i){
			buy1 = Math.max(buy1, -prices[i]);
			sell1 = Math.max(sell1, buy1 + prices[i]);
			buy2 = Math.max(buy2, sell1 - prices[i]);
			sell2 = Math.max(sell2, buy2 + prices[i]);
		}
		return sell2;
	}
}