动态规划：打家劫舍买卖股票
2024-05-13 23:08:28
一、打家劫舍
1、基础
- 打家劫舍
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组nums，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
1）dp数组含义
dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]
2）递推公式
对于第i间房屋，可以分为两种情况：
- 不偷第i间房屋：dp[i] = dp[i - 1]
- 偷第i间房屋：dp[i] = dp[i - 2] + nums[i]
3）dp数组初始化
dp[0] = nums[0];
dp[1] = max(nums[0], nums[1]);
4）遍历方式
从头遍历到结尾：for (int i = 2; i < nums.size(); i++)
2、进阶
- 打家劫舍 II
你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。
该题目只是多了一个环形结构，根据题目中给定的条件，我们可以将环形结构分为两个直线结构，转变为基础题：
注意：这里的取是考虑的意思，取头不取尾是肯定不偷尾房间，但也不一定偷头房间，只是将头房间纳入要不要偷的考虑范围内
- 取头不取尾
- 取尾不取头
最后再取两者最大值即可。动态规划过程中的dp数组含义，递推公式，初始化方法，遍历顺序和基础题相同。
class Solution {private:/-----基础题：打家劫舍动态规划模块-----/int robByIndex(vector<int>& nums, int begIndex, int endIndex){if(begIndex == endIndex) return nums[begIndex];vector<int> dp(endIndex - begIndex + 1, 0);dp[0] = nums[begIndex];dp[1] = max(nums[begIndex], nums[begIndex + 1]);for(int i = 2; i < endIndex - begIndex + 1; i++){dp[i] = max(dp[i - 1], dp[i - 2] + nums[begIndex + i]);}return dp[endIndex - begIndex];}
public:/-----分两种情况讨论-----/int rob(vector<int>& nums) {if(nums.size() == 1) return nums[0];int res1 = robByIndex(nums, 0, nums.size() - 2);int res2 = robByIndex(nums, 1, nums.size() - 1);return max(res1, res2);}
};
3、打家劫舍的树形动态规划
337. 打家劫舍 III
在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。
这道题是一个典型的树形dp，需要融合dp和递归来进行解题
1）dp数组含义
这里使用二维的dp数组记录一个节点的两个状态：偷该节点，不偷该节点
2）递归参数与返回值
递归参数为当前节点，返回值为当前节点的dp数组
3）递归终止条件（终止条件即为dp数组初始化）
当前节点为空，偷不偷都是0： if (cur == NULL) return vector{0, 0};
4）遍历顺序（递归顺序）
由于根节点依赖于叶子节点，因此为后序遍历
5）单层递归逻辑（dp数组推导公式）
cur为当前节点
// 偷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};
6）解题代码
class Solution {public:int rob(TreeNode* root) {vector<int> result = robTree(root);return max(result[0], result[1]);}// 长度为2的数组，0：不偷，1：偷vector<int> robTree(TreeNode* cur) {if (cur == NULL) return vector<int>{0, 0};vector<int> left = robTree(cur->left);vector<int> right = robTree(cur->right);// 偷curint val1 = cur->val + left[0] + right[0];// 不偷cur/---这里注意仍然要比较一下，不一定要偷左孩子或右孩子---/int val2 = max(left[0], left[1]) + max(right[0], right[1]); return {val2, val1};}
};
由于dp数组只有只有两维，因此可以使用pair进行优化。相较于vector，pair占用内存更小，运行更快。
class Solution {private:pair<int, int> robTree(TreeNode* root){if(root == nullptr) return{0, 0};pair<int, int> left = robTree(root->left);pair<int, int> right = robTree(root->right);int getRoot = root->val + left.first + right.first;int noGetRoot = max(left.first, left.second) + max(right.first, right.second);return{noGetRoot, getRoot};}
public:int rob(TreeNode* root) {pair<int, int> res = robTree(root);return max(res.first, res.second);}
};
二、买卖股票
1、单次买卖，持有一支
121. 买卖股票的最佳时机
给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
1）dp数组含义
我们使用二维数组记录第i天的两种状态
dp[i][0]:第i天不持有股票手中的现金
dp[i][1]:第i天持有股票手中的现金
2）递推公式
如果第i天持有股票即dp[i][0]， 那么可以由两个状态推出来
- 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1][0]
- 第i天买入股票，所得现金就是买入今天的股票后所得现金即：
-prices[i](注意：这里是因为只限制了买一次股票，因此如果第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]);
3）初始化
dp[0][0] = 0; dp[0][1] = -prices[0]
4）遍历顺序
从前往后遍历
5）最后返回值
最后返回一定是dp[prices.size() - 1][1]，因为最后一天的时候肯定是不持有股票才能赚钱
6）解题代码
// 版本一
class Solution {public:int maxProfit(vector<int>& prices) {int len = prices.size();if (len == 0) return 0;vector<vector<int>> dp(len, vector<int>(2));dp[0][0] -= prices[0];dp[0][1] = 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], prices[i] + dp[i - 1][0]);}return dp[len - 1][1];}
};
7）pair优化
由于dp数组第二个维度只有两维，因此可以使用pair进行优化
class Solution {public:int maxProfit(vector<int>& prices) {vector<pair<int, int>> dp(prices.size());dp[0].first = -prices[0];dp[0].second = 0;for(int i = 1; i < prices.size(); i++){dp[i].first = max(dp[i - 1].first, -prices[i]);dp[i].second = max(dp[i - 1].second, dp[i - 1].first + prices[i]);}if(dp[prices.size() - 1].second < 0) return 0;return dp[prices.size() - 1].second;}
};
8）滚动数组
由于dp数组只有两个维度，因此可以使用滚动数组优化为一维dp数组
// 版本二
class Solution {public:int maxProfit(vector<int>& prices) {int len = prices.size();vector<vector<int>> dp(2, vector<int>(2)); // 注意这里只开辟了一个2 * 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、多次买卖，持有一支
122.给定一个数组 prices ，其中 prices[i] 是一支给定股票第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
和单次买卖相比，只有递推公式发生了变化：
如果第i天持有股票即dp[i].first， 那么可以由两个状态推出来
- 第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金 即：dp[i - 1].first
- 第i天买入股票，所得现金就是买入今天的股票后所得现金即：
dp[i - 1].second - prices[i](注意：这里是因为只限制了买一次股票，因此如果第i天买入，手中现金就是-prices[i]，和前一天没有关系)
那么dp[i][0]应该选所得现金最大的，所以dp[i].first = max(dp[i - 1].first, dp[i - 1].second - prices[i]);
1）动态规划解法
class Solution {public:int maxProfit(vector<int>& prices) {if(prices.size() == 0) return 0;vector<pair<int, int>> dp(prices.size());dp[0].first = - prices[0];dp[0].second = 0;for(int i = 1; i < prices.size(); i++){dp[i].first = max(dp[i-1].first, dp[i - 1].second - prices[i]);dp[i].second = max(dp[i - 1].second, dp[i - 1].first + prices[i]);}if(dp[prices.size() - 1].second < 0) return 0;return dp[prices.size() - 1].second; }
};
2）贪心算法
本题还可以使用贪心算法解决，收集每天的正收益即可
class Solution {public:int maxProfit(vector<int>& prices) {int res = 0;for(int i = 1; i < prices.size(); i++){if(prices[i] > prices[i - 1])res += prices[i] - prices[i - 1];}return res;}
};
3）滚动数组
// 版本二
class Solution {public:int maxProfit(vector<int>& prices) {int len = prices.size();vector<vector<int>> dp(2, vector<int>(2)); // 注意这里只开辟了一个2 * 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], dp[(i - 1) % 2][1] - 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];}
};
3、2次买卖，持有一支
123. 买卖股票的最佳时机 III
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
1）dp数组
当最多买卖两次的时候，一天的状态可以有四个：
dp[i][0]：第一次买入状态dp[i][1]：第一次卖出状态dp[i][2]：第二次买入状态dp[i][3]：第二次卖出状态
注意：这个状态是一个持续的过程，如第一次买入后，第二次买入前，均处于第一次买入状态
2）递推公式
每个状态都分为当天发生该状态和该状态在之前发生过两种，取两者最大值即可。注意第一次买入如果是当前买入，dp[i][0] = -prices[i]，因为第一次买入前手中现金就是0
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]);
3）初始化
dp[0][0] = -prices[0];
dp[0][0] = 0;
dp[0][2] = -prices[0];
dp[0][3] = 0;
注意：在初始化过程中dp[0][2]也要初始化为-prices[0]，虽然第一天不可能买第二次。题目要求最多买卖两次，但我们根据实际情况可能只买卖了一次，或者不买卖，这样初始化：
- 在我们只买卖一次的时候将
dp[i][0]和dp[i][1]的状态同步到了dp[i][2]和dp[i][3]； - 当我们买卖多次的时候，
dp[i][0]和dp[i][1]在买卖一次后保持不变，dp[i][2]和dp[i][3]仅需在买卖第一次赚的钱基础上进行变化
这样，不管我们买卖了几次，dp[i][3]均是在要求内赚的最多的钱
4）遍历顺序
从前到后
5）代码实现
class Solution {public:int maxProfit(vector<int>& prices) {if(prices.size() == 0) return 0;vector<vector<int>> dp(prices.size(), vector<int>(4, 0));dp[0][0] = -prices[0];dp[0][2] = -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]);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[prices.size() - 1][3];}
};
4、k次买卖，持有一支
188. 买卖股票的最佳时机 IV
给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
这个就是把2次买卖拓展为k次买卖，在dp数组推导的时候写成循环即可
class Solution {public:int maxProfit(int k, vector<int>& prices) {/---特殊情况处理---/if(k == 0 || prices.size() == 0) return 0;/---dp数组定义，第一维度为天数，第二维度为每天的状态数-----/vector<vector<int>> dp(prices.size(), vector<int>(2 * k, 0));/---初始化dp数组，每个交易状态均初始化为-prices[0]-----/for(int i = 0; i <= 2 * k - 1; i = i + 2){dp[0][i] = -prices[0];}/---递推公式，第一次买入特殊处理，其余买入卖出使用循环处理----/for(int i = 1; i < prices.size(); i++){dp[i][0] = max(dp[i - 1][0], -prices[i]);for(int j = 1; j <= 2 * k - 1; j++){if(j % 2 == 1) dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - 1] + prices[i]); //卖出if(j % 2 == 0) dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - 1] - prices[i]); //买入}}/---不管买卖了多少次，最后一天最后一个状态就是赚的钱---/return dp[prices.size() - 1][2 * k - 1];}
};
5、多次买卖，持有一支，有冷却期
1）dp数组
由于包含了冷却期，将卖出状态分割成为了卖出当天，冷却期，卖出了且过了冷却期三个状态，因此一天有四种状态，因此：
- dp[i][0]:买入股票状态（今天买入股票，或者是之前就买入了股票然后没有操作）
- dp[i][1]:两天前就卖出了股票，度过了冷冻期，一直没操作，今天保持卖出股票状态
- dp[i][2]:今天卖出了股票
- dp[i][3]:今天为冷冻期状态，但冷冻期状态不可持续，只有一天
2）递推公式
/---如果是之前买了，今天保持;如果今天买了，则昨天可能是状态1或3---/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]); //状态1的昨天可能是状态1或3dp[i][2] = dp[i - 1][0] + prices[i]; //状态2的昨天只能为状态0dp[i][3] = dp[i - 1][2]; //状态3的昨天只能为状态1
3）初始化
第一天买入状态初始化为-prices[0]
dp[0][0] = -prices[0];
4）遍历顺序
从前到后
5）返回值
由于卖出状态分割成为了卖出当天，冷却期，卖出了且过了冷却期三个状态，因此最后赚的最多的钱为最后一天三个状态的最大值
6）解题代码
class Solution {public:int maxProfit(vector<int>& prices) {if(prices.size() == 0) return 0;vector<vector<int>> dp(prices.size(), vector<int>(4, 0));dp[0][0] = -prices[0];for(int i = 1; i < prices.size(); 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[prices.size() - 1][1], max(dp[prices.size() - 1][2], dp[prices.size() - 1][3]));}
};
6、多次买卖，持有一支，有手续费
- 买卖股票的最佳时机含手续费
给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；非负整数 fee 代表了交易股票的手续费用。
你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。返回获得利润的最大值。
注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。
这个类型只是在买卖股票（多次买卖，持有一支）的基础上在当天卖出的时候多减去手续费。如果题目修改成买入也需要手续费的话，同理。
class Solution {public:int maxProfit(vector<int>& prices, int fee) {if(prices.size() == 0) return 0;vector<vector<int>> dp(prices.size(), vector<int>(2, 0));dp[0][0] = -prices[0];for(int i = 1; i < prices.size(); 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] - fee);}return dp[prices.size() - 1][1];}
};
动态规划：打家劫舍买卖股票相关推荐
- _42LeetCode代码随想录算法训练营第四十二天-动态规划 | 121.买卖股票的最佳时机、122.买卖股票的最佳时机II
_42LeetCode代码随想录算法训练营第四十二天-动态规划 | 121.买卖股票的最佳时机.122.买卖股票的最佳时机II 题目列表 121.买卖股票的最佳时机 122.买卖股票的最佳时机II 1 ...
- 【动态规划】买卖股票
买卖股票系列 121.买卖股票的最佳时机 122. 买卖股票的最佳时机 II 123. 买卖股票的最佳时机 III 188. 买卖股票的最佳时机 IV 309. 最佳买卖股票时机含冷冻期 121.买卖 ...
- 买卖股票动态规划python_leetcode 买卖股票的最佳时机（一，二简单，动态规划）...
买卖股票的最佳时机(一): 本题是获取最大利润:利用动态规划求解,自底向上,找出从以前到今天可以获取的最大利润:因此最后一天的就是最大利润: 状态 每天有三种选择,买入,卖出,什么也不做: 每天的状态 ...
- 代码随想录算法训练营第五十二天_第九章_动态规划 | 121. 买卖股票的最佳时机、122.买卖股票的最佳时机II
LeetCdoe 121. 买卖股票的最佳时机 给定一个数组 prices ,它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格. 你只能选择 某一天 买入这只股票,并选择在 未 ...
- 动态规划--Leetcode121.买卖股票的最佳时机
给定一个数组,它的第 i 个元素是一支给定股票第 i 天的价格. 如果你最多只允许完成一笔交易(即买入和卖出一支股票),设计一个算法来计算你所能获取的最大利润. 注意你不能在买入股票前卖出股票. 示例 ...
- 买卖股票的最好时机(一、二)
目录 买卖股票的最好时机(一) 动态规划解决 贪心思想解决 买卖股票的最好时机(二) 贪心思想解决 动态规划解决 买卖股票是经典的动态规划问题,在动态规划的学习与练习中,最令我煎熬的就是状态方程递推, ...
- leetcode 309. Best Time to Buy and Sell Stock with Cooldown | 309. 最佳买卖股票时机含冷冻期（动态规划）
题目 https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/ 题解 我知道要dp,但是不知道要怎么dp ...
- 买卖股票类问题动态规划解法（Leetcode题解-Python语言）
在 Leetcode 中,关于买卖股票的问题共有6道,而这些题目是可以用相同的思维进行求解的,强烈推荐这篇总结,写得非常到位. 股票类问题的动态规划分三步走,1.首先明确方程的含义, T[i][k][ ...
- LeetCode 309. 最佳买卖股票时机含冷冻期（动态规划）
1. 题目 给定一个整数数组,其中第 i 个元素代表了第 i 天的股票价格 . 设计一个算法计算出最大利润.在满足以下约束条件下,你可以尽可能地完成更多的交易(多次买卖一支股票): 你不能同时参与多 ...
最新文章
- python list 的乘法
- java设计模式---构建者模式
- arm编译安装openCV整理
- 查看显卡利用率 python_既然大家都说装了win10，就不用鲁大师监测显卡温度，为什么呢？...
- 为什么nodejs是单进程的_Nodejs·进程
- 8年javascript总结
- bufferedreader接收不到数据_FreeRTOS例程3-串口中断接收不定长的数据与二值信号量的使用
- 关于数据仓库 — 总体工具介绍
- 面试官对我说：虽然你技术能力强，但是依然做不了架构师
- hashtable遍历
- [卷积核]空洞卷积（转）
- 改caffe 里面的contrsitve_loss
- c语言cin cou头文件,c+第五次实验
- selenium之 chromedriver与chrome版本映射表（更新至v2.43）
- 用php做居中金字塔,[菜鸟学php] php版自定义函数实现金字塔
- 博文翻译系列——如何入门数据科学 without spending a penny
- Mybatis异常There is no getter for property named ‘XXX‘ in ‘class java.lang.String‘
- Farseer.net轻量级开源框架 中级篇：事务的使用
- 安卓pdf阅读器_想找可以安装APP的电子书阅读器？BOOX这几个型号可以选！
- 峰度的意义_李德荃关于偏度与峰度的讲解