【动态规划】买卖股票系列
121.买卖股票的最佳时机
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。
注意：你不能在买入股票前卖出股票。
示例 1:
输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 =6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
示例 2:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
1 class Solution { 2 public int maxProfit(int[] prices) { 3 4 int pos=0; 5 int max=0; 6 7 for(int i=1;i<prices.length;i++){ 8 if(prices[i]<prices[pos]){ 9 pos=i;//最小值下标 10 } 11 max=max>prices[i]-prices[pos]?max:prices[i]-prices[pos]; 12 // 前i天的最大收益 = max{前i-1天的最大收益，第i天的价格-前i-1天中的最小价格} 13 //记录【今天之前买入的最小值】 14 //计算【今天之前最小值买入，今天卖出的获利】，也即【今天卖出的最大获利】 15 //比较【每天的最大获利】，取最大值即可 16 } 17 return max; 18 } 19 }
贪心，复杂度O(n)
122. 买卖股票的最佳时机 II
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 =5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
示例 2:
输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 =5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
提示：
1 <= prices.length <= 3 * 10 ^ 4
0 <= prices[i] <= 10 ^ 4
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
法一：贪心
贪心算法只能用于计算最大利润，计算的过程并不是实际的交易过程。
1 class Solution { 2 public int maxProfit(int[] prices) { 3 int ans = 0; 4 int n = prices.length; 5 for (int i = 1; i < n; ++i) { 6 ans += Math.max(0, prices[i] - prices[i - 1]); 7 } 8 return ans; 9 } 10 }
法二：动态规划
要点在于分析状态以及状态之间的转移关系
1 public class Solution { 2 3 public int maxProfit(int[] prices) { 4 int len = prices.length; 5 if (len < 2) { 6 return 0; 7 } 8 9 // cash：持有现金 10 // hold：持有股票 11 // 状态转移：cash → hold → cash → hold → cash → hold → cash 12 13 int cash = 0; 14 int hold = -prices[0]; 15 16 int preCash = cash; 17 int preHold = hold; 18 for (int i = 1; i < len; i++) { 19 cash = Math.max(preCash, preHold + prices[i]); 20 hold = Math.max(preHold, preCash - prices[i]); 21 22 preCash = cash; 23 preHold = hold; 24 } 25 return cash; 26 } 27 }
123. 买卖股票的最佳时机 III
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。
注意: 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入: [3,3,5,0,0,3,1,4]
输出: 6
解释: 在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 =3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。
示例 2:
输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 =5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3:
输入: [7,6,4,3,1]
输出: 0
解释: 在这个情况下, 没有交易完成, 所以最大利润为 0。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
动态规划。使用滚动数组来优化空间代替dp数组。要分析出每个时刻的状态。状态的初始值要根据状态之间的关系来设定。首先肯定可以找到至少一个状态的初始值，剩余状态的初始值就根据这个确定的来设定。
1 class Solution { 2 public int maxProfit(int[] prices) { 3 if(prices==null || prices.length==0) { 4 return 0; 5 } 6 int n = prices.length; 7 //定义5种状态，并初始化第一天的状态 8 int dp0 = 0; 9 int buy1 = -prices[0];//第一次买入 10 int sell1 = 0;//第一次卖出 11 int buy2 = -prices[0];//第二次买入.由于第一天不能买入两次，所以初值设为sell1(初值)-price[0] 12 int sell2 = 0;//第二次卖出。由于第一天不能卖出，所以初值设为buy2(初值)+price[0] 13 for(int i=1;i<n;++i) { 14 //这里省略dp0，因为dp0每次都是从上一个dp0来的相当于每次都是0 15 //处理第一次买入、第一次卖出 16 buy1 = Math.max(buy1,dp0-prices[i]); 17 sell1 = Math.max(sell1,buy1+prices[i]); 18 //处理第二次买入、第二次卖出 19 buy2 = Math.max(buy2,sell1-prices[i]); 20 sell2 = Math.max(sell2,buy2+prices[i]); 21 } 22 //返回最大值 23 return Math.max(0,Math.max(Math.max(buy1,sell1),Math.max(buy2,sell2))); 24 } 25 }
188. 买卖股票的最佳时机 IV
给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1：
输入：k = 2, prices = [2,4,1]
输出：2
解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天(股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。
示例 2：
输入：k = 2, prices = [3,2,6,5,0,3]
输出：7
解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。
提示：
0 <= k <= 1 0 9 10^9109
0 <= prices.length <= 1000
0 <= prices[i] <= 1000
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iv
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
1 class Solution { 2 public int maxProfit(int k, int[] prices) { 3 int len=prices.length; 4 if(len==0||k==0)return 0; 5 if(k >= prices.length/2) return greedy(prices); 6 //第i天，交易了j次，卖出or买入 7 int dp[][][]=new int[len][k+1][2]; 8 9 dp[0][0][0]=0; 10 dp[0][0][1]=-prices[0]; 11 12 for(int i=0;i<len;i++){ 13 for(int j=1;j<=k;j++){ 14 if (i==0){ 15 //初始化 16 dp[i][j][0]=0;//卖出 17 dp[i][j][1]=-prices[0];//买入 18 }else{ 19 //dp[i][k-1][1]和dp[i][k][0] 这两个是一对，对应是第k次买入、第k次卖出 20 //注意j还是j-1 21 //例如j=1时卖出，就是第一次卖出.比较的是price[i]的大小，无需j-1 22 dp[i][j][0]=Math.max(dp[i-1][j][0],dp[i-1][j][1]+prices[i]);//第j次卖出 23 //例如j=1时买入，其实是第二次买入了，对应的是第一次卖出的钱减去当前price 24 dp[i][j][1]=Math.max(dp[i-1][j][1],dp[i-1][j-1][0]-prices[i]);//第j次买入 25 } 26 27 } 28 } 29 int ans=0; 30 for(int i=0;i<=k;i++){ 31 ans=Math.max(dp[len-1][i][0],ans); 32 } 33 return ans; 34 } 35 //直接贪心 36 private int greedy(int[] prices) { 37 int max = 0; 38 for(int i = 1; i < prices.length; ++i) { 39 if(prices[i] > prices[i-1]) 40 max += prices[i] - prices[i-1]; 41 } 42 return max; 43 } 44 }
309. 最佳买卖股票时机含冷冻期
给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。
设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
示例:
输入: [1,2,3,0,2]
输出: 3
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-cooldown
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
法一：动态规划
1 class Solution { 2 public int maxProfit(int[] prices) { 3 int len=prices.length; 4 if(len==0)return 0; 5 int dp[][]=new int[len][3]; 6 //状态是指当天交易完的状态！ dp[i] 表示第 i 天结束之后的「累计最大收益」 7 dp[0][0]=-prices[0];//买入 8 dp[0][1]=0;//卖出且处于冷冻期 9 dp[0][2]=0;//卖出且不处于冷冻期 10 11 for(int i=1;i<len;i++){ 12 13 dp[i][0]=Math.max(dp[i-1][2]-prices[i],dp[i-1][0]);//更新买入.只有不处于冷冻期才能买入 14 dp[i][1]=dp[i-1][0]+prices[i];//卖出后马上进入冷冻期 15 dp[i][2]=Math.max(dp[i-1][1],dp[i-1][2]);//卖出且不处于冷冻期 16 17 18 } 19 return Math.max(dp[len-1][1],dp[len-1][2]); 20 } 21 }
法二：动态规划，用两个数组来保存状态，在买入的时候注意处理
1 class Solution { 2 public int maxProfit(int[] prices) { 3 if (prices.length <= 1) { 4 return 0; 5 } 6 7 int[] buy = new int[prices.length]; 8 int[] sell = new int[prices.length]; 9 buy[0] = - prices[0]; 10 sell[0] = 0; 11 //buy[1]选择-prices[0]和-prices[1]中的较大值,因为如果第1天为buy状态，之前不会存在卖的操作 12 buy[1] = Math.max(buy[0], -prices[1]); 13 sell[1] = Math.max(sell[0], buy[0] + prices[1]); 14 for (int i = 2; i < prices.length; i++) { 15 //维持第i-1天卖掉的状态，或者在第i-1天买入的情况下第i天卖掉 16 sell[i] = Math.max(sell[i - 1], buy[i - 1] + prices[i]); 17 //维持第i-1天买入的状态，或者在第i-2天卖掉的情况下买入第i天股票 18 buy[i] = Math.max(buy[i - 1], sell[i - 2] - prices[i]); 19 } 20 return sell[prices.length - 1]; 21 } 22 }
浙公网安备 33010602011771号