LeetCode买卖股票的最佳时机系列总结

此类动态规划从二维动规理解后优化到一维动规，部分题目还可以用到贪心。

121 买卖股票的最佳时机（买卖一次）

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在未来的某一个不同的日子卖出该股票。设计一个
算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

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

二维动规
int maxProfit(vector<int>& prices) {int n = prices.size();if(n == 1)return 0;vector<vector<int>>dp(n, vector<int>(2));dp[0][0] = 0;                 // 不持有 = 卖出+还没买dp[0][1] = -prices[0];        // 持有 买过还没卖for(int i = 1; i < n; ++i) {dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i]);//第i天不持有 = max(第i - 1不持有, i - 1天持有+今天卖出)dp[i][1] = max(dp[i - 1][1],  -prices[i]);//第i天持有 = max(第i - 1持有, 今天买入，只买一次)}return dp[n - 1][0];}

一维动规O(N)/O(1)
每一天的状态只与前一天的状态有关，把dp[i - 1][1],dp[i - 1][0]存在两个变量中，
计算出dp[i][1],dp[i][0]在存回对应变量即可
int maxProfit(vector<int>& prices) {int n = prices.size();if(n == 1)return 0;int sell = 0;                // 不持有 = 卖出+还没买int buy = -prices[0];        // 持有 买过还没卖for(int i = 0; i < n; ++i) {int newbuy = max(buy, -prices[i]);int newsell = max(sell, buy + prices[i]);sell = newsell;buy = newbuy;}return sell;}

贪心：
int maxProfit(vector<int>& prices) {int n = prices.size();if(n == 1)return 0;int maxn = 0;int start = prices[0];for(int i = 1; i < n; ++i) {if(prices[i] < start) start = prices[i];//下一个小于假设买入的价格，更新startelse maxn = max(maxn, prices[i] - start);//更新最大利润}return maxn;}

122 买卖股票的最佳时机2 （买卖多次）

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

二维动规
定义状态dp[i][1] 表示第i天交易完后手里没有股票的最大利润，
dp[i][0] 表示第i天交易完后手里持有一支股票的最大利润（i从0开始）。int maxProfit(vector<int>& prices) {int n = prices.size();vector<vector<int>>dp(n, vector<int>(2));dp[0][0] = - prices[0];  //持有dp[0][1] = 0;            //未持有for(int i = 1; i < n; ++i) {dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);//第i天持有 = max(第i - 1持有, i - 1天不持有今天买入)和1不同dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);}return dp[n - 1][1];}
};

一维动规
int maxProfit(vector<int>& prices) {int n = prices.size();int dp0 = -prices[0];int dp1 = 0;for(int i = 1; i < n; ++i) {int newdp0 = max(dp0, dp1 - prices[i]);int newdp1 = max(dp1, dp0 + prices[i]);dp0 = newdp0;dp1 = newdp1;}return dp1;}

贪心，收集所有上坡，和是最大int maxProfit(vector<int>& prices) {int n = prices.size();int maxn = 0;for(int i = 1; i < n; ++i) maxn += max(0, prices[i] - prices[i - 1]);return maxn;}

123 买卖股票最佳时机（买卖2次）

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

二维动规int maxProfit(vector<int>& prices) {int n = prices.size();if(n <= 1)return 0;vector<vector<int>>dp(n, vector<int>(5));dp[0][0] = 0;                  //无操作dp[0][1] = -prices[0];         //第一次买入dp[0][2] = 0;                  //第一次卖出dp[0][3] = -prices[0];         //第二次买入dp[0][4] = 0;                  //第二次卖出for(int i = 1; i < n; ++i) {dp[i][0] = dp[i - 1][0];dp[i][1] = max(dp[i - 1][0] - prices[i], dp[i - 1][1]);//第一次买入 = max(前一天无操作今天买入， 前一天已经买入)dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] + prices[i]);//第一次卖出 = max(前一天已经卖出， 前一天买入今天卖出)dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);//第二次买入 = max(前一天已经第二次买入，前一天是第一次卖出+今天买入)dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);//第二次卖出 = max(前一天已经第二次买入。前一天是第二次买入+今天卖出)}return dp[n - 1][4];}

 一维动规；每一天的状态只与前一天的状态有关int maxProfit(vector<int>& prices) {int n = prices.size();if(n <= 1)return 0;int buy1 = -prices[0];int sell1 = 0;int buy2 = -prices[0];int sell2 = 0;for(int i = 1; i < n; ++i) {buy1 = max(buy1, -prices[i]);sell1 = max(sell1, buy1 + prices[i]);buy2 = max(buy2, sell1 - prices[i]);sell2 = max(sell2, buy2 + prices[i]);}return sell2;}

188买卖股票最佳时机 (买卖k次)

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

二维动规int maxProfit(int k, vector<int>& prices) {int n = prices.size();if(k == 0 || n == 0)return 0;vector<vector<int>>dp(n, vector<int>(2*k + 1, 0));for(int i = 1; i < 2*k; i += 2) dp[0][i] = -prices[0]; //奇数买入for(int i = 1; i < n; i++) {for(int j = 0; j < 2*k - 1; j += 2) {dp[i][j + 1] = max(dp[i - 1][j + 1], dp[i - 1][j] -prices[i]);dp[i][j + 2] = max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);}}return dp[n - 1][2*k];}

309 买卖股票的最佳时机+冷冻期

给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格。
设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

二维动规int maxProfit(vector<int>& prices) {int n = prices.size();vector<vector<int>>dp(n, vector<int>(3));dp[0][0] = -prices[0];   //持有dp[0][1] = 0;            //不持有，在冷冻dp[0][2] = 0;            //不持有，不在冷冻for(int i = 1; i < n; ++i) {dp[i][0] = max(dp[i - 1][0], dp[i - 1][2] - prices[i]);//第i天持有 = max(i - 1天持有， i - 1天不持有不在冷冻 今天买入)dp[i][1] = dp[i - 1][0] + prices[i];//第i天不持有在冷冻 = i - 1刚卖出dp[i][2] = max(dp[i - 1][2],dp[i - 1][1]);//第i天不持有不冷冻 = max(i - 1天不持有不冷冻， i - 1天冷冻)}return max(dp[n - 1][1], dp[n - 1][2]);}

一维，空间优化
int maxProfit(vector<int>& prices) {int n = prices.size();int buy = -prices[0], sell = 0, lock = 0;//持有不持有，在冷冻//不持有，不在冷冻for(int i = 0; i < n; i++) {int newbuy = max(buy, lock - prices[i]);int newsell = buy + prices[i];int newlock = max(lock, sell);buy = newbuy;sell = newsell;lock = newlock;}return max(lock, sell);
}