打家劫舍三部曲

打家劫舍1
打家劫舍2
打家劫舍3

第一题

打家劫舍是经典的dp问题，所以套用动态规划五部曲

• dp数组定义
  dp[i] 表示到下标为i的房子可以偷到的最多的钱
• 递推公式
  无非两种情况，偷当前房子和不偷当前房子，即
  dp[i] = Math.max(dp[i - 2] + nums[i],dp[i - 1])
• dp数组初始化
  dp[0] = nums[0],dp[1] = Math.max(dp[0],dp[1])
• 遍历顺序
  dp[i] 是根据dp[i - 2] 和 dp[i - 1] 推导出来的，所以是从前往后遍历。

第二题

无非就是成环了，偷头就不能偷尾，有三种情况。

1. 考虑不带首尾
2. 考虑不带尾
3. 考虑不带头
   但是2，3包含1的情况，所以其实只有两种情况

class Solution {
    public int rob(int[] nums) {
        if(nums.length == 0 || nums == null) {
            return 0;
        }
        if(nums.length == 1) return nums[0];
        int money1 = robbery(nums,0,nums.length - 2);
        int money2 = robbery(nums,1,nums.length - 1);
        return money1 > money2 ? money1 : money2;
    }
    public int robbery(int[] nums,int start,int end) {
        if(start == end) 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 = start + 2;i <= end;i++) {
            dp[i] = Math.max(nums[i] + dp[i - 2],dp[i - 1]);
        }
        return dp[end];
    }
}

第三题

        这道题可以用dp来做，只不过是在树上dp，我们要用到递归，因为要参考左右子树的结果，所以我们使用后序遍历。
        dp含义：定义一个长度为2的数组，0代表不偷当前节点的最大值，1为偷当前节点的最大值，因为是递归所以系统栈存储每个节点的信息，递归参数是树节点，返回值是长度为2的数组，终止条件为当前节点为空，返回{0，0}

class Solution {
    public int rob(TreeNode root) {
        int[] res = new int[2];
        res = robTree(root);
        return Math.max(res[0],res[1]);
    }
    public int[] robTree(TreeNode cur) {
        int[] res = new int[2];
        if(cur == null) {
            return res;
        }
        int[] left = robTree(cur.left);
        int[] right = robTree(cur.right);
        //偷父节点
        res[1] = cur.val + left[0] + right[0];
        //不偷父节点,此时要考虑子节点偷和不偷哪个金额更大
        res[0] = Math.max(left[0],left[1]) + Math.max(right[0],right[1]);
        return res;
    }
}