代码随想录算法训练营day48| 198.打家劫舍、213.打家劫舍II、337.打家劫舍III

Leetcode 198.打家劫舍

题目链接
思路：dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]。

如果偷第i房间，那么dp[i] = dp[i - 2] + nums[i] ，即：第i-1房一定是不考虑的，找出下标i-2（包括i-2）以内的房屋，最多可以偷窃的金额为dp[i-2] 加上第i房间偷到的钱。

如果不偷第i房间，那么dp[i] = dp[i - 1]，即考虑i-1房（注意这里是考虑，并不是一定要偷i-1房）
代码：

class Solution {
    public int rob(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        if (nums.length == 1) {
            return nums[0];
        }
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        dp[1] = Math.max(dp[0], nums[1]);
        for (int i = 2; i < nums.length; i++) {
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
        }
        return dp[nums.length - 1];
    }
}

Leetcode 213.打家劫舍II

题目链接
思路：考虑两种情况，包含首元素不包含尾元素和包含尾元素不包含首元素
代码：

class Solution {
    public int rob(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        if (nums.length == 1) {
            return nums[0];
        }
        // 不包含尾
        int result1 = robRange(nums, 0, nums.length - 2);
        // 不包含头
        int result2 = robRange(nums, 1, nums.length - 1);
        return Math.max(result1, result2);

    }

    private int robRange(int[] nums, int start, int end) {
        if (end == start) {
            return nums[start];
        }
        int[] dp = new int[nums.length];
        dp[start] = nums[start];
        dp[start + 1] = Math.max(nums[start], nums[start + 1]);
        for (int i = 2; i <= end; i++) {
            dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        return dp[end];
    }
}

Leetcode 337.打家劫舍III

题目链接
思路：动态规划结合树
代码：

class Solution {
    public int rob(TreeNode root) {
        // 0：不偷当前节点，1：偷当前节点
        // 偷当前节点，那么左右孩子就不能偷，不偷当前节点，那么左右孩子就可以偷
        int[] res = robTree(root);
        return Math.max(res[0], res[1]);
    }

    private int[] robTree(TreeNode root) {
        int res[] = new int[2];
        if (root == null) {
            return res;
		}
		
        int[] left = robTree(root.left);
        int[] right = robTree(root.right);

        res[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        res[1] = root.val + left[0] + right[0];
        return res;
    }
}