day 48 打家劫舍-CSDN博客

本文链接：https://blog.csdn.net/weixin_42410511/article/details/131613240

dp[ i ] : 考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]。
递推公式： dp[i] = max(dp[i-2]+nums[i-1], dp[i-1]);
初始化： dp[0] = 0 dp[1] = num[0]

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        vector<int>dp(n+1,0);
        dp[0] = 0;
        dp[1] = nums[0];

        for(int i=2; i<=n; i++){
            dp[i] = max(dp[i-2]+nums[i-1], dp[i-1]);
         
        }
        return dp[n];
    }
};

打家劫舍 II
题目这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统
第一种情况：第一家偷那么就是范围[1, n-1]
第二种情况：第一家不偷，范围[2, n]
以上这里确定的是范围，而不是一定偷不偷。第一种具体偷不偷第一家递推公式决定，同样第二种具体偷不偷最后一家也是递推公式决定

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

    int robb(vector<int>& nums, int start, int end){
          vector<int>dp(nums.size()+1,0);
          dp[start-1] = 0;
          dp[start] = nums[start-1];
          for(int i=start+1; i<=end; i++){
              dp[i] = max(dp[i-1], dp[i-2] + nums[i-1]);
          }

          return dp[end];

    }
};

337. 打家劫舍 III

记忆化搜索
情况1 ：偷该结点，不偷他的子节点
情况2：不偷该结点，偷子节点

class Solution {
public:
    unordered_map<TreeNode*, int>mp;
    int rob(TreeNode* root) {
        if(!root) return 0;
        if(!root->left && !root->right) return root->val;
        if(mp.find(root)!=mp.end()) return mp[root];
        mp[root] = max(root->val + unrob(root->left) + unrob(root->right), rob(root->left)+rob(root->right));
        return mp[root];
    }
    int unrob(TreeNode* root){
        if(!root) return 0;
        return rob(root->left) + rob(root->right);
    }
};

动态规划

每一个结点记录两个值{use, unuse}分别表示使用这个结点得到的最大利益和不使用结点结点所得到的最大利益
当前结点 use = root->val + left[1] + right[1]; 不使用左孩子和右孩子的值
unuse = max(left[0], left[1]) + max(right[0], right[1]);
不使用当前结点表示可以使用左右孩子，不代表一定会使用他的左右孩子，
所以对左右孩子是否使用获得最大值进行比较取最大值
左右根–>后序遍历

class Solution {
public:
    unordered_map<TreeNode*, vector<int>>mp;
    int rob(TreeNode* root) {
        mp[nullptr] = {0,0};
        dfs(root);
        return max(mp[root][0], mp[root][1]);
       
    }
    void dfs(TreeNode* root){
         if(!root) return;
         dfs(root->left);
         dfs(root->right);
         int use = root->val + mp[root->left][1] + mp[root->right][1];
         int unuse =  max(mp[root->left][0], mp[root->left][1]) +  max(mp[root->right][0], mp[root->right][1]);
         mp[root] = {use, unuse};
    }

};

将map 优化成每一步的二维数组

class Solution {
public:
  
    int rob(TreeNode* root) {
        vector<int>result = dfs(root);
        return max(result[0], result[1]);
       
    }
    vector<int> dfs(TreeNode* root){
         if(!root) return {0, 0};
         vector<int> left = dfs(root->left);
         vector<int> right = dfs(root->right);
         int use = root->val + left[1] + right[1];
         int unuse =  max(left[0], left[1]) +  max(right[0], right[1]);
         return {use, unuse};
    }

};