代码随想录第三十九天| 198.打家劫舍 213.打家劫舍II 337.打家劫舍 III

198.打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

解题思路

动态规划是解决此类问题的有效方法。我们可以定义一个数组 dp，其中 dp[i] 表示偷窃到第 i 个房屋时能获得的最大金额。状态转移方程需要考虑两种情况：

• 不偷当前房屋：最大金额等于前一个房屋的最大金额 dp[i-1]。
• 偷当前房屋：最大金额等于前两个房屋的最大金额加上当前房屋的金额 dp[i-2] + nums[i]。

因此，状态转移方程为：

dp[i] = max(dp[i-1], dp[i-2] + nums[i])

初始化：

• 当只有一个房屋时，直接返回该房屋的金额。
• 当有两个房屋时，返回两者中的较大值。

优化：可以通过滚动变量将空间复杂度优化到 O(1)，但使用数组更直观易懂。

代码

class Solution {
    public int rob(int[] nums) {
		if(nums.length == 0 || nums == null) return 0;
		if(nums.length == 1){
			return nums[0];
		}
		int[] dp = new int[nums.length];
		dp[0] = nums[0];
		if(nums.length == 2){
			return Math.max(nums[0],nums[1]);
		}
		dp[1] = Math.max(nums[0],nums[1]);
		for(int i = 2 ;i< nums.length;i++){
			dp[i] = Math.max(dp[i-1],dp[i-2]+nums[i]);
		}
		return dp[nums.length-1];
    }
}

复杂度分析

• 时间复杂度：O(n)，需要遍历一次数组。
• 空间复杂度：O(n)，使用了一个长度为 n 的数组存储中间结果。

题目：213.打家劫舍 II

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。
示例:

输入: [2,3,2]
输出: 3
解释: 你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

说明：

• 数组的长度不超过 10000。

解题思路

由于房屋是环形的，所以第一家和最后一家不能同时被选中。这个问题可以分解为两个子问题：

1. 在不偷窃第一家的情况下，能够偷窃到的最高金额。
2. 在不偷窃最后一家的情况下，能够偷窃到的最高金额。
   我们可以使用动态规划来解决这个问题。动态规划的状态转移方程为：
   dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i])
   其中，dp[i] 表示到第 i 家时能够偷窃到的最高金额。

代码

class Solution {
    public int robAction(int[] nums, int start, int end){
        int[] dp = new int[end-start];
        dp[0] = nums[start];
        dp[1] = Math.max(nums[start], nums[start+1]);
        for(int i = 2; i < end-start; i++){
            dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i+start]);
        }
        return dp[end-start-1];
    }
    public int rob(int[] nums) {
        if(nums.length == 0 || nums == null) return 0;
        if(nums.length == 1){
            return nums[0];
        }
        if(nums.length == 2){
            return Math.max(nums[0], nums[1]);
        }
        int len = nums.length;
        return Math.max(robAction(nums, 0, len - 1), robAction(nums, 1, len));
    }
}

在这段代码中，robAction 函数用于计算从 start 到 end 的子数组中能够偷窃到的最高金额。然后在 rob 函数中，我们分别计算不偷窃第一家和不偷窃最后一家的情况，取两者的最大值作为最终结果。

337. 打家劫舍 III

题目描述

在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。
计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。
示例 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.

解题思路

这个问题可以用递归+动态规划的方法来解决。我们可以定义一个递归函数 robAction，它返回一个大小为2的数组，其中：

• res[0] 表示包含当前节点值的最大金额（当前节点被选中）。
• res[1] 表示不包含当前节点值的最大金额（当前节点不被选中）。
  递归的基本情况是当节点为空时，返回 [0, 0]，因为空节点不贡献任何价值。
  对于每个节点，我们有两个选择：

1. 打劫当前节点，那么我们不能打劫它的左右子节点，但我们可以打劫其左右子节点的子节点。
2. 不打劫当前节点，那么我们可以选择打劫或不打劫它的左右子节点。
   递归地计算左右子节点的最大值，然后根据当前节点的选择来更新 res[0] 和 res[1]。

代码实现

public class Solution {
    public int rob(TreeNode root) {
        int[] res = robAction(root);
        return Math.max(res[0], res[1]);
    }
    private int[] robAction(TreeNode root) {
        int[] res = new int[2];
        if (root == null) return res;
        
        int[] left = robAction(root.left);
        int[] right = robAction(root.right);
        
        // 打劫当前节点，不能打劫左右子节点
        res[0] = root.val + left[1] + right[1];
        // 不打劫当前节点，可以打劫或不打劫左右子节点
        res[1] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        
        return res;
    }
}

在这个代码中，robAction 函数是核心，它递归地计算每个节点的最大打劫金额，并通过数组返回结果。最终，rob 函数返回根节点的最大打劫金额。