LeetCode题目:https://leetcode.cn/problems/house-robber/
打家劫舍问题的初始问题,很明显,当存在i个房子的时候,打家劫舍的最大收益应该是多少?谈到最大收益,可以判断应该需要使用max来进行处理。同时,打家劫舍要求至少间隔一间房屋,所以递推公式需要考虑当前位置的临近位置,和间隔位置两种情况。因此可以看做是max(间隔房间 + 当前房间收益, 临近房间最大收益),共同来决定最大的收益。
因此,由以上推理,至少需要初始化两个值才能完成上述状态转移,其中最开始位置一定是当前房屋的收益。而存在两个房间的时候应该是收益最大值。
代码如下:
class Solution {
public:
int rob(vector<int>& nums) {
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 - 2] + nums[i], dp[i - 1]);
}
return dp[nums.size() - 1];
}
};
LeetCode题目:https://leetcode.cn/problems/house-robber-ii/
与问题1不同点在于,当存在环形的时候,开头的元素和末尾的元素是临近关系的。这就意味着会出现三种情况:(1)开头和末尾的元素都不需要。(2)需要开头的元素。(3)需要末尾的元素。其中(1)情况可以在2/3情况中包含计算。
因此,其实可以抽象看成,如果情况2,那就默认去掉末尾元素进行最大值计算。如果情况3,那就去掉开头元素进行最大值计算。最后再对两者进行比较,即可得到最后的结果。
最终代码如下:
class Solution {
public:
int rangeRob(vector<int>& nums, int begin, int end) {
vector<int> dp(nums.size(), 0);
dp[begin] = nums[begin];
dp[begin + 1] = max(nums[begin], nums[begin + 1]);
for (int i = begin + 2; i < end; i++) {
dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
}
return dp[end-1];
}
int rob(vector<int>& nums) {
if(nums.size() == 1) return nums[0];
if(nums.size() == 2) return max(nums[0], nums[1]);
int robFront = rangeRob(nums, 1, nums.size());
int robBack = rangeRob(nums, 0, nums.size() - 1);
return max(robFront, robBack);
}
};
LeetCode题目:https://leetcode.cn/problems/house-robber-iii/
该问题主要注重于对树形DP的理解,所谓树形DP,需要在二叉树上进行遍历并同时用返回值来保存状态的转移过程。因此核心在于对返回值的处理上,如何使返回值即表示当前节点的状态,又可以保存节点的值。可以参考DAY37 968.监控二叉树。
同时,要求得最大收益,因此每次遍历后要对遍历结果对比再进行返回,因此递归要采用后序遍历的方法,来进行递归以收集信息。此外,对于每个返回的值,因为打家劫舍要存在间隔,所以应该分为没有取当前节点的值,和取了当前节点的值两个情况来进行处理。因此,每次递归需要返回两个状态值,使用当前和没有使用当前,即val1 = root->val + leftDp[0] + rightDp[0],val2 = max(leftDp[0],leftDp[1]) + max(rightDp[0],rightDp[1]),最后返回(val1,val2)
如此,每次递归的流程便确定下来。最终代码如下:
class Solution {
public:
vector<int> robTree (TreeNode* root) {
if (root == NULL) return {0, 0};
vector<int> leftDp = robTree(root->left);
vector<int> rightDp = robTree(root->right);
int val1 = root->val + leftDp[0] + rightDp[0];
int val2 = max(leftDp[0], leftDp[1]) + max(rightDp[0], rightDp[1]);
return {val2, val1};
}
int rob(TreeNode* root) {
vector<int> result = robTree(root);
return max(result[0], result[1]);
}
};
除了dp思路以外,也可以使用常规的递归模式进行处理,同时为了优化一些已知点的最大收益不被反复计算,应该设定map进行映射,以便于对节点是否被计算进行查询,如果已经被计算则直接返回值(理解上其实和状态转移差不多)
class Solution {
public:
unordered_map<TreeNode*, int> robMap;
int rob(TreeNode* root) {
if(root == NULL) return 0;
if(root->left == NULL && root->right == NULL) return root->val;
if(robMap.find(root) != robMap.end()) return robMap[root];
/* 计算当前节点 */
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);
robMap[root] = max(val1, val2);
return robMap[root];
}
};