代码随想录算法训练营第四十八天|198. 打家劫舍、213. 打家劫舍 II、337. 打家劫舍 III

第九章 动态规划part09

198. 打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

没想出来递推公式

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(),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

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。

给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。

思路：分两种情况讨论：

①包含首元素，不包含尾元素

②包含尾元素，不包含首元素

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.size()==0)  return 0;
        if(nums.size()==1)  return nums[0];
        int num1=Rob(nums,0,nums.size()-2);
        int num2=Rob(nums,1,nums.size()-1);
        return max(num1,num2);
    }
    int Rob(vector<int>& nums,int begin,int end){
        if(begin==end)  return nums[begin];
        vector<int> dp(nums.size());
        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-1],dp[i-2]+nums[i]);
        }
        return dp[end];
    }
    
};

337. 打家劫舍 III

小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。

除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。

给定二叉树的 root 。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额 。

还是没能彻底理解前两道题的解法，所以没能想出来，这个问题的核心还是在于是取该节点值还是不取该节点值。

暴力法 （超时）

class Solution {
public:
    int rob(TreeNode* root) {
        if(root==nullptr)  return 0;
        if(root->left==nullptr&&root->right==nullptr)  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);
    }
};

• 时间复杂度：O(n^2)，这个时间复杂度不太标准，也不容易准确化，例如越往下的节点重复计算次数就越多
• 空间复杂度：O(log n)，算上递推系统栈的空间

①记忆化递推（减少节点重复计算）

class Solution {
public:
    unordered_map<TreeNode*,int> umap; 
    int rob(TreeNode* root) {
        if(root==nullptr)  return 0;
        if(root->left==nullptr&&root->right==nullptr)  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);
    }
};

②动态规划！！（看了题解）

使用后序遍历二叉树+动态规划（偷当前节点or不偷当前节点，使用数组记录）

dp[0],dp[1]记录偷或不偷，使用函数返回值记录。

class Solution {
public:
    unordered_map<TreeNode*,int> umap; 
    int rob(TreeNode* root) {
        vector<int> res=traversal(root);
        return max(res[0],res[1]);
    }
    vector<int> traversal(TreeNode* root){
        if(root==nullptr)  return vector<int>{0,0};
        vector<int> left=traversal(root->left);
        vector<int> right=traversal(root->right);
        //偷当前节点
        int val1=root->val+left[0]+right[0];
        //不偷当前节点
        int val2=max(left[0],left[1])+max(right[0],right[1]);
        return vector<int>{val2,val1};
    }
};

本题可以跟贪心法求二叉树安装监控那道题联系，本题是使用了数组记录偷或不偷当前节点情况，安装监控问题是使用了数值记录当前节点覆盖情况。总结是类似这种需要间隔点来求值的一般要对节点情况做记录，方便后面的继续执行。