LeetCode-213. 打家劫舍 II

题目来源

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

相似题目

• 198. 打家劫舍
• 213. 打家劫舍 II
• 337. 打家劫舍 III

题解分析

解法一：动态规划

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){
       int n = end-start+1;
       int[] dp = new int[n+1];
       dp[0] = 0;
        for(int i=1;i<=n; i++){
            if(i > 1){
                dp[i] = Math.max(dp[i-1], dp[i-2] + nums[start+i-1]);
            }else{
                dp[i] = nums[start+i-1];
            }
        }
        return dp[n];
    }
}

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

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){
       int n = end-start+1;
       // dp[i]表示以i结尾的这天，小偷可以偷到的最大金额
        int dp = 0, pre = 0;
        for(int i=1; i<=n; i++){
            int temp = dp;
            dp = Math.max(dp, pre + nums[start+i-1]);
            pre = temp;
        }
        return dp;
    }
}

运行结果