***[Lintcode]House Robber II

最新推荐文章于 2018-10-10 15:59:29 发布

原创最新推荐文章于 2018-10-10 15:59:29 发布 · 236 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#lintcode

算法专栏收录该内容

191 篇文章

订阅专栏

解决环形排列房屋的抢劫问题，确保不会同时抢劫相邻房屋，采用动态规划算法找到最大收益。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

After robbing those houses on that street, the thief has found himself a new place for his thievery so that he will not get too much attention. This time, all houses at this place are arranged in a circle. That means the first house is the neighbor of the last one. Meanwhile, the security system for these houses remain the same as for those in the previous street.

Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.

首先想到使用另外一个数组记录当前最高纪录是否包括了第一个House。在抢最后一家时，判断如果抢了第一家，则放弃最后一家。算法如下：

public class Solution {
    /**
     * @param nums: An array of non-negative integers.
     * return: The maximum amount of money you can rob tonight
     */
    public int houseRobber2(int[] nums) {
        int[] res = new int[nums.length];
        boolean[] includeFirst = new boolean[nums.length];

        if(nums.length == 0) return 0;
        if(nums.length == 1) return nums[0];
        if(nums.length == 2) {
            return Math.max(nums[0], nums[1]);
        }
        
        res[0] = nums[0];
        res[1] = Math.max(nums[0], nums[1]);
        
        includeFirst[0] = true;
        includeFirst[1] =  nums[0] > nums[1];

        for(int i = 2; i < nums.length; i++) {
            if(i == nums.length - 1) {
                if(includeFirst[i - 2]) {
                    res[i] = Math.max(res[i - 1], nums[i]);
                } else {
                    res[i] = Math.max(res[i - 2] + nums[i], res[i - 1]);
                }
            } else {
                res[i] = Math.max(res[i - 2] + nums[i], res[i - 1]);
                includeFirst[i] = res[i - 2] + nums[i] > res[i - 1] ?
                    includeFirst[i - 2] : includeFirst[i - 1];
            }
        }
        return res[nums.length - 1];
    }
}

但是这个算法忽略了一种情况，即最佳方案必须包括最后一个House。极端情况可以假设最后一个House为正无穷。如果不算入最后一个House，其他方案都不是最佳的。第二种算法，分别调用两次House Robber I的算法，第一次包含第一个House，不包括最后一个。第二次反之。求Max

public class Solution {  

    public int rob(int[] nums) {  
        if(nums==null || nums.length==0) return 0;  
        if(nums.length==1) return nums[0];  
        if(nums.length==2) return Math.max(nums[0], nums[1]);  
        return Math.max(robsub(nums, 0, nums.length-2), robsub(nums, 1, nums.length-1));  
    }  
      
    private int robsub(int[] nums, int s, int e) {  
        int n = e - s + 1;  
        int[] d =new int[n];  
        d[0] = nums[s];  
        d[1] = Math.max(nums[s], nums[s+1]);  
          
        for(int i=2; i<n; i++) {  
            d[i] = Math.max(d[i-2]+nums[s+i], d[i-1]);  
        }  
        return d[n-1];  
    }  
}