LeetCode-213. 打家劫舍 II

Posted 2021-12-29 Garrett_Wale

题目来源

213. 打家劫舍 II

题目详情

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

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

示例 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

题解分析

解法一：动态规划

1. 其实本题和LeetCode的另一题：198. 打家劫舍很像。不同的一点时，这些房屋是首尾相连的，这也导致了不能直接使用LeetCode-198题使用的动态规划方程了。
2. 值得思考的是，这里的首尾相连影响最大的还是首尾这两个特殊位置的考虑，而数组中间的这些元素是可以照常使用198这题的动态转移方程的。
3. 我们可以单独把首尾元素拎出来考虑：如果小偷不偷最后一个房屋，那小偷可以偷的房屋区间就是[0, n-2]；而如果小偷不偷第一间房屋，那小偷可以偷的房屋区间变成了[1, n-1]。
4. 最后的结果就是以上两种情况的最大值，因为整体只有这两种情况，小偷要么不偷第一个，要么不偷第二个。那有读者可能会说，要是两个都不偷呢？其实这种情况不会对本题造成任何问题，我们分类的原因主要是防止小偷同时偷首尾房屋，而这是违背规则的。
5. 还有一个情况需要注意的就是，对于边界值的考虑，即只有一间房屋和只有两间房屋。

class Solution 
    public int rob(int[] nums) 
        int n = nums.length;
        if(n == 1)
            return nums[0];
        else if(n == 2)
            return Math.max(nums[0], nums[1]);
        
        return Math.max(robdp(nums, 0, n-2), robdp(nums, 1, n-1));
    
    private int robdp(int[] nums, int start, int end)
        if(end < start)
            return 0;
        
        int n = end-start+1;
        int[] dp = new int[n]; // dp[i]表示以i结尾的这天，小偷可以偷到的最大金额
        dp[0] = nums[start];
        
        for(int i=1; i<n; i++)
            if(i > 1)
                dp[i] = Math.max(dp[i-2] + nums[start+i], dp[i-1]);
            else
                dp[i] = Math.max(dp[i-1], nums[start+i]);
            
        
        return dp[n-1];
    

解法二：动态规划-压缩数组

1. 与普通的动态规划题目一样，需要时刻考虑是否可以应用压缩数组来减少空间大小。
2. 对于本题而言，也是可以的，因为当前状态只依赖于前面的一个或者两个状态。

class Solution 
    public int rob(int[] nums) 
        int n = nums.length;
        if(n == 1)
            return nums[0];
        else if(n == 2)
            return Math.max(nums[0], nums[1]);
        
        return Math.max(robdp(nums, 0, n-2), robdp(nums, 1, n-1));
    
    private int robdp(int[] nums, int start, int end)
        if(end < start)
            return 0;
        
        int n = end-start+1;

        int pre = 0;
        int prepre = 0;
        if(n > 1)
            prepre = nums[start];
            pre = Math.max(nums[start], nums[start+1]);
        else
            pre = nums[start];
        
        int now = pre;
        for(int i=2; i<n; i++)
            now = Math.max(prepre + nums[i+start], pre);
            prepre = pre;
            pre = now;
        
        return now;
    

运行结果

Either Excellent or Rusty