一、股票买卖
1.1 最多买一次
题目链接：
https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock/submissions/
题目：
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
示例 1：
1 输入：[7,1,5,3,6,4]
2 输出：5
3 解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
4 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
解决：
dp[i][0]：代表第i天之前包括第i天没有任何操作
dp[i][1]：代表第i天之前包括第i天第一次购买
dp[i][2]：代表第i天之前包括第i天第一次卖出
1 class Solution {
2 public:
3 int maxProfit(vector<int>& prices) {
4 int len = prices.size();
5 if(!len)
6 return 0;
7 vector<vector<int> > dp(len, vector<int>(3, 0));
8 dp[0][0] = 0;
9 dp[0][1] = -prices[0];
10 dp[0][2] = 0;
11 for(int i=1; i<len; i++)
12 {
13 dp[i][0] = dp[i-1][0];
14 dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i]);
15 dp[i][2] = max(dp[i-1][2], dp[i-1][1] + prices[i]);
16 }
17 return dp[len-1][2];
18 }
19 };
解决2：
1 class Solution {
2 public:
3 int maxProfit(vector<int>& prices) {
4 int len = prices.size();
5 if(!len)
6 return 0;
7 int k = 1;
8 k = 2 * k + 1;
9 vector<vector<int> > dp(len, vector<int>(k, 0));
10 for(int i=0; i<k; i++)
11 {
12 if(i&1)
13 dp[0][i] = -prices[0];
14 }
15 for(int i=1; i<len; i++)
16 {
17 dp[i][0] = dp[i-1][0];
18 for(int j=1; j<k; j++)
19 {
20 if(j&1)
21 dp[i][j] = max(dp[i-1][j], dp[i-1][j-1] - prices[i]);
22 else
23 dp[i][j] = max(dp[i-1][j], dp[i-1][j-1] + prices[i]);
24 }
25 }
26 return dp[len-1][k-1];
27 }
28 };
1.2 最多买两次
题目链接：
https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iii/submissions/
题目：
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1：
1 输入：prices = [3,3,5,0,0,3,1,4]
2 输出：6
3 解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
4 随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。
解决1：
dp[i][0]：代表第i天之前包括第i天没有任何操作
dp[i][1]：代表第i天之前包括第i天第一次购买
dp[i][2]：代表第i天之前包括第i天第一次卖出
dp[i][3]：代表第i天之前包括第i天第二次购买
dp[i][4]：代表第i天之前包括第i天第二次卖出
1 class Solution {
2 public:
3 int maxProfit(vector<int>& prices) {
4 //0:代表之前没有任何操作，1：代表之前只有购买一次操作
5 int len = prices.size();
6 if(!len)
7 return 0;
8 vector<vector<int> > dp(len, vector<int>(5, 0));
9 dp[0][0] = 0;
10 dp[0][1] = -prices[0];
11 dp[0][2] = 0;
12 dp[0][3] = -prices[0];
13 dp[0][4] = 0;
14 for(int i=1; i<len; i++)
15 {
16 dp[i][0] = dp[i-1][0];
17 dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i]);
18 dp[i][2] = max(dp[i-1][2], dp[i-1][1] + prices[i]);
19 dp[i][3] = max(dp[i-1][3], dp[i-1][2] - prices[i]);
20 dp[i][4] = max(dp[i-1][4], dp[i-1][3] + prices[i]);
21 }
22 return dp[len-1][4];
23 }
24 };
解决2：
1 class Solution {
2 public:
3 int maxProfit(vector<int>& prices) {
4 //0:代表之前没有任何操作，1：代表之前只有购买一次操作
5 int len = prices.size();
6 if(!len)
7 return 0;
8 int k = 2;
9 k = 2 * k + 1;
10 vector<vector<int> > dp(len, vector<int>(k, 0));
11 for(int i=0; i<k; i++)
12 {
13 if(i&1)
14 dp[0][i] = -prices[0];
15 }
16 for(int i=1; i<len; i++)
17 {
18 dp[i][0] = dp[i-1][0];
19 for(int j=1; j<k; j++)
20 {
21 if(j&1)
22 dp[i][j] = max(dp[i-1][j], dp[i-1][j-1] - prices[i]);
23 else
24 dp[i][j] = max(dp[i-1][j], dp[i-1][j-1] + prices[i]);
25 }
26 }
27 return dp[len-1][k-1];
28 }
29 };
1.3 最多买k次，限定数组长度
题目：
给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。数组长度一定满足k次购买，也就是数组长度len大于等于k*2。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1：
1 输入：k = 2, prices = [3,2,6,5,0,3]
2 输出：7
3 解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
4 随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。
解决：
1 class Solution {
2 public:
3 int maxProfit(int k, vector<int>& prices) {
4 int len = prices.size();
5 if(!len)
6 return 0;
7 //int k = 1;
8 k = 2 * k + 1;
9 vector<vector<int> > dp(len, vector<int>(k, 0));
10 for(int i=0; i<k; i++)
11 {
12 if(i&1)
13 dp[0][i] = -prices[0];
14 }
15 for(int i=1; i<len; i++)
16 {
17 dp[i][0] = dp[i-1][0];
18 for(int j=1; j<k; j++)
19 {
20 if(j&1)
21 dp[i][j] = max(dp[i-1][j], dp[i-1][j-1] - prices[i]);
22 else
23 dp[i][j] = max(dp[i-1][j], dp[i-1][j-1] + prices[i]);
24 }
25 }
26 return dp[len-1][k-1];
27 }
28 };
1.4 无限次买卖
题目链接：
https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/
题目：
给定一个数组 prices ，其中 prices[i] 是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1：
1 输入: prices = [1,2,3,4,5]
2 输出: 4
3 解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
4 注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
解决：
1 class Solution {
2 public:
3 int maxProfit(vector<int>& prices) {
4 int len = prices.size();
5 if(len <= 1)
6 return 0;
7 int ans = 0;
8 vector<vector<int> > dp(len, vector<int>(2, 0));
9 dp[0][1] = -prices[0];
10 for(int i=1; i<len; i++)
11 {
12 dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]);
13 dp[i][1] = max(dp[i-1][1], dp[i][0] - prices[i]);
14 }
15 return max(dp[len-1][0], dp[len-1][1]);
16 }
17 };
1.5 最多买k次，不限定数组长度
题目链接：
https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iv/
题目：
给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。数组长度一定满足k次购买，也就是数组长度len大于等于k*2。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1：
1 输入：k = 2, prices = [3,2,6,5,0,3]
2 输出：7
3 解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
4 随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。
解决：
先判断数组长度是否满足k次买卖，也就是数组长度len大于等于2*k；如果满足就按照k次买卖进行动态规划，否则就按照无限次买卖进行动态规划。
1 class Solution {
2 public:
3 int maxProfit(int k, vector<int>& prices) {
4 int len = prices.size();
5 if(k >= len / 2){
6 return maxProfit1(prices);
7 }else
8 return maxProfit2(k, prices);
9 }
10 int maxProfit1(vector<int>& prices){
11 int len = prices.size();
12 if(len <= 1)
13 return 0;
14 vector<vector<int> > dp(len, vector<int>(2, 0));
15 dp[0][0] = 0;
16 dp[0][1] = -prices[0];
17 for(int i=1; i<len; i++){
18 dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i]);
19 dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i]);
20 }
21 return max(dp[len-1][0], dp[len-1][1]);
22 }
23 int maxProfit2(int k, vector<int>& prices){
24 int len = prices.size();
25 if(!len)
26 return 0;
27 //int k = 1;
28 k = 2 * k + 1;
29 vector<vector<int> > dp(len, vector<int>(k, 0));
30 for(int i=0; i<k; i++)
31 {
32 if(i&1)
33 dp[0][i] = -prices[0];
34 }
35 for(int i=1; i<len; i++)
36 {
37 dp[i][0] = dp[i-1][0];
38 for(int j=1; j<k; j++)
39 {
40 if(j&1)
41 dp[i][j] = max(dp[i-1][j], dp[i-1][j-1] - prices[i]);
42 else
43 dp[i][j] = max(dp[i-1][j], dp[i-1][j-1] + prices[i]);
44 }
45 }
46 return dp[len-1][k-1];
47 }
48 };
1.6 买卖含手续费（实际上就是无限次买卖）
题目链接：
https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/
题目：
给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；整数 fee 代表了交易股票的手续费用。
你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。
返回获得利润的最大值。
示例 1：
1 输入：prices = [1, 3, 2, 8, 4, 9], fee = 2
2 输出：8
3 解释：能够达到的最大利润:
4 在此处买入 prices[0] = 1
5 在此处卖出 prices[3] = 8
6 在此处买入 prices[4] = 4
7 在此处卖出 prices[5] = 9
8 总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8
解决：
1 class Solution {
2 public:
3 int maxProfit(vector<int>& prices, int fee) {
4 int n = prices.size();
5 if(n <= 1)
6 return 0;
7 vector<vector<int> > dp(n, vector<int>(2, 0));
8 dp[0][1] = -prices[0];
9 for(int i=1; i<n; i++){
10 dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i] - fee);
11 dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i]);
12 }
13 return max(dp[n-1][0], dp[n-1][1]);
14 }
15 };
1.7 买卖含冷冻期（实际上就是无限次买卖）
题目链接：
https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/
题目：
给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。
设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
示例 1：
1 输入: [1,2,3,0,2]
2 输出: 3
3 解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]
解决：
1 class Solution {
2 public:
3 int maxProfit(vector<int>& prices) {
4 int n = prices.size(), ans = 0;
5 if(n < 2)
6 return ans;
7 vector<vector<int> > dp(n+1, vector<int>(2, 0));
8 dp[1][1] = -prices[0];
9 for(int i=2; i<=n; i++){
10 dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i-1]);
11 dp[i][1] = max(dp[i-1][1], dp[i-2][0] - prices[i-1]);
12 }
13 return max(dp[n][0], dp[n][1]);
14 }
15 };