记录下买卖股票类型动态规划题目使用的状态转移方程。
121. 买卖股票的最佳时机
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
只能交易一次
c
#define MAX(x,y) ((x)>(y)?(x):(y))
int maxProfit(int* prices, int pricesSize) {
int highest = prices[pricesSize-1];
int res = 0;
for(int i=pricesSize-2; i>=0; i--) {
if(prices[i] < highest) {
res = MAX(res, highest-prices[i]);
}
else {
highest = prices[i];
}
}
return res;
}122. 买卖股票的最佳时机 II
给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。
在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。然而，你可以在 同一天 多次买卖该股票，但要确保你持有的股票不超过一股。
返回 你能获得的 最大 利润 。
交易次数不限
c
#define MAX(x,y) ((x)>(y)?(x):(y))
int maxProfit(int* prices, int pricesSize) {
// head = NULL;
// return dp(prices, pricesSize, 0, false);
// dp[i][1] 在第i天持股的最大收益
// dp[i][0] 在第i天不持股的最大收益
int dp[pricesSize][2];
dp[0][0] = 0;
dp[0][1] = -1*(prices[0]);
for(int i=1; i<pricesSize; i++) {
// 不买 买入
dp[i][1] = MAX(dp[i-1][1], dp[i-1][0]-prices[i]);
// 卖出 卖不了保持
dp[i][0] = MAX(dp[i-1][1]+prices[i], dp[i-1][0]);
}
return dp[pricesSize-1][0];
}714. 买卖股票的最佳时机含手续费
给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格 ；整数 fee 代表了交易股票的手续费用。
你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。
返回获得利润的最大值。
注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。
交易成本变动
c
#define MAX(x,y) ((x)>(y)?(x):(y))
int maxProfit(int* prices, int pricesSize, int fee) {
// dp[i][1] 在第i天持股的最大收益
// dp[i][0] 在第i天不持股的最大收益
int dp[pricesSize][2];
dp[0][0] = 0;
dp[0][1] = -1*(prices[0])-fee;
for(int i=1; i<pricesSize; i++) {
// 不买 买入
dp[i][1] = MAX(dp[i-1][1], dp[i-1][0]-prices[i]-fee);
// 卖出 卖不了保持
dp[i][0] = MAX(dp[i-1][1]+prices[i], dp[i-1][0]);
}
return dp[pricesSize-1][0];
}123. 买卖股票的最佳时机 III
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
交易次数限制
c
#define MAX(x,y) ((x)>(y)?(x):(y))
int maxProfit(int* prices, int pricesSize) {
// 交易次数：完成购买和卖出的完整过程，因此重点在卖出时交易次数上涨
// dp[i][j][0] 第i天第j次交易未持有的最大金额
// dp[i][j][0] 第i天第j次交易持有的最大金额
int dp[pricesSize][3][2];
// 假设同一天可以交易多次 dp[0][1][0] 表示第一天交易一次（买入和卖出一次），因此获利0。这么设置保证交易最多次数的金额最大。
for(int j=0; j<3; j++) {
dp[0][j][0] = 0;
dp[0][j][1] = (-1)*prices[0];
}
for(int i=1; i<pricesSize; i++) {
for(int j=0; j<3; j++) {
// 不卖
dp[i][j][0] = dp[i-1][j][0];
if(j > 0) {
// 卖出
dp[i][j][0] = MAX(dp[i-1][j-1][1]+prices[i], dp[i][j][0]);
// 买了立即卖出
dp[i][j][0] = MAX(dp[i][j-1][1]+prices[i], dp[i][j][0]);
}
// 买入 不买
dp[i][j][1] = MAX(dp[i-1][j][0]-prices[i], dp[i-1][j][1]);
// 卖了又立即买入
dp[i][j][1] = MAX(dp[i][j][0]-prices[i], dp[i][j][1]);
}
}
// for(int i=0; i<pricesSize; i++) {
// for(int j=0; j<3; j++) {
// printf("%d %d,", dp[i][j][0], dp[i][j][1]);
// }
// printf("\n");
// }
return dp[pricesSize-1][2][0];
}188. 买卖股票的最佳时机 IV
给你一个整数数组 prices 和一个整数 k ，其中 prices[i] 是某支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说，你最多可以买 k 次，卖 k 次。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
交易次数限制
c
#define MAX(x,y) ((x)>(y)?(x):(y))
int maxProfit(int k, int* prices, int pricesSize) {
// 交易次数：完成购买和卖出的完整过程，因此重点在卖出时交易次数上涨
// dp[i][j][0] 第i天第j次交易未持有的最大金额
// dp[i][j][0] 第i天第j次交易持有的最大金额
int dp[pricesSize][k+1][2];
// 假设同一天可以交易多次 dp[0][1][0] 表示第一天交易一次（买入和卖出一次），因此获利0。这么设置保证交易最多次数的金额最大------返回时可以直接返回dp[pricesSize-1][k][0]。
for(int j=0; j<k+1; j++) {
dp[0][j][0] = 0;
dp[0][j][1] = (-1)*prices[0];
}
for(int i=1; i<pricesSize; i++) {
for(int j=0; j<k+1; j++) {
// 不卖
dp[i][j][0] = dp[i-1][j][0];
if(j > 0) {
// 卖出
dp[i][j][0] = MAX(dp[i-1][j-1][1]+prices[i], dp[i][j][0]);
// 买了立即卖出
dp[i][j][0] = MAX(dp[i][j-1][1]+prices[i], dp[i][j][0]);
}
// 买入 不买
dp[i][j][1] = MAX(dp[i-1][j][0]-prices[i], dp[i-1][j][1]);
// 卖了又立即买入
dp[i][j][1] = MAX(dp[i][j][0]-prices[i], dp[i][j][1]);
}
}
// for(int i=0; i<pricesSize; i++) {
// for(int j=0; j<k+1; j++) {
// printf("%d %d,", dp[i][j][0], dp[i][j][1]);
// }
// printf("\n");
// }
return dp[pricesSize-1][k][0];
}309. 买卖股票的最佳时机含冷冻期
给定一个整数数组prices，其中第 prices[i] 表示第 i 天的股票价格 。
设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
交易间隔限制
c
#define MAX(x,y) ((x)>(y)?(x):(y))
int maxProfit(int* prices, int pricesSize) {
// dp[i][1][1] 已持有但还在冷冻期不可能，不用
// dp[i][1][0] 在第i天持股的最大收益
// dp[i][0][1] 在第i天不持股刚卖出的最大收益
// dp[i][0][0] 在第i天不持股无冷冻期的最大收益
int dp[pricesSize][2][2];
dp[0][0][1] = 0;
dp[0][0][0] = 0;
dp[0][1][0] = -1*(prices[0]);
// dp[0][1][1] = INT_MIN;
for(int i=1; i<pricesSize; i++) {
// 不买 买入
dp[i][1][0] = MAX(dp[i-1][1][0], dp[i-1][0][0]-prices[i]);
// 过冷冻期 不卖
dp[i][0][0] = MAX(dp[i-1][0][1], dp[i-1][0][0]);
// 卖出
dp[i][0][1] = dp[i-1][1][0]+prices[i];
}
return MAX(dp[pricesSize-1][0][0], dp[pricesSize-1][0][1]);
}该题目可用二维动态规划处理，状态转移方程为：
dp[i][1] = MAX(dp[i-1][1], dp[i-2][0]-prices[i])
dp[i][0] = MAX(dp[i-1][0], dp[i-1][1]+prices[i])
看的别人的解法可以通过，相比不限次数，变动点在买入时机，我理解在i-2买入表示尽可能多的交易，状态方程能保证交易次数越多利润也越多就行。