LeetCode 题解 - 213. House Robber II

LeetCode 第 213. House Robber II，题目难度 Medium。

一. 题目要求

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

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

示例 1:

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

示例 2:

输入: [1,2,3,1]
输出: 4
解释: 你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
     偷窃到的最高金额 = 1 + 3 = 4 。

二. 解题思路 & 代码实现

和第一题基本一样，变化的地方在于 第一个房屋和最后一个是相邻的，因此不能同时打劫。因此需要对是否打劫了第 1 个或最后一个房屋做标识，其他逻辑与 LeetCode 解题报告-198.House Robber 基本一致。

解法 1. 递归

class Solution {

    private int[] nums;
    public int rob(int[] nums) {

        int len = nums.length;
        if (len == 0) {
            return 0;
        }
        if (len == 1) {
            return nums[0];
        }
        if (len == 2) {
            return Math.max(nums[0], nums[1]);
        }

        this.nums = nums;
        return Math.max(helper(len-1, true),helper(len - 2, false));

    }
	
	// robLast 标识是否打劫最后一间房屋
    int helper(int index, boolean robLast) {
        if (index < 0) {
            return 0;
        }
		
		// 如果打劫了最后一间则不能在打劫第 1 间。
        if (index == 0) {
            if (robLast) {
                return 0;
            }else {
                return nums[0];
            }
        }

        return Math.max(helper(index-1, robLast),helper(index - 2, robLast) + nums[index]) ;
    }
 }

和第一题一样，递归的解法虽然可以解决问题，但是因为存在大量的重复计算所以导致运行超时，接下来依然采用空间换时间的方式进行优化。

解法2. 递归优化-空间换时间

为了避免重复计算，我们需要将已经计算过的 index 索引出的最大收益值记录下来避免重复计算，和第一题不同的是因为存在 是否打劫最后一间房屋的问题，因此每个 index 都需要记录两个值。实现代码如下：

class Solution {

    private int[] nums;
    //记录打劫最后 1 间房屋时的收益
    private Map<Integer, Integer> robLastMap = new HashMap<>();
    // 记录不打劫最后 1 间房屋时的收益
    private Map<Integer, Integer> notRobLastMap = new HashMap<>();

    public int rob(int[] nums) {

        int len = nums.length;
        if (len == 0) {
            return 0;
        }
        if (len == 1) {
            return nums[0];
        }
        if (len == 2) {
            return Math.max(nums[0], nums[1]);
        }

        this.nums = nums;
        return Math.max(helper(len - 1, true), helper(len - 2, false));

    }

    int helper(int index, boolean robLast) {
        if (index < 0) {
            return 0;
        }

        if (index == 0) {
            if (robLast) {
                return 0;
            } else {
                return this.nums[0];
            }
        }
        if (robLast) {
            if (!robLastMap.containsKey(index)) {
                robLastMap.put(index, Math.max(helper(index - 1, robLast), helper(index - 2, robLast) + nums[index]));
            }
            return robLastMap.get(index);

        } else {
            if (!notRobLastMap.containsKey(index)) {
                notRobLastMap.put(index, Math.max(helper(index - 1, robLast), helper(index - 2, robLast) + nums[index]));
            }
            return notRobLastMap.get(index);
        }
    }
}

经过优化后的代码执行情况为：Runtime: 2 ms, faster than 5.14%，Memory Usage: 39.2 MB, less than 6.67%，依然存在优化空间。

解法3. 进一步优化

这是我在 discuss 里面看到的解法，解法 2 中使用了 Map 来存储中间值，相对于 Map 数组的查询和修改性能其实更高一些，因此可以数组代替 Map 进行操作。

实现代码如下：

public class Solution {

    private int[] nums;
    private int[] robLastArr;
    private int[] notRobLastArr;

    public int rob(int[] nums) {

        int len = nums.length;
        if (len == 0) {
            return 0;
        }
        if (len == 1) {
            return nums[0];
        }
        if (len == 2) {
            return Math.max(nums[0], nums[1]);
        }

        this.nums = nums;
        this.robLastArr = new int[len];
        this.notRobLastArr = new int[len];
		// 设置初始值为 -1，如果数组值为 -1 说明还没有计算过，如果不是则直接取值，避免重复计算
        for (int i = 0; i < len; i++) {
            robLastArr[i] = -1;
            notRobLastArr[i] = -1;
        }
        return Math.max(helper(len - 1, true), helper(len - 2, false));

    }


    int helper(int index, boolean robLast) {
        if (index < 0) {
            return 0;
        }

        if (index == 0) {
            if (robLast) {
                return 0;
            } else {
                return this.nums[0];
            }
        }
        if (robLast) {
            if (robLastArr[index] == -1) {
                robLastArr[index] = Math.max(helper(index - 1, robLast), helper(index - 2, robLast) + nums[index]);
            }
            return robLastArr[index];

        } else {
            if (notRobLastArr[index] == -1) {
                notRobLastArr[index] = Math.max(helper(index - 1, robLast), helper(index - 2, robLast) + nums[index]);
            }
            return notRobLastArr[index];
        }
    }

}

这一版的运行情况为 Runtime: 0 ms, faster than 100.00%，Memory Usage: 38.9 MB, less than 6.67%，较第二版已经有了明显的提升。

三. 解题后记

整体思路和第一道题差不多，但因为多了首尾相邻的特殊条件因此需要做额外的判断，整体难度不算大，理解了第一题的解法这道题解出来也是比较简单的事情了。

---

老铁，都看到这了来一波点赞、评论、关注三连可好

我是 AhriJ邹同学，前后端、小程序、DevOps 都搞的炸栈工程师。博客持续更新，如果觉得写的不错，欢迎来一波老铁三连，不好的话也欢迎指正，互相学习，共同进步。