代码随想录算法训练营第四十八天| 198. 打家劫舍、213. 打家劫舍 II、337. 打家劫舍 III。

198. 打家劫舍

题目链接：力扣

题目要求：

        你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例 1：

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
     偷窃到的最高金额 = 1 + 3 = 4 。

• 1 <= nums.length <= 100
• 0 <= nums[i] <= 400

总结：

        dp[i]代表范围到第i家包括，包括第i家，能偷的最大金额，如果偷这个i家的，则只能看范围到该家的前面两家的能偷的最大金额，加上该家的金额，如果不偷这家的，则需要看范围到该家的前一家的能偷的最大金额。比较这两种可能性的最大值将其赋给dp[i]。

class Solution {
    public int rob(int[] nums) {
        //如果只有一家，则肯定偷就完事了，返回这家的金额
        if(nums.length == 1) return nums[0];
        //dp[i]代表考虑前i家包括第i家，能偷的最大金额数
        int[] dp = new int[nums.length];
        //只有一家，则必偷，dp[0]直接等于这一家的金额
        dp[0] = nums[0];
        //有两家，为了避免报警，则选一个最大金额的偷
        dp[1] = Math.max(nums[0],nums[1]);
        //当前i偷的情况下，需要前两个元素的dp[i-2],也就是截止到i-2个的家能偷的最大值，这个dp[i-2]要加上第i个家的金额
        //当前i不偷的情况下，需要包含前1个元素的dp[i-1]，也就是截止到i-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];
    }
}

213. 打家劫舍 II

题目链接：力扣

题目要求：

        你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。

给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。

示例 1：

输入：nums = [2,3,2]
输出：3
解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

总结：

        本题因为成环，故第一个和最后一个不能同时去选，所以分为下面三个情况，首位都不含，只含头，只含尾，这三个情况每个情况都又转换成了上题的不成环的情况，比较三者的最大值即可，这里因为后两种情况也都包含了第一种情况，故只需要考虑后两种情况的最大值即可。用上一题的思路都后两种情况求dp[i]。

对于一个数组，成环的话主要有如下三种情况：

• 情况一：考虑不包含首尾元素

• 情况二：考虑包含首元素，不包含尾元素

• 情况三：考虑包含尾元素，不包含首元素

注意我这里用的是"考虑"，例如情况三，虽然是考虑包含尾元素，但不一定要选尾部元素！ 对于情况三，取nums[1] 和 nums[3]就是最大的。

而情况二 和 情况三 都包含了情况一了，所以只考虑情况二和情况三就可以了。

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]);
        return Math.max(rob1(nums,0,nums.length-1),rob1(nums,1,nums.length));
    }
    
    private int rob1(int[] nums,int start,int end){
        if(end-start+1 == 1) return nums[start];
        int[] dp = new int[end-start+1];
        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-1];
    }
}

337. 打家劫舍 III

题目链接：力扣

题目要求：

        小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。

给定二叉树的 root 。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额 。 

示例 1:

输入: root = [3,2,3,null,3,null,1]
输出: 7 
解释: 小偷一晚能够盗取的最高金额 3 + 3 + 1 = 7

总结：

        用一个大小为2的res数组，res[0]代表不偷当前节点，目前的最大金额数，res[1]代表偷当前的节点，目前的最大金额数，用后序遍历二叉树，将每次的结果返回上一层加以利用，到达上一层的节点。如果不偷遍历的当前节点，则其左右孩子可偷可不偷，则需要前求其左孩子不偷与偷的情况的最大金额，left[0]与left[1],求这两者的最大值，求其右孩子不偷与 偷情况的最大金额，right[0]与right[1],求这两者的最大值，将遍历到的该节点的左右孩子的两个最大金额相加赋值给当前节点不偷情况下的最大金额res[0]。当前如果偷该节点的话，那么其左右孩子就都不能偷，故需求得其左孩子在不偷左孩子的情况下取得的最大金额数left[0],右孩子在不偷右孩子的情况下取得的最大金额数right[0],将left[0]、right[0]、当前节点的val值三者相加，求出在偷本节点的情况下，偷取的最大金额res[1]；

/**
 * 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 = rob1(root);
        return Math.max(res[0],res[1]);
    }
    private int[] rob1(TreeNode root){
        int[] res = new int[2];
        if(root == null) return res;
        int[] left = rob1(root.left);
        int[] right = rob1(root.right);
        //对当前节点不偷还是偷的情况分别res[0],res[1]考虑
        //不偷，则其左右孩子都可以偷
        res[0] = Math.max(left[0],left[1]) + Math.max(right[0],right[1]);
        //偷，则左右孩子只能考虑不偷的情况
        res[1] = root.val + left[0] + right[0];
        return res;
    }
}