***[Lintcode]House Robber II

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