017、打家劫舍问题（labuladong）

最新推荐文章于 2024-10-31 16:16:13 发布

FKX1213

最新推荐文章于 2024-10-31 16:16:13 发布

阅读量168

点赞数

文章标签：算法 leetcode

本文链接：https://blog.csdn.net/Yora123/article/details/128594786

版权

文章介绍了使用动态规划解决LeetCode中的打家劫舍问题，包括三个不同版本的解题思路：从一维数组到二维数组，再到处理树结构的递归解法，重点在于状态转移方程和备忘录优化。

摘要由CSDN通过智能技术生成

House Robber

基于labuladong的算法网站，进行个人总结思考和code，网址点我进行跳转

1、打家劫舍Ⅰ

力扣第198题，打家劫舍

[198]打家劫舍

class Solution {
    // 利用动态规划
    public int rob(int[] nums) {
        int count = nums.length;//  房屋个数
        // memo[i]:偷窃到第i个房屋时，偷窃到的最高金额
        int[] memo = new int[count];// dp table
        // 状态可能性
        for (int i = 0; i < count; i++) {
            // base case
            if (i == 0) {
                memo[i] = nums[0];
                continue;
            }
            if (i == 1) {
                memo[i] = Math.max(nums[0], nums[1]);
                continue;
            }
            // 状态转移（选择）
            // 不偷第i家；偷第i家
            memo[i] = Math.max(memo[i - 1], memo[i - 2] + nums[i]);
        }
        return memo[count - 1];
    }
}

2、打家劫舍Ⅱ

力扣第213题，打家劫舍Ⅱ

[213]打家劫舍 II

class Solution {
    // 本题的关键在于首尾不能同时被抢劫，那么问题就可以分解成为：
    // 1、在[0，nums.length-2]求能偷窃到的最高金额
    // 2、在[1，nums.length-1]求能偷窃到的最高金额
    public int rob(int[] nums) {
        int length = nums.length;
        // 先行条件判断
        if (length == 1) {
            return nums[0];
        }
        if (length == 2) {
            return Math.max(nums[0], nums[1]);
        }
        return Math.max(dp(nums, 0, length - 2), dp(nums, 1, length - 1));
    }

    // 返回小偷在[left,right]房屋,能偷窃到的最高金额
    int dp(int[] nums, int left, int right) {
        int length = right - left + 1;
        int[] memo = new int[length];
        for (int i = 0; i < length; i++) {
            // base case
            if (i == 0) {
                memo[i] = nums[i + left];
                continue;
            }
            if (i == 1) {
                memo[i] = Math.max(memo[i - 1], nums[i + left]);
                continue;
            }
            // 可能的选择导致的状态结果
            memo[i] = Math.max(memo[i - 1], memo[i - 2] + nums[i + left]);
        }
        return memo[length - 1];
    }

}

3、打家劫舍Ⅲ

力扣第337题，打家劫舍Ⅲ

[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 {
    // 利用一个map作为备忘录，消除重叠子问题
    Map<TreeNode, Integer> memo = new HashMap<>();

    // 本题是典型的自上而下的动态规划
    // 返回以root为根节点时，小偷能够偷盗的最高金额
    public int rob(TreeNode root) {
        // base case
        if (root == null) {
            return 0;
        }
        if (memo.containsKey(root)) {
            return memo.get(root);
        }
        // 状态的可能性
        // 1、抢当前住宅 ,然后去下下家
        int yes = root.val
                + (root.left == null ? 0 : rob(root.left.left) + rob(root.left.right))
                + (root.right == null ? 0 : rob(root.right.left) + rob(root.right.right));
        // 2、不抢当前住宅
        int no = rob(root.left) + rob(root.right);
        // 最后的结果
        int result = Math.max(yes, no);
        // 记得添加到备忘录中
        memo.put(root, result);
        return result;
    }

}