算法练习第四十八天|337. 打家劫舍 III、213. 打家劫舍 II、198. 打家劫舍

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 {
    // 1.递归去偷，超时
    // public int rob(TreeNode root) {
    //     if (root == null)
    //         return 0;
    //     int money = root.val;
    //     if (root.left != null) {
    //         money += rob(root.left.left) + rob(root.left.right);
    //     }
    //     if (root.right != null) {
    //         money += rob(root.right.left) + rob(root.right.right);
    //     }
    //     return Math.max(money, rob(root.left) + rob(root.right));
    // }

    // 执行用时：0 ms , 在所有 Java 提交中击败了 100% 的用户
    // 不偷：Max(左孩子不偷，左孩子偷) + Max(右孩子不偷，右孩子偷)
    // root[0] = Math.max(rob(root.left)[0], rob(root.left)[1]) +
    // Math.max(rob(root.right)[0], rob(root.right)[1])
    // 偷：左孩子不偷+ 右孩子不偷 + 当前节点偷
    // root[1] = rob(root.left)[0] + rob(root.right)[0] + root.val;
    public int rob(TreeNode root) {
        int[] res = robAction1(root);
        return Math.max(res[0], res[1]);
    }

    int[] robAction1(TreeNode root) {
        int res[] = new int[2];
        if (root == null)
            return res;
        //后序遍历
        int[] left = robAction1(root.left);
        int[] right = robAction1(root.right);

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


}

213. 打家劫舍 II

class Solution {
    public int rob(int[] nums) {
        //主要考虑两种情况，[0,nums.length-2]以及[1,nums.length-1]

        if(nums == null || nums.length == 0) return 0;
        if(nums.length ==1) return nums[0];

        int result1 = calculate(nums,0,nums.length-2);
        int result2 = calculate(nums,1,nums.length-1);

        return Math.max(result1,result2);

    }
    public int calculate(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(dp[i-2] + nums[i],dp[i-1]);
        }

        return dp[end];
    }
}

198. 打家劫舍

class Solution {
    public int rob(int[] nums) {
        //dp数组含义：dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]。

        //递推公式:
        //如果偷i的房间最多金额是：dp[i] = dp[i-2] + nums[i]
        //如果不偷i的房间最多金额是,即考 虑i-1房，：dp[i] = dp[i-1];
        //dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);

        //初始化
        //dp[0] = nums[0],dp[1] = max(nums[0],nums[1]);

        if(nums == null || nums.length == 0) return 0;

        if(nums.length == 1) return nums[0];
        int[] dp = new int[nums.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-2] + nums[i],dp[i-1]);
        }
        return dp[nums.length-1];
    }
}