标签：不能 http 关系 etc self dp2 版本 存储 包含
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。
限制只能买入卖出一次
buy[i]记录截止到第i天是买入的状态的最小花费（值为负数）
1 class Solution { 2 public: 3 int maxProfit(vector<int>& prices) { 4 if(prices.size()<2){ 5 return 0; 6 } 7 int n=prices.size(),res=0; 8 vector<int> buy(n,0); 9 buy[0]=-prices[0]; 10 for(int i=1;i<n;++i){ 11 res=max(buy[i-1]+prices[i],res); 12 buy[i]=max(-prices[i],buy[i-1]); 13 } 14 return res; 15 } 16 };
严格来说这个不算dp，计算第i天的情况时，只用到了buy[i-1]的数据。。所以前面保存的数据是没有意义的。
dp[i]记录第i天当天卖出的最大利润，则最大利润一定等于之前某天买今天卖。
i):首先可以昨天买今天卖。
ii):还可以之前某天买今天卖。dp[i-1]等于昨天之前买入，i-1天卖出的最大利润，那么i-1天不卖，改为第i天卖也可以得到一个利润。
两个利润取最大。
1 class Solution { 2 public: 3 int maxProfit(vector<int>& prices) { 4 if(prices.size()<2){ 5 return 0; 6 } 7 int n=prices.size(); 8 vector<int> dp(n,0); 9 dp[0]=0; 10 int res=0; 11 for(int i=1;i<n;++i){ 12 dp[i]=max(0,prices[i]-prices[i-1]); 13 dp[i]=max(dp[i],dp[i-1]-prices[i-1]+prices[i]); 14 res=max(res,dp[i]); 15 } 16 return res; 17 } 18 };
和DP一样都是O(N)时间，和第一种dp一样想法，只是不用记录dp数组了。毕竟考察i的时候，只需要buy[i-1]的数据。
思路：最高利润出现在：买入为价格最低时，卖出为买入之后价格最高时。
故当更新最小值价格时，之前的最大价格要舍弃，从当前索引继续考察。
1 class Solution: 2 def maxProfit(self, prices: List[int]) -> int: 3 l=len(prices) 4 if l<2: 5 return 0 6 _min,_max=0,0 7 i=0 8 res=0 9 while i<l: 10 if prices[i]<prices[_min]: 11 _min=i 12 _max=i 13 if prices[i]>prices[_max]: 14 _max=i 15 res=max(res,prices[_max]-prices[_min]) 16 i+=1 17 return res
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
无限制次数的买入卖出
1 class Solution { 2 public: 3 int maxProfit(vector<int>& prices) { 4 int n=prices.size(); 5 if(n<2){return 0;} 6 vector<int> buy(n,0),sell(n,0); 7 buy[0]=-prices[0]; 8 for(int i=1;i<n;++i){ 9 sell[i]=max(sell[i-1],prices[i]+buy[i-1]);//之前卖今天不卖 or 之前买今天卖 10 buy[i]=max(buy[i-1],sell[i-1]-prices[i]);//之前买今天不买 or 之前卖了今天买 11 } 12 return sell[n-1]; 13 } 14 };
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iii/
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。
限制最多两次买入卖出
定义了4个dp数组，分别是
buy1[i]：第i天是第一次买入的状态
sell[i]:第i天是第一次卖出的状态
buy2、sell2同理。
由于一开始还不能第二次买和第二次卖，所以赋值为负无穷。
1 class Solution { 2 public: 3 #define inf INT_MIN 4 int maxProfit(vector<int>& prices) { 5 int n=prices.size(); 6 if(n<2){return 0;} 7 vector<int> buy1(n,0),sell1(n,0),buy2(n,inf),sell2(n,inf); 8 buy1[0]=-prices[0]; 9 for(int i=1;i<n;++i){ 11 sell1[i]=max(prices[i]+buy1[i-1],sell1[i-1]); 12 buy1[i]=max(-prices[i],buy1[i-1]); 13 sell2[i]=max(buy2[i-1]+prices[i],sell2[i-1]); 14 buy2[i]=max(buy2[i-1],sell1[i-1]-prices[i]); 16 } 17 return max(0,max(sell2[n-1],sell1[n-1])); 18 } 19 };
方法2：先计算1次买卖最大的利润sell1[i]。再计算从第i天开始再买卖一次最大的利润sell2[i]。
第一次买卖是从前向后求（因为左侧是固定的），第二次买卖是从后向前求（因为右侧是固定的）
1 class Solution { 2 public: 3 #define inf INT_MIN 4 int maxProfit(vector<int>& prices) { 5 int n=prices.size(); 6 if(n<2){return 0;} 7 vector<int> sell1(n,0),sell2(n,0); 8 int min_buy=-prices[0]; 9 for(int i=1;i<n;++i){ 10 sell1[i]=max(sell1[i-1],prices[i]+min_buy); 11 min_buy=max(min_buy,-prices[i]); 12 } 13 int res=max(0,sell1[n-1]); 14 int max_sell=prices[n-1]; 15 for(int i=n-2;i>=0;--i){ 16 sell2[i]=max(sell2[i+1],max_sell-prices[i]); 17 max_sell=max(max_sell,prices[i]); 18 res=max(res,sell1[i]+sell2[i]); 19 } 20 return res; 21 } 22 };
之前写过的python版本，以供参考：
1 class Solution: 2 def maxProfit(self, prices) -> int: 3 l=len(prices) 4 if l<2: 5 return 0 6 res=0 7 #先算一个dp1数组 8 #dp1[i]表示截止到第i-1天只进行一次买卖的最大利润 9 dp1=[0 for i in range(l)] 10 max_price,min_price=prices[0],prices[0] 11 for i in range(1,l): 12 dp1[i]=max(dp1[i-1],prices[i]-min_price) 13 #对于第i天来说，1.如果当天卖：最大利润即当前卖出价格 14 #减去之前的最小买入价格，2如果不卖：最大利润和前一天的 15 #最大利润相同 16 min_price=min(min_price,prices[i]) #更新当前最小买入价格 17 max_price=max(max_price,prices[i]) #更新当前最大卖出价格 18 #对于任意k，dp1[k]表示k卖出的最大利润， 19 #那么需要求剩下k+1到n-1的最大利润 20 #倒着求，因为右边界不变始终为l-1，左边界在变化 21 #dp2[i]表示从i开始到最后只进行一次买卖的最大利润 22 res=dp1[-1] 23 # print(res) 24 dp2=[0 for i in range(l)] 25 max_price=prices[-1] 26 for i in range(l-2,-1,-1): 27 dp2[i]=max(dp2[i+1],max_price-prices[i]) 28 #对于第i天，1.若当天买，则最大利润即之后的最大卖出价格减去 29 #当前买入价格，2.若当天不买，最大利润和后一天的最大利润相同 30 max_price=max(max_price,prices[i]) #更新当前最大卖出价格 31 res=max(res,dp1[i-1]+dp2[i]) if i>=1 else max(res,dp2[i]) 32 # print(dp1) 33 # print(dp2) 34 return res
后来发现其实不需要存储dp数组，只需要一个变量记录上一次的状态就行，但我懒，就不写了，反正内存大任性
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iv/
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。
这道题限制买卖次数最大为k，是一个变量。
设二维dp数组。dp[i][j]表示截止到i最多完成j笔交易的最大利润。
截止第i天，最大利润首先可以是之前的最大利润，即之前就完成了j笔交易，第i天不卖。
当然第i天也可以卖，那么本拨交易的买入最晚也得是i-1天，那么i-2天之前（包含i-2天）就必须要完成j-1笔交易。
用一个max值表示截止到前一天完成j-1笔交易、并且是待卖出状态的最大利润。
递推方程为：dp[i][j]=max(dp[i-1][j],max+prices[i])
另外每次循环中要更新max的值。
另外有用例k给的无限大，那么申请dp数组时会爆栈。需要判断一下k和价格数量的关系，如果k太大，转化为上面第2题的无限次的买卖股票问题。
前面的问题1和问题3只是这道题的特殊情况，代码直接复制过去就可以运行。
1 class Solution { 2 public: 3 int maxProfit(int k, vector<int>& prices) { 4 if(prices.empty()){ 5 return 0; 6 } 7 int n=prices.size(); 8 if(2*k<n){ 9 vector<vector<int>> dp(n,vector<int>(k+1,0)); 10 //dp[i][j]表示截止第i天完成最多j次交易得到的最大收益 11 for(int j=1;j<k+1;++j){ 12 int _max=-prices[0]; 13 for(int i=1;i<n;++i){ 14 dp[i][j]=max(dp[i-1][j],_max+prices[i]); 15 _max=max(dp[i-1][j-1]-prices[i],_max); 16 } 17 } 18 return dp.back().back(); 19 } 20 else{//k太大，相当于可以无限次交易 21 vector<int> dp(n,0); 22 //dp[i]表示截止第i+1天得到的最大收益 23 int _max=-prices[0]; 24 for(int i=1;i<n;++i){ 25 dp[i]=max(dp[i-1],_max+prices[i]); 26 _max=max(_max,dp[i]-prices[i]); 27 } 28 return dp.back(); 29 } 30 return 0; 31 } 32 };
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/
给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。?
设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
这道题多了一个冷冻期的限制：卖出之后要至少休息一天才能买入
那么理所当然的，多设立一个dp数组以表示冷冻期的状态：
1 class Solution { 2 public: 3 int maxProfit(vector<int>& prices) { 4 if(prices.size()<2){ 5 return 0; 6 } 7 int n=prices.size(); 8 vector<int> buy(n,0),sell(n,0),freeze(n,0); 9 //buy[i]、sell[i]、freeze[i]分别表示第i天 10 //买入、卖出、不买不卖的最大收益（包含买股票花的钱） 11 buy[0]=-prices[0]; 12 int res=0; 13 for(int i=1;i<n;++i){ 14 buy[i]=max(buy[i-1],freeze[i-1]-prices[i]); 15 sell[i]=max(sell[i-1],buy[i-1]+prices[i]); 16 freeze[i]=max(sell[i-1],freeze[i-1]); 17 res=max(sell[i],res); 18 } 19 return res; 20 } 21 };
也可以仿照第四题的解法，用一个max值保存截止前一天待卖出状态的最大利润，不过更新max的时候，要注意冷冻期的要求。所以_max=max(_max,dp[i-2]-prices[i])，即截止i-2天卖出的最大利润，休息一天，第i天买入。之前的题目是_max=max(_max,dp[i-1]-prices[i])，注意二者的区别，虽然只是1和2的数字不同，但却是整道题的关键
1 class Solution { 2 public: 3 int maxProfit(vector<int>& prices) { 4 int n=prices.size(); 5 if(n<2){return 0;} 6 vector<int> sell(n,0); 7 sell[1]=max(0,prices[1]-prices[0]); 8 int _max=max(-prices[0],-prices[1]); 9 for(int i=2;i<n;++i){ 10 sell[i]=max(sell[i-1],_max+prices[i]); 11 _max=max(_max,sell[i-2]-prices[i]); 12 } 13 // for(int x:sell){cout<<x<<" ";}; 14 return sell[n-1]; 15 } 16 };
完结撒花????
明天就要华为机试了，坏运气给??爬
2020-02-19 02:01:09
Leetocode全部5道买卖股票问题总结(121+122+123+188+309)
标签：不能 http 关系 etc self dp2 版本 存储 包含
原文地址：https://www.cnblogs.com/FdWzy/p/12288157.html
