198. House Robber 213. House Robber II

    public static void main(String[] args) {
        int[] nums = {2, 7, 9, 3, 1};
        Test2 test2 = new Test2();
        int rob = test2.rob(nums);
        System.out.println(rob);
    }

    public int rob(int[] nums) {
        int length = nums.length;
        if (length==1) return nums[0];
        int[] dp=new int[length];
        dp[0]=nums[0];
        dp[1]=Math.max(nums[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[length-1];
    }

成环了

把环拆成两个队列，一个是从0到n-1，另一个是从1到n，然后返回两个结果最大的

public class Test2 {
    public static void main(String[] args) {
        int[] nums = {1,2,3,1};
        Test2 test2 = new Test2();
        int rob = test2.rob(nums);
        System.out.println(rob);
    }
//    把环拆成两个队列，一个是从0到n-1，另一个是从1到n，然后返回两个结果最大的
    public int rob(int[] nums) {
        if (nums.length==1) return nums[0];
        if (nums.length==2) return Math.max(nums[0],nums[1]);
        int[] array1=new int[nums.length-1];
        int[] array2=new int[nums.length-1];
        for (int i = 0; i < nums.length-1; i++) {
            array1[i]=nums[i];
        }
        for (int i = 0; i < nums.length-1; i++) {
            array2[i]=nums[i+1];
        }

        int[] dp1=new int[array1.length];
        dp1[0]=array1[0];
        dp1[1]=Math.max(array1[0],array1[1]);
        for (int i = 2; i < array1.length; i++) {
            dp1[i]=Math.max(dp1[i-1],dp1[i-2]+array1[i]);
        }
        int[] dp2=new int[array2.length];
        dp2[0]=array2[0];
        dp2[1]=Math.max(array2[0],array2[1]);
        for (int i = 2; i < array2.length; i++) {
            dp2[i]=Math.max(dp2[i-1],dp2[i-2]+array2[i]);
        }
        return Math.max(dp1[array1.length-1],dp2[array2.length-1]);
    }

转换成树结构

题解

public class Solution {

    // 树的后序遍历

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

    private int[] dfs(TreeNode node) {
        if (node == null) {
            return new int[]{0, 0};
        }

        // 分类讨论的标准是：当前结点偷或者不偷
        // 由于需要后序遍历，所以先计算左右子结点，然后计算当前结点的状态值
        int[] left = dfs(node.left);
        int[] right = dfs(node.right);

        // dp[0]：以当前 node 为根结点的子树能够偷取的最大价值，规定 node 结点不偷
        // dp[1]：以当前 node 为根结点的子树能够偷取的最大价值，规定 node 结点偷
        int[] dp = new int[2];

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