打家劫舍系列

最新推荐文章于 2024-09-03 16:44:30 发布

Jelly_Believer

最新推荐文章于 2024-09-03 16:44:30 发布

阅读量103

点赞数

分类专栏：动态规划 LeetCode 文章标签： css css3 html

本文链接：https://blog.csdn.net/weixin_42438346/article/details/121485019

版权

LeetCode 同时被 2 个专栏收录

67 篇文章 0 订阅

订阅专栏

动态规划

11 篇文章 0 订阅

订阅专栏

这篇博客介绍了如何使用动态规划和递归策略解决一系列计算机科学问题，包括数组中的打家劫舍问题和树形结构的节点盗窃问题。作者详细解释了动态规划的状态转移方程和递归函数的实现，并提供了两种不同情况下的解决方案，分别是考虑成环和树形结构的数组。此外，还讨论了如何避免暴力递归中的重复计算，引入了记忆化搜索的概念以提高效率。

摘要由CSDN通过智能技术生成

在这里插入图片描述

dp[i]数组含义：考虑下标i（包括i）以内的房间，最多可以偷窃的金额为dp[i]
注意！：dp[1] = max(nums[0], nums[1])而不是dp[1] = nums[1]，因为dp[i]数组的定义是第i个房间能够偷窃到的最大金额

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.size() == 1) return nums[0];
        if(nums.size() == 2) return max(nums[0], nums[1]);

        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]);
            //cout<<"dp"<<i<<": "<<dp[i]<<endl;
        }

        return dp[nums.size() - 1];
    }
};

在这里插入图片描述

与I的区别就是房间是一个圈，则首尾是否相邻也得考虑

对于一个数组，成环的话主要有以下三种情况

考虑不包含首尾元素
考虑不包含尾元素
考虑不包含首元素

而情况二和三都包括一了，故只需考虑二和三，其余的就和打家劫舍I一样了。

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.size() == 1) return nums[0];
        if(nums.size() == 2) return max(nums[0], nums[1]);

        int rob1 = robRang(nums, 0, nums.size() - 2);
        int rob2 = robRang(nums, 1, nums.size()-1); //前闭后闭

        return max(rob1, rob2);
    }

    int robRang(vector<int>& nums, int start, int end){
        if(start == end) 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-1], dp[i-2] + nums[i]);
        }

        return dp[end];

    }
};

在这里插入图片描述

和上面两题的区别就是，房屋之间以树形结构相连。
对树遍历的话就是前中后序（深度优先搜索）还是层序遍历（广度优先搜索）了。
而本题需要通过递归函数返回值来做下一步计算，故得用后序遍历。

法一：（暴力递归）

int rob(TreeNode* root){
	if(!root) return 0;
	if(!root->left && !root->right) return root->val;
	//偷父节点
	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);

	//返回二者最大值
	return max(val1, val2);
}

以上有重复计算，故可以用记忆话搜索，如果已经计算过了就不要再计算了。

unordered_map<TreeNode*, int> umap;
int rob(TreeNode* root){
	if(!root) return 0;
	if(!root->left && !root->right) return root->val;
	
	if(umap[root]) return umap[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);
	
	umap[root] = max(val1, val2);

	//返回二者最大值
	return max(val1, val2);
}

法二：动态规划

上面的暴力方法，对一个节点的偷与不偷并没有做记录，而是需要实时计算。
而动态规划是采用状态转移容器来记录结果，这里用一个长度为2的数组，来记录当前节点偷与不偷所得的最大金额。

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) return vector<int>{0, 0};

        vector<int> left = robTree(cur->left);
        vector<int> 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};
    } 
};