代码随想录算法训练营Day47 | LeetCode198.打家劫舍、LeetCode213.打家劫舍II、LeetCode337.打家劫舍III

LeetCode198.打家劫舍

本题较为简单，考虑一个节点时，只需要考虑偷和不偷两种情况，当不偷的情况时，取dp[n-1],这里的意思并不是决定偷n-1的节点，而是考虑n-1节点时的最大价值。

代码如下：

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

LeetCode213.打家劫舍II

相比于上一题需要考虑环形，那么就只会分为三种情况：1、首尾都不考虑；2、考虑首不考虑尾；3、考虑尾不考虑首。那么在这三种情形中，第23种情形只是考虑首和尾，并没有说偷不偷，因为情形2和3里面包含了1.

如果只考虑一种情形，那么和上题就是一样的，我们只需要对两种情形分别做一次打家劫舍I，然后取最大值就是我们的结果。

代码如下：

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

LeetCode337.打家劫舍III

本题有一定难度，将二叉树与动态规划相结合，基础的树形dp。
思路：每个节点均有一个dp数组，只有两个值，dp[0]表示不偷当前节点时的所得到的最大价值，dp[1]表示偷当前节点是所得到的最大价值，那么分别考虑两种情况，当不偷当前节点时，就可以考虑左右两个子孩子，将他们的最大价值相加。当偷当前节点时，就只能考虑左右两个子孩子不偷的情形所能获得的最大价值。思路还是很巧妙的，但第一次接触真的难想。

代码如下：

class Solution {
public:
    vector<int> robTree(TreeNode* root){
        if(root==nullptr) return vector<int>{0,0};
        vector<int> robLeft = robTree(root->left);
        vector<int> robRight = robTree(root->right);
        int val1 = max(robLeft[0],robLeft[1])+max(robRight[0],robRight[1]);
        int val2 = robLeft[0]+robRight[0]+root->val;
        return vector<int>{val1,val2};
    }
    int rob(TreeNode* root) {
        vector<int> dp = robTree(root);
        return  max(dp[0],dp[1]);
    }
};