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

198.打家劫舍

题目链接：198.打家劫舍

文档讲解：代码随想录

视频讲解：动态规划，偷不偷这个房间呢？| LeetCode：198.打家劫舍

思路

dp数组：dp[i]表示考虑下标i（包括i）以内的房屋，最多可以偷dp[i]。

递推公式：dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])，不偷房间i，则金额为dp[i - 1]，偷房间i，则金额为dp[i - 2] + nums[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]);
        }

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

213.打家劫舍II

题目链接：213.打家劫舍II

文档讲解：代码随想录

视频讲解：动态规划，房间连成环了那还偷不偷呢？| LeetCode：213.打家劫舍II

思路

与上一题类似，只需要分别考虑偷不偷首位的房间：

• 不偷尾房间：只需要将不包含尾房间的数组放入上一题中计算。
• 不偷首房间：只需要将不包含首房间的数组放入上一题中计算。

两者取最大值。

代码

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 result1 = robRange(nums, 0, nums.size() - 1);
        int result2 = robRange(nums, 1, nums.size());
        return max(result1, result2);
    }

    int robRange(vector<int> &nums, int start, int end) { // 左闭又开
        if (end - start == 1)
            return nums[start];
        if (end - start == 2)
            return max(nums[start], nums[start + 1]);

        vector<int> dp(nums.size(), 0);
        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 - 1];
    }
};

337.打家劫舍III

题目链接：337.打家劫舍III

文档讲解：代码随想录

视频讲解：动态规划，房间连成树了，偷不偷呢？| LeetCode：337.打家劫舍3

思路

采用后序遍历，先得到左右子树的状态，然后再考虑当前结点是否偷取。

后序遍历返回值返回一个长度为2的数组，数组元素0代表不偷该结点所得到的最大金额，数组元素1代表偷该结点所得到的最大金额。

对于中间结点的处理，如果偷中间结点，则最大金额为中间结点金额 + 不偷左结点最大金额 + 不偷右节点最大金额，如果不偷中间结点，则最大金额为左右结点偷或不偷的最大金额和。

代码

class Solution {
public:
    int rob(TreeNode *root) {
        vector<int> result = traversal(root);
        return max(result[0], result[1]);
    }

private:
    // 返回值：偷与不偷两种状态的金钱数
    // 下标0表示不偷当前结点，下标1表示偷当前结点
    vector<int> traversal(TreeNode *node) {
        if (node == NULL)
            return vector<int>{0, 0};

        vector<int> left = traversal(node->left);
        vector<int> right = traversal(node->right);

        // 没有偷左右结点，偷当前结点
        int val1 = node->val + left[0] + right[0];
        // 偷左右结点，不偷当前结点
        int val2 = max(left[0], left[1]) + max(right[0], right[1]);
        return {val2, val1};
    }
};