文章目录
- 198.打家劫舍
- 思路
- 代码实现
- 213.打家劫舍II
- 思路
- 代码实现
- 337.打家劫舍 III
- 思路
- 代码实现
- 记忆化递归法(其他解法)
198.打家劫舍
题目链接
思路
- 确定dp数组(dp table)以及下标的含义
dp[i]:考虑下标i以内的房屋,最多可以偷窃的金额为dp[i]。
注意:dp[i]不是一定要偷第i个房间,它代表的是从0-i的范围房间内能偷的最大值。 - 确定递推公式
决定dp[i]的条件有第i房间偷还是不偷。
如果偷第i房间,那么dp[i] = dp[i - 2] + nums[i]
如果不偷第i房间,那么dp[i] = dp[i - 1],即考虑 i-1房
然后dp[i]取最大值,即dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]); - dp数组如何初始化
从递推公式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]);
vector dp(nums.size());
dp[0] = nums[0];
dp[1] = max(nums[0], nums[1]); - 确定遍历顺序
dp[i] 是根据dp[i - 2] 和 dp[i - 1] 推导出来的,那么一定是从前到后遍历 - 举例推导dp数组
代码实现
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()+1,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];}
};
213.打家劫舍II
题目链接
思路
这道题和上一道题几乎是一模一样,只不过是围成一个圈,那么这道题最重要的点就是,怎么避免偷的房间首尾相连。
所以重点就是不让他们首尾相连,那么可以分情况讨论:
- 不考虑首尾
- 考虑首不考虑尾
- 不考虑首考虑尾
而第一种情况包含在2和3情况里,直接讨论2和3情况即可,这样一个环形数组又变成了线型数组,和打家劫舍一模一样。
代码实现
class Solution {
public:int dynamic(int left,int right,vector<int>& nums){if(left==right)return nums[left];vector<int> dp(nums.size(),0);dp[left]=nums[left];dp[left+1]=max(nums[left],nums[left+1]);for(int i=left+2;i<=right;i++){dp[i]=max(dp[i-1],dp[i-2]+nums[i]);}return dp[right];}int rob(vector<int>& nums) {if(nums.size()==0)return 0;if(nums.size()==1)return nums[0];return max(dynamic(0,nums.size()-2,nums),dynamic(1,nums.size()-1,nums));}
};
337.打家劫舍 III
题目链接
思路
这道题比上面那道题又加了一个档次,是二叉树和动态规划的结合运用,第一次见我也是一脸懵逼。这道题用递归结构分析:
- 确定递归函数的参数和返回值
这里我们要求一个节点偷与不偷的两个状态所得到的金钱,那么返回值就是一个长度为2的数组。dp数组以及下标的含义:下标为0记录不偷该节点所得到的的最大金钱,下标为1记录偷该节点所得到的的最大金钱。 - 确定终止条件
在遍历的过程中,如果遇到空节点的话,很明显,无论偷还是不偷都是0,所以就返回{0,0}。这也相当于dp数组的初始化 - 确定遍历顺序
首先明确的是使用后序遍历。 因为要通过递归函数的返回值来做下一步计算。 - 确定单层递归的逻辑
如果是偷当前节点,那么左右孩子就不能偷,val1 = cur->val + left[0] + right[0];
如果不偷当前节点,那么左右孩子就可以偷,至于到底偷不偷一定是选一个最大的,所以:val2 = max(left[0], left[1]) + max(right[0], right[1]);
最后当前节点的状态就是{val2, val1};
代码实现
class Solution {
public:vector<int> robTree(TreeNode* root){if(root==nullptr)return {0,0};//dp[0]为当前未偷,dp[1]为当前偷了vector<int> left=robTree(root->left);vector<int> right=robTree(root->right);int val1=max(left[1],left[0])+max(right[0],right[1]);int val2=root->val+left[0]+right[0];return {val1,val2};}int rob(TreeNode* root) {vector<int> result=robTree(root);return max(result[0],result[1]);}
};
记忆化递归法(其他解法)
可以使用一个map把计算过的结果保存一下,这样如果计算过孙子了,那么计算孩子的时候可以复用孙子节点的结果。
代码如下:
class Solution {
public:unordered_map<TreeNode* , int> umap; // 记录计算过的结果int rob(TreeNode* root) {if (root == NULL) return 0;if (root->left == NULL && root->right == NULL) return root->val;if (umap[root]) return umap[root]; // 如果umap里已经有记录则直接返回// 偷父节点int val1 = root->val;if (root->left) val1 += rob(root->left->left) + rob(root->left->right); // 跳过root->leftif (root->right) val1 += rob(root->right->left) + rob(root->right->right); // 跳过root->right// 不偷父节点int val2 = rob(root->left) + rob(root->right); // 考虑root的左右孩子umap[root] = max(val1, val2); // umap记录一下结果return max(val1, val2);}
};