代码随想录打卡第48天|198.打家劫舍；213.打家劫舍II；337.打家劫舍III

198.打家劫舍

关键点1：if(nums.length == 1) return nums[0];单独列出这种情况

关键点2：dp[i] = Math.max(dp[i-2]+nums[i],dp[i-1])、dp[i-2]+nums[i]是取了的情况，dp[i-1]是没取的情况，求最大值

关键点3： return dp[nums.length-1];

class Solution {
    public int rob(int[] nums) {
        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];
    }
}

213.打家劫舍II

关键点1：if(nums.length == 1) return nums[0]；nums.length == 2，return Math.max(nums[0],nums[1]);;单独列出这两种情况

关键点2：nums.length>=3时，初始化first = nums[left];second = Math.max(nums[left],nums[left+1]);

关键点3：

3-1：temp 保存一下second的值，temp = second;
3-2：更新second = Math.max(nums[i]+ first,second);
3-3：再将temp给前一个状态 first = temp;

class Solution {
    public int rob(int[] nums) {
        if(nums.length == 1){
            return nums[0];
        } 
        else if(nums.length == 2){
            return Math.max(nums[0],nums[1]);
        } 
        int leftNum = rob_basic(nums,0,nums.length-2);
        int rightNum = rob_basic(nums,1,nums.length-1);
        return Math.max(leftNum,rightNum);
    }
    public int rob_basic(int[] nums,int left,int right){        
        int first = nums[left];
        int second = Math.max(nums[left],nums[left+1]);
        for(int i = left+2;i <= right;i++){
            int temp = second;
            second = Math.max(nums[i]+ first,second);
            first = temp;
        }
        return second;
    }
}

337.打家劫舍III

关键点1：进行后续遍历，左右中；

关键点2：

2-1：res[0] = root.val+leftArr[1]+rightArr[1]; // res[0] 表示要取这个节点的值作为范围；

2-2：res[1] = Math.max(leftArr[0],leftArr[1])+Math.max(rightArr[0],rightArr[1]); // res[1] 表示不取这个节点的值作为范围；

关键点3：主函数输入root，backStacking(root);

/**
 * 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[] resArr = backStacking(root);
        return Math.max(resArr[0],resArr[1]);
    }
    public int[] backStacking(TreeNode root){
        int[] res = new int[2];  
        if(root == null){
            return res;
        }
        int[] leftArr = backStacking(root.left);
        int[] rightArr = backStacking(root.right);
             
        res[0] = root.val+leftArr[1]+rightArr[1];
        res[1] = Math.max(leftArr[0],leftArr[1])+Math.max(rightArr[0],rightArr[1]);
        return res;
    }
}