问题总览

类型	问题描述	完成
	198. 打家劫舍	✅
	213. 打家劫舍 II	✅
	337. 打家劫舍 III	✅
	剑指 Offer II 089. 房屋偷盗	✅
	剑指 Offer II 090. 环形房屋偷盗	✅

题解

198. 打家劫舍

// 我自己的思路，和股票问题有点类似
class Solution {
    public int rob(int[] nums) {
        //前i个房间所能偷到的最大金额
        int n = nums.length;
        int[][] dp = new int[n + 1][2];
        for (int i = 1; i <= n; i++) {
            // 第i个房间选择不偷，前一个房间可以是偷也可以是不偷
            dp[i][0] = Math.max(dp[i - 1][1], dp[i - 1][0]);
            // 第i个房间选择偷，那么前一个房间肯定没偷
            dp[i][1] = dp[i - 1][0] + nums[i - 1];
        }
        return Math.max(dp[n][1], dp[n][0]);
    }
}

class Solution {
    public int rob(int[] nums) {
        //前i个房间所能偷到的最大金额
        int n = nums.length;
        if (n == 1) {
            return nums[0];
        }
        int[] dp = new int[n];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        for (int i = 2; i < n; i++) {
            // 前一个房间偷：dp[i-1]
            // 前一个房间不偷：dp[i-2] + nums[i-1]
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
        }
        return dp[n - 1];
    }
}

213. 打家劫舍 II

增加了首尾不能同时偷取的条件

class Solution {
    public int rob(int[] nums) {
        int len = nums.length;
        if (len == 1) {
            return nums[0];
        }
        if (len == 2) {
            return Math.max(nums[0], nums[1]);
        }
        return Math.max(rob(nums, 0, len - 2), rob(nums, 1, len - 1));
    }

    public int rob(int[] nums, int start, int end) {
        if (end - start == 1) {
            return Math.max(nums[start], nums[end]);
        }

        int[] dp = new int[nums.length];
        dp[start] = nums[start];
        dp[start + 1] = Math.max(nums[start], nums[start + 1]);
        for (int i = start + 2; i <= end; i++) {
            dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        return dp[end];
    }
}
//leetcode submit region end(Prohibit modification and deletion)

337. 打家劫舍 III

房屋被设计成功了二叉树的结构

class Solution {

    public int rob(TreeNode root) {
        int[] res = dp(root);
        return Math.max(res[0], res[1]);
    }

    // 以root为根的树，当前抢劫到的最大金额
    // 0: 表示未抢 root
    // 1: 表示抢了 root
    public int[] dp(TreeNode root) {
        if (root == null) {
            return new int[]{0, 0};
        }
        int[] left = dp(root.left);
        int[] right = dp(root.right);
        int rob = root.val + left[0] + right[0];
        int notRob = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        return new int[]{notRob, rob};
    }
}