day47

打家劫舍

1.打家劫舍1

class Solution {

    private int[] memo;
    //主函数
    public int rob(int[] nums) {
        //  初始化备忘录
        memo = new int[nums.length];
        Arrays.fill(memo, -1);
        //强盗从第0间房子开始抢劫
        return dp(nums, 0);
    }

    //返回 dp[start..] 能抢到的最大值
    private int dp(int[] nums, int start){
        if(start >= nums.length){
            return 0;
        }
        //避免重复计算
        if(memo[start] != -1) return memo[start];

        int res = Math.max(
            dp(nums, start + 1),
            dp(nums, start + 2) + nums[start]
        );
        // 记入备忘录
        memo[start] = res;
        return res;
    }
}

2.打家劫舍2

class Solution {

    public int rob(int[] nums) {
        int n = nums.length;
        if (n == 1) return nums[0];
//仅比较选第一个房子~倒数第二个房子  和 第二个房子到最后一个房子这两种情况进行对比
        return Math.max(robRange(nums, 0, n - 2), 
                        robRange(nums, 1, n - 1));
    }

    // 仅计算闭区间 [start,end] 的最优结果
    int robRange(int[] nums, int start, int end) {
        int n = nums.length;
        int dp_i_1 = 0, dp_i_2 = 0;
        int dp_i = 0;
        for (int i = end; i >= start; i--) {
            dp_i = Math.max(dp_i_1, nums[i] + dp_i_2);
            dp_i_2 = dp_i_1;
            dp_i_1 = dp_i;
        }
        return dp_i;
    }
}

3.打家劫舍3

class Solution {
    Map<TreeNode, Integer> memo = new HashMap<>();
    public int rob(TreeNode root) {
        if (root == null) return 0;
        // 利用备忘录消除重叠子问题
        if (memo.containsKey(root)) 
            return memo.get(root);
        // 抢，然后去下下家
        int do_it = root.val
            + (root.left == null ? 
                0 : rob(root.left.left) + rob(root.left.right))
            + (root.right == null ? 
                0 : rob(root.right.left) + rob(root.right.right));
        // 不抢，然后去下家
        int not_do = rob(root.left) + rob(root.right);
        
        int res = Math.max(do_it, not_do);
        memo.put(root, res);
        return res;
    }
}