目录
一、Leetcode 题目
1. 打家劫舍系列
（1）打家劫舍
https://leetcode.cn/problems/house-robber/description/你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
示例 1：
输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。
示例 2：
输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。理解：
① dp[i]：考虑下标 i（包括 i）以内的房屋，最多可以偷窃的金额为 dp[i]。
② 决定 dp[i] 的因素就是第 i 房间偷还是不偷。
如果偷第i房间，那么 dp[i] = dp[i - 2] + nums[i] ，即：第 i-1 房一定是不考虑的，找出 下标 i-2 （包括 i-2）以内的房屋，最多可以偷窃的金额为 dp[i-2] 加上第i房间偷到的钱。
如果不偷第i房间，那么 dp[i] = dp[i - 1]，即考 虑 i-1 房，（注意这里是考虑，并不是一定要偷 i-1 房）。然后 dp[i] 取最大值，即 dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
③ 从递推公式 dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]); 可以看出，递推公式的基础就是 dp[0] 和 dp[1]。从 dp[i] 的定义上来讲，dp[0] 一定是 nums[0]，dp[1] 就是 nums[0] 和 nums[1] 的最大值即：dp[1] = max(nums[0], nums[1]);
class Solution {
public:
int rob(vector<int>& nums) {
if (nums.size() == 0) return 0;
if (nums.size() == 1) return nums[0];
vector<int> dp(nums.size(), 0);
dp[0] = nums[0];
dp[1] = max(nums[0], nums[1]);
for (int i = 2; i < nums.size(); i++) {
// 当前房子有两种选择：偷 / 不偷
dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
}
return dp[nums.size() - 1];
}
};
（2）打家劫舍II
你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。
示例 1：
输入：nums = [2,3,2]
输出：3
解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。
示例 2：
输入：nums = [1,2,3,1]
输出：4
解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
偷窃到的最高金额 = 1 + 3 = 4 。
示例 3：
输入：nums = [1,2,3]
输出：3理解：
对于一个数组，成环的话主要有如下三种情况：
- 情况一：考虑不包含首尾元素
- 情况二：考虑包含首元素，不包含尾元素
- 情况三：考虑包含尾元素，不包含首元素
class Solution {
public:
int rob(vector<int>& nums) {
if (nums.size() == 0) return 0;
if (nums.size() == 1) return nums[0];
int result1 = robRange(nums, 0, nums.size() - 2); // 考虑头，不考虑尾
int result2 = robRange(nums, 1, nums.size() - 1); // 考虑尾，不考虑头
return max(result1, result2);
}
int robRange(vector<int>& nums, int start, int end) {
if (end == start) return nums[start];
vector<int> dp(nums.size());
dp[start] = nums[start];
dp[start + 1] = max(nums[start], nums[start + 1]);
for (int i = start + 2; i <= end; i++) {
dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
}
return dp[end];
}
};
（3）打家劫舍 III
小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为
root。除了
root之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。给定二叉树的
root。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额 。
示例 1:
输入: root = [3,2,3,null,3,null,1]
输出: 7
解释: 小偷一晚能够盗取的最高金额 3 + 3 + 1 = 7
示例 2:
输入: root = [3,4,5,1,3,null,1]
输出: 9
解释: 小偷一晚能够盗取的最高金额 4 + 5 = 9① 记忆递归
使用一个 map 把计算过的结果保存一下，这样如果计算过孙子了，那么计算孩子的时候可以复用孙子节点的结果。
// 方法一：（记忆递归）
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
unordered_map<TreeNode*, int> umap;
int rob(TreeNode* root) {
if (root == nullptr) return 0;
if (!root->left && !root->right) return root->val;
if (umap[root]) return umap[root]; // 遍历过节点了，复用上次记录的结果
// 比大小，val1：选父节点；val2：选子节点
int val1 = root->val;
if (root->left) val1 += rob(root->left->left) + rob(root->left->right);
if (root->right) val1 += rob(root->right->left) + rob(root->right->right);
int val2 = rob(root->left) + rob(root->right);
umap[root] = max(val1, val2); // 记录当前节点的最佳选择
return max(val1, val2);
}
};② 递归法
dp数组（dp table）以及下标的含义：下标为0记录不偷该节点所得到的的最大金钱，下标为1记录偷该节点所得到的的最大金钱。
- 通过递归左节点，得到左节点偷与不偷的金钱。
- 通过递归右节点，得到右节点偷与不偷的金钱。
如果是偷当前节点，那么左右孩子就不能偷，val1 = cur->val + left[0] + right[0]; （如果对下标含义不理解就再回顾一下dp数组的含义）
如果不偷当前节点，那么左右孩子就可以偷，至于到底偷不偷一定是选一个最大的，所以：val2 = max(left[0], left[1]) + max(right[0], right[1]);
最后当前节点的状态就是{val2, val1}; 即：{不偷当前节点得到的最大金钱，偷当前节点得到的最大金钱}
// 方法二：（动态规划）
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
int rob(TreeNode* root) {
// 动态规划 dp 意义为当前节点偷或不偷的钱
vector<int> dp = robTree(root);
return max(dp[0], dp[1]);
}
vector<int> robTree(TreeNode* root) {
vector<int> dp(2, 0);
// 遍历到叶子节点返回
if (root == nullptr) return dp;
// 后序遍历，从叶子节点向上遍历
vector<int> left = robTree(root->left);
vector<int> right = robTree(root->right);
// 计算节点的 dp，0:偷，1:不偷
dp[0] = root->val + left[1] + right[1]; // 偷就不能偷左右节点
dp[1] = max(left[0], left[1]) + max(right[0], right[1]); // 不偷左右节点能偷，也能不偷
return dp;
}
};2. 股票系列
（1）买卖股票的最佳时机
给定一个数组
prices，它的第i个元素prices[i]表示一支给定股票第i天的价格。你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回
0。
示例 1：
输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
示例 2：
输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。思路：
① dp[i][0] 表示第i天持有股票所得最多现金。dp[i][1] 表示第 i 天不持有股票所得最多现金。
② 如果第 i 天持有股票即 dp[i][0]， 那么可以由两个状态推出来
- 第 i-1 天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
- 第 i 天买入股票，所得现金就是买入今天的股票后所得现金即：-prices[i]
那么 dp[i][0] 应该选所得现金最大的，所以 dp[i][0] = max(dp[i - 1][0], -prices[i]);
如果第 i 天不持有股票即 dp[i][1]， 也可以由两个状态推出来
- 第 i-1 天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
- 第 i 天卖出股票，所得现金就是按照今天股票价格卖出后所得现金即：prices[i] + dp[i - 1][0]
同样 dp[i][1] 取最大的，dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
③ dp[0][0] 表示第 0 天持有股票，此时的持有股票就一定是买入股票了，所以 dp[0][0] = -prices[0]；dp[0][1] 表示第 0 天不持有股票，不持有股票那么现金就是 0，所以 dp[0][1] = 0;
// 写法一：
class Solution {
public:
int maxProfit(vector<int>& prices) {
int len = prices.size();
// 0:持有股票的状态；1:卖出股票的状态
vector<vector<int>> dp(len, vector<int>(2, 0));
dp[0][0] = -prices[0];
for (int i = 1; i < len; i++) {
// 持续上一个状态，或者更新到新的状态
dp[i][0] = max(dp[i - 1][0], -prices[i]);
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
}
return dp[len - 1][1];
}
};
// 改进：
class Solution {
public:
int maxProfit(vector<int>& prices) {
int len = prices.size();
vector<vector<int>> dp(2, vector<int>(2)); // 只保存昨天的状态
dp[0][0] -= prices[0];
dp[0][1] = 0;
for (int i = 1; i < len; i++) {
dp[i % 2][0] = max(dp[(i - 1) % 2][0], -prices[i]);
dp[i % 2][1] = max(dp[(i - 1) % 2][1], prices[i] + dp[(i - 1) % 2][0]);
}
return dp[(len - 1) % 2][1];
}
};
（2）买卖股票的最佳时机II
给你一个整数数组
prices，其中prices[i]表示某支股票第i天的价格。在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。
返回 你能获得的 最大 利润 。
示例 1：
输入：prices = [7,1,5,3,6,4]
输出：7
解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。
最大总利润为 4 + 3 = 7 。
示例 2：
输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
最大总利润为 4 。
示例 3：
输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0。思路：
① dp[i][0] 表示第 i 天持有股票所得现金；dp[i][1] 表示第 i 天不持有股票所得最多现金。
② 如果第 i 天持有股票即 dp[i][0]， 那么可以由两个状态推出来：
- 第 i-1 天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
- 第 i 天买入股票，所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即：dp[i - 1][1] - prices[i]
如果第 i 天不持有股票即 dp[i][1] 的情况， 依然可以由两个状态推出来：
- 第 i-1 天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
- 第 i 天卖出股票，所得现金就是按照 今天股票价格卖出后 所得现金即：prices[i] + dp[i - 1][0]
class Solution {
public:
int maxProfit(vector<int>& prices) {
int len = prices.size();
vector<vector<int>> dp(len, vector<int>(2, 0));
dp[0][0] -= prices[0];
dp[0][1] = 0;
// cout << dp[0][0] << " " << dp[0][1] << endl;
for (int i = 1; i < len; i++) {
dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]); //
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
// cout << dp[i][0] << " " << dp[i][1] << endl;
}
return dp[len - 1][1];
}
};（3）买卖股票的最佳时机III
给定一个数组，它的第
i个元素是一支给定的股票在第i天的价格。设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入：prices = [3,3,5,0,0,3,1,4]
输出：6
解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。
示例 2：
输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
示例 3：
输入：prices = [7,6,4,3,1]
输出：0
解释：在这个情况下, 没有交易完成, 所以最大利润为 0。
示例 4：
输入：prices = [1]
输出：0思路：
① 一天一共就有五个状态：
1）没有操作 （其实我们也可以不设置这个状态）
2）第一次持有股票
3）第一次不持有股票
4）第二次持有股票
5）第二次不持有股票
dp[i][j] 中 i 表示第 i 天，j 为 [0 - 4] 五个状态，dp[i][j] 表示第 i 天状态 j 所剩最大现金。
② 达到dp[i][1]状态，有两个具体操作：
- 操作一：第 i 天买入股票了，那么 dp[i][1] = dp[i-1][0] - prices[i]
- 操作二：第 i 天没有操作，而是沿用前一天买入的状态，即：dp[i][1] = dp[i - 1][1]
所以 dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);
同理 dp[i][2] 也有两个操作：
- 操作一：第 i 天卖出股票了，那么 dp[i][2] = dp[i - 1][1] + prices[i]
- 操作二：第 i 天没有操作，沿用前一天卖出股票的状态，即：dp[i][2] = dp[i - 1][2]
所以 dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])
同理可推出剩下状态部分：
- dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
- dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
// 写法一：
class Solution {
public:
int maxProfit(vector<int>& prices) {
int len = prices.size();
// dp[i][j]表示第i天状态j所剩最大现金
// 0:第一次买入股票的状态；1:第一次卖出的最大金额
// 2:第二次买入股票的状态；3:第二次卖出的最大金额
vector<vector<int>> dp(len, vector<int>(4, 0));
dp[0][0] = -prices[0]; // 第一次买入
dp[0][2] = -prices[0]; // 第二次买入
for (int i = 1; i < len; i++) {
dp[i][0] = max(dp[i - 1][0], -prices[i]);
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]); // 判断买入状态比较好，还是卖出状态比较好
dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] - prices[i]);
dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] + prices[i]);
}
return dp[len - 1][3];
}
};
// 改进：
class Solution {
public:
int maxProfit(vector<int>& prices) {
if (prices.size() == 0) return 0;
vector<int> dp(4, 0);
dp[0] = -prices[0];
dp[2] = -prices[0];
// cout << dp[0] << " " << dp[1] << " " << dp[2] << " " << dp[3] << endl;
for (int i = 1; i < prices.size(); i++) {
dp[0] = max(dp[0], -prices[i]);
dp[1] = max(dp[1], dp[0] + prices[i]);
dp[2] = max(dp[2], dp[1] - prices[i]);
dp[3] = max(dp[3], dp[2] + prices[i]);
// cout << dp[0] << " " << dp[1] << " " << dp[2] << " " << dp[3] << endl;
}
return dp[3];
}
};
（4）买卖股票的最佳时机IV
给你一个整数数组
prices和一个整数k，其中prices[i]是某支给定的股票在第i天的价格。设计一个算法来计算你所能获取的最大利润。你最多可以完成
k笔交易。也就是说，你最多可以买k次，卖k次。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1：
输入：k = 2, prices = [2,4,1]
输出：2
解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。
示例 2：
输入：k = 2, prices = [3,2,6,5,0,3]
输出：7
解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。思路：
① 使用二维数组 dp[i][j] ：第 i 天的状态为 j，所剩下的最大现金是 dp[i][j]，j 的状态表示为：
- 0 表示不操作
- 1 第一次买入
- 2 第一次卖出
- 3 第二次买入
- 4 第二次卖出
- .....
除了 0 以外，偶数就是卖出，奇数就是买入。
② dp[i][1]，表示的是第 i 天，买入股票的状态，并不是说一定要第 i 天买入股票。
达到 dp[i][1]状态，有两个具体操作：
- 操作一：第 i 天买入股票了，那么dp[i][1] = dp[i - 1][0] - prices[i]
- 操作二：第 i 天没有操作，而是沿用前一天买入的状态，即：dp[i][1] = dp[i - 1][1]
选最大的，所以 dp[i][1] = max(dp[i - 1][0] - prices[i], dp[i - 1][1]);
同理 dp[i][2] 也有两个操作：
- 操作一：第 i 天卖出股票了，那么 dp[i][2] = dp[i - 1][1] + prices[i]
- 操作二：第 i 天没有操作，沿用前一天卖出股票的状态，即：dp[i][2] = dp[i - 1][2]
所以 dp[i][2] = max(dp[i - 1][1] + prices[i], dp[i - 1][2])
class Solution {
public:
int maxProfit(int k, vector<int>& prices) {
if (prices.size() == 0) return 0;
vector<vector<int>> dp(prices.size(), vector<int>(2 * k + 1, 0));
for (int j = 1; j < 2 * k; j += 2) {
dp[0][j] = -prices[0];
}
for (int i = 1; i < prices.size(); 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[prices.size() - 1][2 * k];
}
};
（5）最佳买卖股票时机含冷冻期
给定一个整数数组
prices，其中第prices[i]表示第i天的股票价格 。设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
- 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入: prices = [1,2,3,0,2]
输出: 3
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]
示例 2:
输入: prices = [1]
输出: 0s思路：
dp[i][j]，第 i 天状态为 j，所剩的最多现金为 dp[i][j]。具体可以区分出如下四个状态：
- 状态一：持有股票状态（今天买入股票，或者是之前就买入了股票然后没有操作，一直持有）
- 不持有股票状态，这里就有两种卖出股票状态
- 状态二：保持卖出股票的状态（两天前就卖出了股票，度过一天冷冻期。或者是前一天就是卖出股票状态，一直没操作）
- 状态三：今天卖出股票
- 状态四：今天为冷冻期状态，但冷冻期状态不可持续，只有一天！
j 的状态为：
- 0：状态一
- 1：状态二
- 2：状态三
- 3：状态四
达到买入股票状态（状态一）即：dp[i][0]，有两个具体操作：
- 操作一：前一天就是持有股票状态（状态一），dp[i][0] = dp[i - 1][0]
- 操作二：今天买入了，有两种情况
- 前一天是冷冻期（状态四），dp[i - 1][3] - prices[i]
- 前一天是保持卖出股票的状态（状态二），dp[i - 1][1] - prices[i]
那么 dp[i][0] = max(dp[i - 1][0], dp[i - 1][3] - prices[i], dp[i - 1][1] - prices[i]);
达到保持卖出股票状态（状态二）即：dp[i][1]，有两个具体操作：
- 操作一：前一天就是状态二
- 操作二：前一天是冷冻期（状态四）
dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
达到今天就卖出股票状态（状态三），即：dp[i][2] ，只有一个操作：
- 操作一：昨天一定是持有股票状态（状态一），今天卖出
dp[i][2] = dp[i - 1][0] + prices[i];
达到冷冻期状态（状态四），即：dp[i][3]，只有一个操作：
- 操作一：昨天卖出了股票（状态三）
dp[i][3] = dp[i - 1][2];
class Solution {
public:
int maxProfit(vector<int>& prices) {
int len = prices.size();
if (len == 0) return 0;
// 一共四种状态：
// 状态一：买入状态（前一天是买入状态;前一天是保持卖出状态;前一天是冷冻期）
// 状态二：保持卖出状态（前一天是保持卖出状态;前一天是冷冻期）
// 状态三：卖出状态（前一天是买入状态）
// 状态四：冷冻期（前一天是卖出状态）
vector<vector<int>> dp(len, vector<int>(4, 0));
dp[0][0] = -prices[0];
for (int i = 1; i < len; i++) {
dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][1], dp[i - 1][3]) - prices[i]);
dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);
dp[i][2] = dp[i - 1][0] + prices[i];
dp[i][3] = dp[i - 1][2];
}
return max(dp[len - 1][3], max(dp[len - 1][1], dp[len - 1][2]));
}
};
（6）买卖股票的最佳时机含手续费
给定一个整数数组
prices，其中prices[i]表示第i天的股票价格 ；整数fee代表了交易股票的手续费用。你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。
返回获得利润的最大值。
注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。
示例 1：
输入：prices = [1, 3, 2, 8, 4, 9], fee = 2
输出：8
解释：能够达到的最大利润:
在此处买入 prices[0] = 1
在此处卖出 prices[3] = 8
在此处买入 prices[4] = 4
在此处卖出 prices[5] = 9
总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8
示例 2：
输入：prices = [1,3,7,5,10,3], fee = 3
输出：6思路：
dp[i][0] 表示第 i 天持有股票所省最多现金。 dp[i][1] 表示第 i 天不持有股票所得最多现金
如果第 i 天持有股票即 dp[i][0]， 那么可以由两个状态推出来
- 第 i-1 天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
- 第 i 天买入股票，所得现金就是昨天不持有股票的所得现金减去 今天的股票价格 即：dp[i - 1][1] - prices[i]
所以：dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
如果第 i 天不持有股票即 dp[i][1] 的情况， 依然可以由两个状态推出来
- 第 i-1 天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
- 第 i 天卖出股票，所得现金就是按照今天股票价格卖出后所得现金，注意这里需要有手续费了即：dp[i - 1][0] + prices[i] - fee
所以：dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);
// 写法一：
class Solution {
public:
int maxProfit(vector<int>& prices, int fee) {
int len = prices.size();
if (len == 0) return 0;
// 二种状态
// 第一种：买入状态（前一天已买入；前一天是保持卖出状态）
// 第二种：卖出状态（前一天是保持卖出状态；是买入状态）
vector<vector<int>> dp(len, vector<int>(2, 0));
dp[0][0] = - prices[0] - fee;
for (int i = 1; i < len; i++) {
dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i] - fee);
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
}
return dp[len - 1][1];
}
};
// 写法二：（优化）
class Solution {
public:
int maxProfit(vector<int>& prices, int fee) {
int len = prices.size();
if (len == 0) return 0;
// 二种状态
// 第一种：买入状态（前一天已买入；前一天是保持卖出状态）
// 第二种：卖出状态（前一天是保持卖出状态；是买入状态）
vector<vector<int>> dp(2, vector<int>(2, 0));
dp[0][0] = - prices[0] - fee;
for (int i = 1; i < len; i++) {
dp[i % 2][0] = max(dp[(i - 1) % 2][0], dp[(i - 1) % 2][1] - prices[i] - fee);
dp[i % 2][1] = max(dp[(i - 1) % 2][1], dp[(i - 1) % 2][0] + prices[i]);
}
return dp[(len - 1) % 2][1];
}
};
扫一扫
660
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
