每天一道LeetCode-----买卖商品问题，计算最大利润，分别有一次交易，两次交易，多次交易的情况

Best Time to Buy and Sell Stock

原题链接Best Time to Buy and Sell Stock

给定一个价格序列prices，其中prices[i]代表第i天商品的价格，商家需要在某一天买入，然后在之后的某一天出售，计算可以获得的最大利润

本质就是计算prices[i]−prices[j]prices[i] - prices[j]的最大值，要求i>ji > j

假设已经直到最后结果的最大值位置i(prices[i])，只需要减去最小值即可，那么就需要直到最小值是多少，本题中当从左到右遍历时，完全可以随着遍历进度的增加记录最小值

代码如下

class Solution {
public:int maxProfit(vector<int>& prices) {if(prices.empty())  return 0;/* 记录目前位置找到的最小值 */int minPrices = prices[0];/* 记录最大差值 */int maxProfit = 0;for(int i = 1; i < prices.size(); ++i){/* 以prices[i]作为最大值，尝试计算差值 */maxProfit = std::max(maxProfit, prices[i] - minPrices);/* 尝试更新最小值 */minPrices = std::min(minPrices, prices[i]);}return maxProfit;}
};

当然也可以遍历两次求解，第一次对于每个位置的值，计算它的右侧比它大的最大值，第二次对于每个位置，计算右侧的最大值与自己的差，更新最大差值，求出结果

代码如下

class Solution {
public:int maxProfit(vector<int>& prices) {int n = prices.size();vector<int> dp(n + 1, 0);/* 计算prices[i]右侧的最大值，包括自己 */for(int i = n - 1; i >= 0; --i)dp[i] = std::max(dp[i + 1], prices[i]);int maxProfit = 0;/* 右侧最大值 - 自身 = 最大差值 */for(int i = 0; i < n; ++i)maxProfit = std::max(maxProfit, dp[i] - prices[i]);return maxProfit;}
};

Best Time to Buy and Sell Stock II

原题链接Best Time to Buy and Sell Stock II

要求和上面一样，不过这次可以进行多次交易，即买，卖，买，卖，买，卖…，其中买卖不能在同一天进行

这样就不能像上面那样只求一次了，其实仔细想一下，序列无非三种排列

递增，假设A<B<C<DA
递减，假设A>B>C>DA > B > C > D
无序，假设A<B>C<DA C

对于递增序列，最大的差值就是D−AD - A，因为(D−A)=(D−C)+(C−B)+(B−A)>(D−C)+(B−A)(D - A) = (D - C) + (C - B) + (B - A) > (D - C) + (B - A)

对于递减序列，为0

对于无序序列，总可以找到若干个递增序列，就上面的例子而言最大差值为(B−A)+(D−C)(B - A) + (D - C)，而实际上也可以写成(D−C)+max(C−B,0)+(B−A)(D - C) + max(C - B, 0) + (B - A)，和递增序列的形式是一样的

所以只要依次计算prices[i]−prices[i−1]prices[i] - prices[i - 1]即可

代码如下

class Solution {
public:int maxProfit(vector<int>& prices) {int maxProfit = 0;for(int i = 1; i < prices.size(); ++i)maxProfit += std::max(prices[i] - prices[i - 1], 0);return maxProfit;}
};

Best Time to Buy and Sell Stock III

原题链接Best Time to Buy and Sell Stock III

同样是买卖问题，本题要求最多可以完成两次交易，计算最大利润

利用动态规划，对动态规划数组states[i][j]有如下规定

states[][0]代表0次买，0次卖的利润
states[][1]代表一次买，0次卖的利润(显然是负数)
states[][2]代表一次买，一次卖的利润
states[][3]代表两次买，一次卖的利润
states[][4]代表两次买，两次卖的利润

而states，规定它是二维数组，states[0]代表当前的利润，states[1]代表执行完本次操作后的利润，那么有

