打家劫舍问题（线性，环形

打家劫舍问题（根据递推公式来初始化

偷i和不偷i两种情况

如果连成环，考虑首元素就不考虑尾元素，考虑尾元素就不考虑首元素

线性问题代码

class Solution {
    public int rob(int[] nums) {
        int len=nums.length;
        int[] dp=new int[len];//记录最大可偷窃金额
        dp[0]=nums[0];
        dp[1]=Math.max(dp[0],nums[1]);
        for(int i=2;i<len;i++){
            dp[i]=Math.max(dp[i-1],dp[i-2]+nums[i]);
        }
        return dp[len-1];
    }
}

环形问题，start相当于遍历nums数组的指针，i相当于遍历dp[] 数组的指针

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]);
        int r1 = robHelper(nums, 0, len - 2);
        int r2 = robHelper(nums, 1, len - 1);
        return Math.max(r1, r2);
    }
    public int robHelper(int[] nums, int start, int end) {
        int[] dp = new int[end - start + 1];//数组长度！
        dp[0] = nums[start];
        dp[1] = Math.max(nums[start], nums[start + 1]);
        for (int i = 2; i <= end - start; i++) {
            dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i + start]);
        }
        return dp[end - start];
    }
}

二叉树问题（用后序遍历递推，res[]记录偷与不偷的值

class Solution {
    public int rob(TreeNode root) {
        int[] result=robHelper(root);
        return Math.max(result[0],result[1]);
    }
    public int[] robHelper(TreeNode root){
        int[] res=new int[2];//res[0-1] 记录偷与不偷的值
        if(root==null){
            return res;
        }
        int[] left=robHelper(root.left);
        int[] right=robHelper(root.right);
        int value1=root.val+left[0]+right[0];//偷当前结点
        int value2=Math.max(left[0],left[1])+Math.max(right[0],right[1]);//不偷当前结点
        res[1]=value1;//偷，注意要对应
        res[0]=value2;
        return res;
    }
}