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

?较为简单，关键是递推公式：dp[i] = max((dp[i-2]+nums[i]), dp[i-1]);只需考虑第i个需不需要偷，如果第i-1个没有偷dp[i-2]和dp[i-1]就应该是相同的，dp[i-2]+nums[i]一定大于dp[i-1]。

int rob(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        if (nums.size() == 1) return nums[0];
        vector<int> dp(nums.size());
        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];
    }

?这道题是循环房间，需要考虑三种情况，第一个和最后一个房间都不偷，第一个房间不偷，最后一个房间不偷。因此要根据范围来进行选取：分别舍去第一个和最后一个房间进行选取即可包含这三种情况。

class Solution {
public:
    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);
    }
    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];
    }
};

?这道题是树形dp，采用后序遍历，从底部向根部进行遍历。首先进行左右遍历得到左右子节点的遍历结果，根据左右子节点遍历结果来选取当前节点的偷或不偷。vector[0]的值代表不偷，vector[1]的值代表偷。不偷时选取左右节点偷或不偷最大值之和，偷时，将当前节点的值加上左右节点不偷的值，返回一对偷或不偷的vector。最终结果选取根节点两种情况中的最大值。

class Solution {
public:
    vector<int> robTree(TreeNode* cur) {
        if (cur == NULL) return vector<int>{0, 0};
        vector<int> left = robTree(cur->left);
        vector<int> right = robTree(cur->right);
        //不偷时
        int val0 = max(left[1], left[0]) + max(right[1], right[0]);
        //偷时
        int val1 = cur->val + left[0] + right[0];
        return vector<int>{val0, val1};
    
    }
    int rob(TreeNode* root) {
        vector<int> result = robTree(root);
        return max(result[0], result[1]);
    }
};