states[1][1] = std::max(states[0][1], states[0][0] - prices[i])，表示买入商品prices[i]，那么利润就是0次买0次卖的利润减商品价格，当然需要和1次买0次卖比较，选择较大的那个
states[1][2] = std::max(states[0][2], states[0][1] + prices[i])，表示卖出商品prices[i]，那么利润就是1次买0次卖的利润加商品价格，当然需要和1次买1次卖比较，选择较大的那个
…同理

初始状态，另1次买0次卖的利润为INT_MIN，两次买一次卖的利润为INT_INT，是为了让max选择后者，因为初始状态没有买入任何商品

代码如下

class Solution {
public:int maxProfit(vector<int>& prices) {vector<vector<int>> states(2, vector<int>(2 * 2 + 1, 0));states[0][0] = 0;for(int i = 1; i < 2 * 2 + 1; i += 2){states[0][i] = INT_MIN;states[0][i + 1] = 0;}int cur = 0, next = 1;for(int i = 0; i < prices.size(); ++i){states[next][1] = std::max(states[cur][1], states[cur][0] - prices[i]);states[next][2] = std::max(states[cur][2], states[cur][1] + prices[i]);states[next][3] = std::max(states[cur][3], states[cur][2] - prices[i]);states[next][4] = std::max(states[cur][4], states[cur][3] + prices[i]);/* next变为当前 */std::swap(next, cur);}return states[cur][2 * 2];}
};

Best Time to Buy and Sell Stock IV

原题链接Best Time to Buy and Sell Stock IV

和上面一样，要求最多可以进行k次交易

只需要将上面的两次交易换成k次即可

class Solution {
public:int maxProfit(int k, vector<int>& prices) {vector<vector<int>> states(2, vector<int>(2 * k + 1, 0));  states[0][0] = 0;for(int i = 1; i < 2 * k + 1; i += 2){states[0][i] = INT_MIN;states[0][i + 1] = 0;}int cur = 0, next = 1;for(int i = 1; i < prices.size(); ++i){/* 把两次变为k次，就需要放在循环里了 */for(int j = 1; j < 2 * k + 1; j += 2){states[next][j] = std::max(states[cur][j], states[cur][j - 1] - prices[i]);states[next][j + 1] = std::max(states[cur][j + 1], states[cur][j] + prices[i]);}std::swap(next, cur);}return states[cur][2 * k];}
};

不过这样可能内存溢出，因为如果k很大，申请的内存很容易溢出，解决方法是当k很大时采用其他方法。什么时候k算大呢，就是k次交易可以涉及到每一天，也就是k >= prices.size() / 2，此时就可以转换为没有交易次数限制的问题

代码如下

class Solution {
public:int maxProfit(int k, vector<int>& prices) {/* 如果k很大，采用其他方式 */if(k >= prices.size() / 2)return quickSolver(prices);vector<vector<int>> states(2, vector<int>(2 * k + 1, 0));  for(int i = 1; i < 2 * k + 1; i += 2){states[0][i] = INT_MIN;states[0][i + 1] = 0;}int cur = 0, next = 1;for(int i = 0; i < prices.size(); ++i){/* 把两次变为k次，就需要放在循环里了 */for(int j = 1; j < 2 * k + 1; j += 2){states[next][j] = std::max(states[cur][j], states[cur][j - 1] - prices[i]);states[next][j + 1] = std::max(states[cur][j + 1], states[cur][j] + prices[i]);}std::swap(next, cur);}return states[cur][2 * k];}
private:/* 没有交易次数限制，直接遍历，见第二题 */int quickSolver(vector<int>& prices){int profit = 0;for(int i = 1; i < prices.size(); ++i)profit += std::max(prices[i] - prices[i - 1], 0);return profit;}
};

第一道题的第一种解法比较好，直接遍历一遍同时记录最小值和最大差值，同时也没有额外的空间使用

第二道题不太容易理解，其实对于序列无非递增，递减，无序三种可能，分别观察一下即可

第三第四题主要以动态规划为主