【代码随想录二刷】day 48 | 198.打家劫舍 & 213.打家劫舍II & 337.打家劫舍III

二刷主要记录理解不一样的题

一刷地址：day48

今日题目：中等

打家劫舍系列的题就是选，或者不选的问题，选了自己应该如何处理，自己不选又应该如何处理是两种状态.

打家劫舍

递归 注意全零数据

class Solution {
    int[] memo;
    int[] nums;
    public int rob(int[] nums) {
        int n = nums.length;
        this.nums = nums;
        memo = new int[n];
        // 有一个全0的示例不填充会超时
        Arrays.fill(memo, -1);
        return dfs(n-1);
    }

    int dfs(int i){
        if(i < 0) return 0;
        if(memo[i] != -1) return memo[i];
        // 选自己 或 不选自己
        memo[i] = Math.max(dfs(i-2) + nums[i], dfs(i-1));
        return memo[i];
    }
}

dp

class Solution {
    public int rob(int[] nums) {
        int n = nums.length;
        if(n == 1) return nums[0];
        int[] dp = new int[n];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        for(int i = 2; i < n; i++){
            // 选自己 i-2加自己  不选自己 i-1
            dp[i] = Math.max(dp[i-2] + nums[i], dp[i-1]);
        }

        return dp[n-1];
    }
}

打家劫舍II

和1一模一样，需注意就是memo需要重置
递归

class Solution {
    int[] memo;
    int[] nums;
    public int rob(int[] nums) {
        int n = nums.length;
        if(n == 1) return nums[0];
        this.nums = nums;
        memo = new int[n];
        // 有一个全0的示例不填充会超时
        Arrays.fill(memo, -1);
        // 偷了第一家，最后一家就不能被偷
        int zero = dfs(0, n-2);
        // 需重新重置一下缓存
        Arrays.fill(memo, -1);
        return Math.max(zero, dfs(1, n-1));
    }

    int dfs(int i, int j){
        // j的范围不能小于i
        if(i > j) return 0;
        if(memo[j] != -1) return memo[j];
        // 选自己 或 不选自己
        memo[j] = Math.max(dfs(i, j-2) + nums[j], dfs(i, j-1));
        return memo[j];
    }
}

dp

class Solution {
    public int rob(int[] nums) {
        int n = nums.length;
        if(n == 1) return nums[0];
        int[] dp = new int[n];
        // 不选最后一个位
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0], nums[1]);
        for(int i = 2; i < n-1; i++){
            dp[i] = Math.max(dp[i-1], dp[i-2]+nums[i]);
        }
        int a = dp[n-2];

        // 选最后一个，第一个不选
        Arrays.fill(dp, 0);
        dp[1] = nums[1];
        for(int i = 2; i < n; i++){
            dp[i] = Math.max(dp[i-1], dp[i-2]+nums[i]);
        }
        int b = dp[n-1];

        return Math.max(a,b);
    }
}

打家劫舍III

树形dp的入门题，每个结点存一个int[]，分别是投，与不偷

class Solution {
    int[] dp;
    public int rob(TreeNode root) {
        int[] res = dfs(root);
        // 选不选根结点的最大值
        return Math.max(res[0], res[1]);
    }

    // 后序：返回{选该结点最大值，不选}
    int[] dfs(TreeNode root){
        if(root == null) return new int[]{0,0};
        
        int[] left = dfs(root.left);
        int[] right = dfs(root.right);

        // 选中结点：左右子树都不能选 + 自己结点值
        int a = left[1] + right[1] + root.val;
        // 不选中结点：左右子树都可选      
        int b = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        return new int[]{a, b};
    }
}