DAY48|198.打家劫舍 、213.打家劫舍II （环形）、337.打家劫舍III（二叉树）

今天就是打家劫舍的一天，这个系列不算难，大家可以一口气拿下。

198.打家劫舍

class Solution {
    public int rob(int[] nums) {
        if(nums.length==1) return nums[0];
        //dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]。
        int[] dp=new int[nums.length];
        dp[0]=nums[0];
        dp[1]=Math.max(nums[0],nums[1]);
        //因为间隔不能偷所以从2开始，由1，0推出2
        for(int i=2;i<nums.length;i++){
            //偷i还是不偷i:如果不偷i则查看i-1的值（最大偷窃金额）
            //            如果偷则查看dp[i-2]的值再加上当前。
            dp[i]=Math.max(dp[i-1],dp[i-2]+nums[i]);
        }
        return dp[dp.length-1];
    }
}

213.打家劫舍II
环形问题转化成线性问题

class Solution {
    public int rob(int[] nums) {
        if(nums.length==1) return nums[0];
        if(nums.length==2) return Math.max(nums[0],nums[1]);
        //分两种情况 ：考虑头节点不考虑尾节点，不考虑头节点考虑尾节点
        //取这两种情况最大值
        int res=0;
        res=Math.max(stealAction(0,nums.length-1,nums),stealAction(1,nums.length,nums));
        return res;
    }
    int stealAction(int start,int end,int[] nums){//不包括end
        int[] dp=new int[end-start];///注意！！！！
        dp[0]=nums[start];
        dp[1]=Math.max(nums[start],nums[start+1]);
        for(int i=2;i<end-start;i++){
            if(start==0) dp[i]=Math.max(dp[i-1],dp[i-2]+nums[i]);
            if(start==1) dp[i]=Math.max(dp[i-1],dp[i-2]+nums[i+1]);
        }
        return dp[nums.length-2];
    }
}

第二种方法：因为是环形 所以可以设置xyz

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

    int robAction(int[] nums, int start, int end) {
        int x = 0, y = 0, z = 0;
        for (int i = start; i < end; i++) {
            
            z = Math.max(y, x + nums[i]);
            x = y;
            y = z;
            
        }
        return z;
    }
}

337.打家劫舍III

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int rob(TreeNode root) {
        int[] res = robAction1(root);
        return Math.max(res[0], res[1]);
    }

    int[] robAction1(TreeNode root) {
        //dp数组两个状态偷与不偷当前节点的 money最大值
        int dp[] = new int[2];
        if (root == null)
            return dp;

        int[] left = robAction1(root.left);
        int[] right = robAction1(root.right);
        //不偷当前节点，取左右子树的偷与不偷的最大值
        dp[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        //偷当前节点 则取左右子树不偷的值+当前节点的值
        dp[1] = root.val + left[0] + right[0];
        return dp;
    }
}