lc 打家劫舍系列 198 213 337

最新推荐文章于 2025-05-30 17:22:41 发布

原创最新推荐文章于 2025-05-30 17:22:41 发布 · 222 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

38 篇文章

订阅专栏

本文介绍了LeetCode中的打家劫舍系列问题，包括如何在不触发报警的情况下，计算能偷窃到的最高金额。文章通过示例解释了动态规划的解题思路，并提供了不同限制条件下的解决方案，如不能偷相邻房屋的情况。

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

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

示例 1：

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

输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。

提示：

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

// 首先仍然是一个超时的代码，揭示状态转移关系，很好
class Solution {
    // 状态：第几家，当前利润，当前是否可偷
    private int max;
    private void helper(int[] nums,int index,int cur,boolean robable){
        if(index==nums.length){
            // 因为金额都是正数，并且一定会遍历到最后一家（不会跳跃，也不代表一定偷最后一家）
            // 所以最后一家一定能取到最大值
            max=Math.max(max,cur);
            return;
        }
        if(robable){
            // 如果这一家可偷，那么可以选择偷，也可以不偷
            // 如果偷了，那么下一家不可偷，否则，下一家仍然可偷
            helper(nums,index+1,cur+nums[index],!robable);
            helper(nums,index+1,cur,robable);
        }else{
            // 不可偷，那么只能不偷，下一家可偷
            helper(nums,index+1,cur,!robable);
        }

    }
    public int rob(int[] nums) {
        helper(nums,0,0,true);
        return max;
    }
}

update：

对着上面转化为dp转了半天，没搞出来，找到了一篇让人看了豁然开朗的题解：

https://leetcode-cn.com/problems/house-robber/solution/dong-tai-gui-hua-jie-ti-si-bu-zou-xiang-jie-cjavap/

定义dp[i]为偷[0,i]可以获得的最大利润

那么有两种情况，偷/不偷第i家：如果偷第i家，就不能偷第i-1家，那么最大收益是dp[i-2]+a[i]

如果不偷第i家，就能偷第i-1家，那么最大收益是dp[i-1]

计算的时候，只需要取两者的最大值

base是i=0，1，2的时候，如果为0，那么直接返回0

如果为1，那么就是偷这一家，收益最大

如果为2，那么投第一第二家中较大的：

class Solution {
    // dp[i]表示偷前i家的最大收益
    public int rob(int[] nums) {
        if(nums==null||nums.length==0){
            return 0;
        }
        if(nums.length==1){
            return nums[0];
        }
        int[] dp=new int[nums.length+1];
        dp[0]=0;
        dp[1]=nums[0];
        for(int i=2;i<=nums.length;i++){
            // i=3时，就是看偷第三家（a[2])，不偷第二家，那么就是dp[1]+a[2]
            // 不偷第三家，就是dp[2]
            dp[i]=Math.max(dp[i-1],dp[i-2]+nums[i-1]);
        }
        return dp[nums.length];
    }
}

update:

做了几道股票问题之后，发现状态机做打家劫舍也是降维打击

class Solution {
    public int rob(int[] nums) {
        if(nums==null||nums.length==0){
            return 0;
        }
        int len=nums.length;
        // yes[i]表示结束第i天的操作之后，处于能偷状态，的情况下的最大收益
        // no[i]表示结束第i天的操作之后，处于不能偷状态，的情况下的最大收益
        
        int[] yes=new int[len];
        int[] no=new int[len];
        yes[0]=0;
        no[0]=nums[0];
        int max=nums[0];
        for(int i=1;i<len;i++){
            yes[i]=Math.max(yes[i-1],no[i-1]);
            no[i]=yes[i-1]+nums[i];
            max=Math.max(max,Math.max(yes[i],no[i]));
        }
        return max;
    }
}

213. 打家劫舍 II

难度中等402

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

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

示例 1：
输入：nums = [2,3,2]
输出：3
解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。
示例 2：
输入：nums = [1,2,3,1]
输出：4
解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
     偷窃到的最高金额 = 1 + 3 = 4 。
示例 3：
输入：nums = [0]
输出：0
提示：

1 <= nums.length <= 100
0 <= nums[i] <= 1000

增加的限制，代表不能同时偷第一家和最后一家，看了下，最简单也是大家都在使用的做法是，在[0,len-1]和[1,len]上分别跑一遍198的算法，然后取较大值

class Solution {
    private int rob198(int[] nums){
        if(nums==null||nums.length==0){
            return 0;
        }
        int len=nums.length;
        // yes[i]表示结束第i天的操作之后，处于能偷状态，的情况下的最大收益
        // no[i]表示结束第i天的操作之后，处于不能偷状态，的情况下的最大收益
        
        int[] yes=new int[len];
        int[] no=new int[len];
        yes[0]=0;
        no[0]=nums[0];
        int max=nums[0];
        for(int i=1;i<len;i++){
            yes[i]=Math.max(yes[i-1],no[i-1]);
            no[i]=yes[i-1]+nums[i];
            max=Math.max(max,Math.max(yes[i],no[i]));
        }
        return max;
    }
    public int rob(int[] nums) {
        if(nums==null||nums.length==0){
            return 0;
        }
        if(nums.length==1){
            return nums[0];
        }
        return Math.max(rob198(Arrays.copyOfRange(nums,0,nums.length-1)),rob198(Arrays.copyOfRange(nums,1,nums.length)));
    }
}

337. 打家劫舍 III

难度中等613

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

计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

示例 1:
输入: [3,2,3,null,3,null,1]

     3
    / \
   2   3
    \   \ 
     3   1

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

     3
    / \
   4   5
  / \   \ 
 1   3   1

输出: 9
解释: 小偷一晚能够盗取的最高金额 = 4 + 5 = 9.

感觉因为是树反而更好做qaq

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    private HashMap<TreeNode,Integer> memo=new HashMap<>(); 
    public int rob(TreeNode root) {
        if(root==null){
            return 0;
        }
        if(memo.containsKey(root)){
            return memo.get(root);
        }
        // 对于root，可以偷，也可以不偷
        // 如果偷了root，那么就不能偷root的左右孩子
        // 如果不偷根，就能偷root的左右孩子
        int robRoot=root.val;
        // 不能偷root的左右孩子，则要看左右孩子还分别有没有左右孩子
        if(root.left!=null){
            robRoot+=rob(root.left.left)+rob(root.left.right);
        }
        if(root.right!=null){
            robRoot+=rob(root.right.left)+rob(root.right.right);
        }
        int notRobRoot=rob(root.left)+rob(root.right);
        int t=Math.max(robRoot,notRobRoot);
        memo.put(root,t);
        return t;
    }
}```