day48｜● 198.打家劫舍 ● 213.打家劫舍II ● 337.打家劫舍III

最新推荐文章于 2024-09-27 14:28:55 发布

EssieDing

最新推荐文章于 2024-09-27 14:28:55 发布

阅读量164

点赞数

文章标签：算法数据结构 java

本文链接：https://blog.csdn.net/Dorothy603/article/details/131986452

版权

198.打家劫舍

dp[i]：考虑当前i以内的所有房屋，最多可以偷窃的金额为dp[i]。
递推公式：

偷第i间房，那么一定不考虑i-1，所以前面i-2间房的最大金额加上当前i房的money
不偷第i间房，那么就可以考虑i-1，注意是考虑，不是一定偷。

class Solution {
    public int rob(int[] nums) {
        int[] dp = new int[nums.length];
        if (nums.length == 1) return nums[0];
        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];
    }
}

时间复杂度: O(n)
空间复杂度: O(n)

● 213.打家劫舍II
dp[i] 考虑当前i以内（0-i）的所有房屋，最多可以偷窃的金额为dp[i].

这里递推的逻辑是一样的，不同的是成环之后的首尾特殊情况，这里把偷不偷nums[0]单独分类考虑。

class Solution {
    public int rob(int[] nums) {
        int[] dp = new int[nums.length];
        // if rob nums[0]
        dp[0] = nums[0];
        dp[1] = nums[0];
        for (int i = 2; i < nums.length-1; i++) { // we cannot consider nums.length-1 anymore, so stop at nums.length-2
            dp[i] = Math.max(dp[i-2]+nums[i], dp[i-1]);
        }
        int res = dp[nums.length-2];

        // if not rob nums[0]
        dp[0] = 0;
        dp[1] = nums[1];
        for (int i = 2; i < nums.length; i++) {
            dp[i] = Math.max(dp[i-2]+nums[i], dp[i-1]);
        }

        return Math.max(res, dp[nums.length-1]);
    }
}

时间复杂度: O(n)
空间复杂度: O(n)

● 337.打家劫舍III
后序遍历，因为要利用递归的返回值来做下一步递推。
如果抢了当前节点，那么左右孩子就不能抢，如果没有抢当前节点，那么就可以考虑抢不抢左右节点（注意是考虑）！！！
这题一直没想明白整个流程，

class Solution {
    public int rob(TreeNode root) {
        int[] res = robTree(root);
        return Math.max(res[0], res[1]);
    }
    // two element size array, 0 not rob, 1 rob
    private int[] robTree(TreeNode curr) {
        if (curr == null) return new int[]{0,0};
        int[] left = robTree(curr.left);
        int[] right = robTree(curr.right);
        // if rob curr node, then we cannot rob left and right one.
        int robCurr = left[0] + right[0] + curr.val;
        // if not rob curr node, then we can rob or not rob for each side.
        int notRobCurr = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        return new int[] {notRobCurr, robCurr};
    }
}