算法总结归纳（第九天）（动态规划第二部分）
目录
一、01背包问题实际应用
1、分割等和子集
①、题目描述
②、解题思路
③、代码实现
2、最后一块石头重量Ⅱ
①、题目描述：
②、解题思路
③、代码实现
3、目标和
①、题目描述
②、解题思路
③、代码实现
二、完全背包问题实际应用
1、零钱兑换Ⅱ
①、题目描述
②、解题思路
③、代码实现
2、组合总和
①、题目描述
②、解题思路
③、代码实现
3、零钱兑换
①、题目描述
②、解题思路
③、代码实现
4、完全平方数
①、题目描述
②、解题思路
③、代码实现
三、打家劫舍问题
1、打家劫舍
①、题目描述
②、解题思路
③、代码实现
2、打家劫舍Ⅱ
①、题目描述
②、解题思路
③、代码实现
3、打家劫舍Ⅲ
①、题目描述
②、解题思路
③、代码实现
四、股票问题
1、买卖股票最佳时机Ⅰ
①、题目描述
②、解题思路
③、代码实现
2、买卖股票价格最佳时机Ⅱ
①、题目描述
②、解题思路
③、代码实现
3、买卖股票最佳时机Ⅲ
①、题目描述
②、解题思路
③、代码实现
4、买卖股票最佳时机Ⅳ
①、题目描述
②、解题思路
③、代码实现
5、买卖股票含冷冻期
①、题目描述
②、解题思路
③、代码实现
6、买卖股票最佳时机含手续费
①、题目描述
②、解题思路
③、代码实现
一、01背包问题实际应用
1、分割等和子集
题目链接：分割等和子集
①、题目描述
给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
②、解题思路
1、确定dp数组含义
dp表示当前大小的数的小标包含的数的大小。
2、递推公式
dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
3、初始化
全部初始化成0，如果nums中有负数，就初始化成负无穷。
4、遍历顺序
与01背包相同，先遍历物品，再遍历背包容量。
③、代码实现
bool canPartition(vector& nums) {
int sum = 0;
int dp[20010] = {0};
for(int i = 0; i= nums[i]; j--){
dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
}
}
if(dp[v] == v) return true;
return false;
} 2、最后一块石头重量Ⅱ
题目链接：最后一块石头重量
①、题目描述：
有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。
每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：
- 如果
x == y，那么两块石头都会被完全粉碎； - 如果
x != y，那么重量为x的石头将会完全粉碎，而重量为y的石头新重量为y-x。
最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。
②、解题思路
1、确定dp数组含义
dp[i]中的i表示i这么大容量的时候，能装的最多数字。
2、递推公式
dp[j] = max(dp[j], dp[j - stones[i]] + stones[i])。
sum 为stone总和。
本题推导，是因为，说白了，就是分成两个集合，进行相互抵消，如果两个集合总数不相等，那么
最后的dp[sum / 2] 一定存储的是较小的集合，用总数减去二倍的较小集合就行。
3、初始化
dp数组均初始化成0就行。
4、遍历顺序
先遍历背包，再遍历物品。
③、代码实现
int lastStoneWeightII(vector& stones) {
int sum = 0;
for(int i = 0; i= stones[i]; j--){
dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);
}
}
return sum - (dp[target] * 2);
} 3、目标和
题目链接：目标和
①、题目描述
给你一个非负整数数组 nums 和一个整数 target 。
向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：
- 例如，
nums = [2, 1]，可以在2之前添加'+'，在1之前添加'-'，然后串联起来得到表达式"+2-1"。
返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。
示例 1：
输入：nums = [1,1,1,1,1], target = 3 输出：5 解释：一共有 5 种方法让最终目标和为 3 。 -1 + 1 + 1 + 1 + 1 = 3 +1 - 1 + 1 + 1 + 1 = 3 +1 + 1 - 1 + 1 + 1 = 3 +1 + 1 + 1 - 1 + 1 = 3 +1 + 1 + 1 + 1 - 1 = 3
②、解题思路
sum为总和。
本题，既然要求，目标和，那就一定有uns(正数组) 和 sub(负数组) ，
sum = uns + sub。
uns + sub = sum。①
uns - sub = target ②
有①、②推出，uns = (sum + target) / 2。
sum 和target和为定值，因此相当于求和为uns的值。
问题就是装满容量的uns的背包有几种方法。
1、确定dp数组含义
dp[i]表示想达成i这么大的数，共有几种组合方式。
2、递推公式
dp[j] += dp[j - nums[i]];
因为我们数组下标表示的是能达到该类型的有几种方法，因此使用累加的方式计算。
3、初始化
dp[0] 需要初始化成零。
4、遍历顺序
先遍历物品，再遍历容量。
③、代码实现
int findTargetSumWays(vector& nums, int target) {
int dp[1010] = {1};
int sum = 0;
for(int i = 0; i=nums[i]; j--){
dp[j] += dp[j - nums[i]];
}
}
return dp[x];
} 二、完全背包问题实际应用
1、零钱兑换Ⅱ
题目链接：零钱兑换Ⅱ
①、题目描述
给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。
请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。
假设每一种面额的硬币有无限个。
题目数据保证结果符合 32 位带符号整数。
示例 1：
输入：amount = 5, coins = [1, 2, 5] 输出：4 解释：有四种方式可以凑成总金额： 5=5 5=2+2+1 5=2+1+1+1 5=1+1+1+1+1
②、解题思路
本题中物品可以重复使用，同时有目标值，很明显是完全背包问题。所以我们用完全背包解题。
1、确定dp数组含义
dp数组表示到达当前这么多的零钱有多少种方法。
2、递推公式
dp[j] += dp[j - coins[i]];
3、初始化
dp[0] = 1。别的为0就行。
4、遍历顺序
先遍历物品，再遍历容量，容量从小开始遍历。
③、代码实现
int change(int amount, vector& coins) {
int dp[5010] = {1};
for(int i = 0; i 2、组合总和
题目链接：组合总和Ⅳ
①、题目描述
给你一个由 不同 整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。
题目数据保证答案符合 32 位整数范围。
示例 1：
输入：nums = [1,2,3], target = 4 输出：7 解释： 所有可能的组合为： (1, 1, 1, 1) (1, 1, 2) (1, 2, 1) (1, 3) (2, 1, 1) (2, 2) (3, 1) 请注意，顺序不同的序列被视作不同的组合。
②、解题思路
1、确定dp数组含义
dp[i]表示组合成i这么大数有的排列方法数。
2、递推公式
dp[i] += dp[i - nums[j]];
3、初始化
dp[0] = 1。
4、遍历顺序
先遍历背包，再遍历物品。
这是因为，题目中说组合相同，排列不同也算一种。因此就要和01背包变换一下遍历顺序。
③、代码实现
int combinationSum4(vector& nums, int target) {
int dp[1010] = {1};
for(int i = 0; i<=target; i++){
for(int j = 0; j < nums.size(); j++){
if(i - nums[j] >= 0 && dp[i] < INT_MAX - dp[i - nums[j]])
dp[i] += dp[i - nums[j]];
}
}
return dp[target]; 3、零钱兑换
题目链接：零钱兑换
①、题目描述
②、解题思路
1、确定dp数组含义
dp数组表示组成该数字使用的最小硬币数，组不成的均为INT_MAX。
2、递推公式
dp[j] = min(dp[j], dp[j - coins[i]] + 1);
3、初始化
dp[0] = 0。其它均初始成INT_MAX。
4、遍历顺序
先遍历背包或者先遍历物品都可以。
③、代码实现
int coinChange(vector& coins, int amount) {
if(amount == 0) return 0;
vector dp(amount + 1, INT_MAX);
dp[0] = 0;
for(int i = 0; i 4、完全平方数
题目链接：完全平方数
①、题目描述
给你一个整数 n ，返回 和为 n 的完全平方数的最少数量 。
完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。
示例 1：
输入：n =12输出：3 解释：12 = 4 + 4 + 4
②、解题思路
1、确定dp数组含义
dp数组表示组成该数的完全平方数有几个。
2、递推公式
dp[i] = min(dp[i], dp[i - j * j] + 1);
j表示完全平方根
3、初始化
dp[0] = 0。
4、遍历顺序
先遍历1-n。然后再从完全平方数的平方根开始遍历。
③、代码实现
int numSquares(int n) {
vector dp(n + 1, INT_MAX);
dp[0] = 0;
for(int i = 1; i<=n; i++){
for(int j = 1; j<=i / j ; j++){
dp[i] = min(dp[i], dp[i - j * j] + 1);
}
}
return dp[n];
} 三、打家劫舍问题
1、打家劫舍
①、题目描述
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
示例 1：
输入：[1,2,3,1] 输出：4 解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。 偷窃到的最高金额 = 1 + 3 = 4 。
②、解题思路
题目链接：打家劫舍
1、确定dp数组含义
dp[i]表示i这个下标下，能偷到的的最大金额数的钱。
2、递推公式
dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
3、初始化
dp[0] = nums[0] dp[1] = max(nums[0], nums[1])。
4、遍历顺序
从2开始，从前往后遍历。
③、代码实现
int rob(vector& nums) {
if(nums.size() == 0) return 0;
if(nums.size() == 1) return nums[0];
int dp[1010];
dp[0] = nums[0];
dp[1] = max(nums[0], nums[1]);
for(int i = 2; i 2、打家劫舍Ⅱ
题目链接：打家劫舍Ⅱ
①、题目描述
你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。
示例 1：
输入：nums = [2,3,2] 输出：3 解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。
②、解题思路
本题与打家劫舍基本思路相同，就是在其基础上进行头尾分割成两部分，分别进行求解。
1、确定dp数组含义
dp[]数组依然表示当前下标的最大金额。
2、递推公式
dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
3、初始化
dp[0] = nums[0]， dp[1] = max(dp[0], dp[1])。
4、遍历顺序
从前往后遍历，与上道题一样。
③、代码实现
int rob(vector& nums) {
if(nums.size() == 0) return 0;
if(nums.size() == 1) return nums[0];
if(nums.size() == 2) return max(nums[0], nums[1]);
//本题进行分割，分为只包含首元素，只包含尾元素两种情况。
int res1 = dis(nums, 0, nums.size() - 2);
int res2 = dis(nums, 1, nums.size() - 1);
return max(res1, res2);
}
int dis(vector& nums, int l, int r)
{
int dp[1010];
dp[l] = nums[l];dp[l + 1] = max(nums[l], nums[l + 1]);
for(int i = l + 2; i <= r; i++){
dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
}
return dp[r];
} 3、打家劫舍Ⅲ
题目链接：打家劫舍Ⅲ
①、题目描述
小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。
除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。
给定二叉树的 root 。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额 。
②、解题思路
1、确定dp数组含义
dp[0] 表示不偷，dp[1]表示偷。
2、递推公式
如代码
3、初始化
无需初始化，树上dp直接返回初始值。
4、遍历顺序
二叉树的后序遍历。
③、代码实现
int rob(TreeNode* root) {
vector result = robTree(root);
return max(result[0], result[1]);
}
// 长度为2的数组，0：不偷，1：偷
vector robTree(TreeNode* cur) {
if (cur == NULL) return vector{0, 0};
vector left = robTree(cur->left);
vector right = robTree(cur->right);
// 偷cur，那么就不能偷左右节点。
int val1 = cur->val + left[0] + right[0];
// 不偷cur，那么可以偷也可以不偷左右节点，则取较大的情况
int val2 = max(left[0], left[1]) + max(right[0], right[1]);
return {val2, val1};
} 四、股票问题
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, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
②、解题思路
题目链接：买卖股票最佳时机
1、确定dp数组含义
我们dp[i][j]中的j只有0和1两种状态，i表示天数，0表示持有股票，1表示不持有股票。（持有不等于当天买入）。
dp[i][0]表示第i天持有股票，dp[i][1]表示第i天不持有股票。
2、递推公式
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][0]不依赖dp[i-1][1]，但是dp[i][1]依赖dp[i-1][0]。
3、初始化
dp[]0][0]表示第一天持有股票，肯定要初始化成 - price[0]。
4、遍历顺序
从前往后遍历天数。
③、代码实现
int dp[100010][2];
int maxProfit(vector& prices) {
//0表示持有股票， 1表示不持有股票
dp[0][0] = -prices[0];
for(int i = 1; i < prices.size(); 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[prices.size() - 1][1];
} 2、买卖股票价格最佳时机Ⅱ
①、题目描述
给你一个整数数组 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 。
②、解题思路
题目链接：买卖股票最佳时机Ⅱ
1、确定dp数组含义
dp[i][j]中的j只有0和1两种状态，i表示天数，0表示持有股票，1表示不持有股票。（持有不等于当天买入）。
dp[i][0]表示第i天持有股票，dp[i][1]表示第i天不持有股票。
与上道一摸一样。
2、递推公式
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]);
这是因为本题买卖多次，因此会带上之前的利润。
3、初始化
dp[]0][0]表示第一天持有股票，肯定要初始化成 - price[0]。
4、遍历顺序
从前往后遍历天数。
③、代码实现
int dp[100010][2];
int maxProfit(vector& prices) {
dp[0][0] = -prices[0];
for(int i = 1; i 3、买卖股票最佳时机Ⅲ
①、题目描述
给定一个数组，它的第 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 。
②、解题思路
题目链接：买卖股票最佳时机Ⅲ
1、确定dp数组含义
我们设定五种状态，
dp[i][0]表示当天没有操作， dp[i[[1] 表示第一次持有股票，dp[i][2]表示第一次不持有股票，dp[i][3]表示第二次持有股票，dp[i][4]表示第二次不持有股票。
2、递推公式
dp[i][1]从dp[i-1][0] - price[i] 和 dp[i -1][1]。
dp[i][2]从dp[i-1][2] 和 dp[i -1][1] + price[i]。
dp[i][3] 从dp[i -1][2] - price[i] 和 dp[i - 1][3]推出。
dp[i][4] 从dp[i -1][3] + price[i] 和 dp[i - 1][4]推出。
3、初始化
dp[0][0] = 0; dp[0][1] = -prices[0]; dp[0][2] = 0;
dp[0][3] = -prices[0]; dp[0][4] = 0;
dp[0][3]之所以初始化和dp[0][1]相同，是因为可以同一天买卖两次。
4、遍历顺序
从前往后遍历天数。
③、代码实现
int dp[100010][5];
int maxProfit(vector& prices) {
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 4、买卖股票最佳时机Ⅳ
①、题目描述
给你一个整数数组 prices 和一个整数 k ，其中 prices[i] 是某支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说，你最多可以买 k 次，卖 k 次。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1：
输入：k = 2, prices = [2,4,1] 输出：2 解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。
②、解题思路
题目链接：买卖股票最佳时机Ⅳ
1、确定dp数组含义
dp[i][0]表示当天没有操作， dp[i[[1] 表示第一次持有股票，dp[i][2]表示第一次不持有股票，dp[i][3]表示第二次持有股票，dp[i][4]表示第二次不持有股票。
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])
用于模拟三维数组的k次买卖。
3、初始化
for(int i = 1; i < k * 2; i+=2) dp[0][i] = -prices[0]
奇数均为买入的状态，因此均初始化成 -price[0]。
4、遍历顺序
从前往后遍历天数。
③、代码实现
int maxProfit(int k, vector& prices) {
int dp[100010][k * 2 + 1];
//初始化
for(int i = 1; i < k * 2; i+=2) dp[0][i] = -prices[0];
//递推公式
for(int i = 1; i 5、买卖股票含冷冻期
①、题目描述
给定一个整数数组prices，其中第 prices[i] 表示第 i 天的股票价格 。
设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
- 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入: prices = [1,2,3,0,2] 输出: 3 解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]
②、解题思路
题目链接：买卖股票含冷冻期
1、确定dp数组含义
dp[i][0]表示买入状态，
dp[i][1]表示卖出状态，
dp[i][2]表示当天卖出状态，
dp[i][3]表示冷冻期状态。
2、递推公式
dp[i][0] = max(max(dp[i - 1][0], dp[i - 1][1] - prices[i]), dp[i - 1][3] - prices[i]);
dp[i][1] = max(dp[i - 1][3], dp[i - 1][1]);
dp[i][2] = dp[i - 1][0] + prices[i];
dp[i][3] = dp[i - 1][2];
3、初始化
dp[0][0] = -price[0]。
4、遍历顺序
从前往后遍历天数。
③、代码实现
int maxProfit(vector& prices) {
//0表示买入状态，1表示卖出状态，2表示当天卖出状态，3 表示冷冻期状态。
int dp[10010][4];
dp[0][0] = -prices[0];
for(int i = 1; i 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
②、解题思路
题目链接：买卖股票含手续费
1、确定dp数组含义
dp[i][0]表示买入状态，dp[i][1]表示卖出状态。（在这基础上加了个手续费）。
2、递推公式
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])
3、初始化
dp[0][0]初始化成 -price[i] - fee。
4、遍历顺序
从前往后遍历天数。
③、代码实现
int maxProfit(vector& prices, int fee) {
int dp[100010][2];
dp[0][0] = -prices[0]- fee;
for(int i = 1; i