抢劫问题（第一个和最后一个房子只能包含一个）House Robber II

为什么80%的码农都做不了架构师？>>>   

问题：

Note: This is an extension of House Robber.

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 Robber的延伸。 这里有两种情况1）包含第一个元素，最后不包含2）第一个不包含，最后包含。这是因为首尾相连，如果第一个和最后一个都包含了，会触发报警系统。 因此，我们可以使用类似的动态规划方法对数组进行两次扫描，得到较大的值。注意，要先讨论当原数组位数小于2时的情况。

class Solution {//1ms
    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]);
        }
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        dp[1] = Math.max(nums[0],nums[1]);
        for (int i = 2;i <= nums.length - 2;i ++ ) {
            dp[i] = Math.max(dp[i - 1],dp[i - 2] + nums[i]);
        }
        int res = dp[nums.length - 2];
        dp[1] = nums[1];
        dp[2] = Math.max(nums[1],nums[2]);
        for (int i = 3;i <= nums.length - 1 ;i ++ ) {
            dp[i] = Math.max(dp[i - 1],dp[i - 2] + nums[i]);
        }
        return Math.max(res,dp[nums.length - 1]);
    }
}

class Solution {//1ms
    public int rob(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        if (nums.length == 1) {
            return nums[0];
        }
        int max1 = rob(nums,0,nums.length - 2);
        int max2 = rob(nums,1,nums.length - 1);
        return Math.max(max1,max2);
    }
    public int rob(int[] nums,int i ,int j){
        if (i == j) {
            return nums[i];
        }
        int[] dp = new int[nums.length];
        dp[i] = nums[i];
        dp[i + 1] = Math.max(nums[i + 1],dp[i]);
        for (int k = i + 2;k <= j ;k ++ ) {
            dp[k] = Math.max(dp[k - 1],dp[k - 2] + nums[k]);
        }
        return dp[j];
    }
}

② 使用2个变量。

class Solution {//1ms
    public int rob(int[] nums) {
        if (nums.length == 1) {
            return nums[0];
        }
        return Math.max(rob(nums,0,nums.length - 2),rob(nums,1,nums.length - 1));
    }
    public int rob(int[] nums,int i,int j){
        int curYes = 0;
        int curNo = 0;
        for (int k = i;k <= j ;k ++ ) {
            int preYes = curYes;
            int preNo = curNo;
            curYes = preNo + nums[k];
            curNo = Math.max(preYes,preNo);
        }
        return Math.max(curYes,curNo);
    }
}

转载于:https://my.oschina.net/liyurong/blog/1575529