leetcode213. 打家劫舍 II(java)

最新推荐文章于 2024-11-13 20:43:20 发布

SP_1024

最新推荐文章于 2024-11-13 20:43:20 发布

阅读量1.4k

点赞数

分类专栏： java 算法数据结构文章标签： java leetcode 算法数据结构动态规划

本文链接：https://blog.csdn.net/SP_1024/article/details/131175304

版权

算法同时被 3 个专栏收录

274 篇文章 3 订阅

订阅专栏

java

265 篇文章 2 订阅

订阅专栏

数据结构

235 篇文章 0 订阅

订阅专栏

该问题是一个环形动态规划问题，小偷在不触发警报的情况下，需要决定是否抢劫每个房子以获取最高金额。解决方案包括两种情况：选择或不选择第一个房子。通过递归和缓存避免重复计算，分别计算这两种情况下的最大金额，最后取两者中的最大值作为答案。

摘要由CSDN通过智能技术生成

leetcode213. 打家劫舍 II

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/house-robber-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 = [1,2,3]
输出：3

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

递归 + 缓存

解题思路

因为是环形的。所以就有两种情况。
选择第一个房间时，最后一个是无法选择的，
不选择第一个房间时，最后一个房间是可以作为备选的，
两种情况分开讨论，选择最大的。
这是整体情况。
具体递归时：
每到一个房间有两个选择。偷或者不偷
偷的情况：
那么下一间就不能偷了，要去下下一间去偷。
不偷的情况：
可以去下一间继续做选择。

代码演示

/**
* 主方法调用
*/
public int rob(int[] nums) {
		
        if(nums.length == 1){
            return nums[0];
        }
        //两个或者三个房间时，因为环形只能选一个，所以选最大值就行了
          if(nums.length <= 3 ){
            Arrays.sort(nums);
            return nums[nums.length - 1];
        }
		//缓存表，第一个房间不选时的缓存表
        int[]ans =  new int[nums.length + 1];
        Arrays.fill(ans,-1);
        //缓存表，第一个房间选时的缓存表
        int[]ans2 =  new int[nums.length + 1];
        Arrays.fill(ans2,-1);
        //第一个房间不选时，最后一个房间可以选，
        //所以结束位置nums.length - 1 ，起始位置1 
        int p1 = process(nums,1,nums.length - 1,ans);
         //第一个房间选择时，最后一个房间不可以选，
        //所以结束位置nums.length - 2 ，
        int p2 = nums[0] + process(nums,2,nums.length - 2,ans2);
        //选出最大值
        return Math.max(p1,p2);
    }

		/**
		* 递归加缓存
		* index 小偷来到的房间下标
		* end 结束位置
		* ans 缓存
		*/
      public int process(int[]nums,int index,int end,int[]ans){
        //base case 越界时，返回0
        if(index > end){
            return 0;
        }
        //缓存中有数据直接从缓存中拿。
        if(ans[index] != -1){
            return ans[index];
        }
        //选择不偷当前房间时，去下一间继续做选择
        int p1 = process(nums,index + 1,end,ans);
        //选择当前房间时，下一间就不能选了，要去下下一间去选择，所以 index + 2
        int p2 = process(nums,index + 2,end,ans);
        //因为偷当前房间，所以当前房间的值 加上后序结果，
        p2 += nums[index];
        //取最大值
        int aos =  Math.max(p1,p2);
        //结果放进缓存中
        ans[index] = aos;
        return aos;

    }