打劫三部曲-II

我们在上一阶段顺利的完成了零元大抢购，现在开始向富人区进军，那啥啥之下没有人是无辜的，但是富人区的安保果然是升过级的，警报系统首尾相连。嗯，果然是有点挑战。

https://www.lintcode.com/problem/house-robber-ii/

纵横江湖多年，刷题无数，这点问题还能难倒了？与前面的挑战相比，根本就是换汤不换药，继续动态规划走起。其实技巧在于：

1. 如果抢了第1家，那么最后一家一定不能抢。
2. 如果不抢第1家，那么最后一家可以抢（但是不一定非要抢）。

现在就把问题等价成2个与第一题一样结构的问题：1）从第1家抢到倒数第2家；2）从第2家抢到最后一家。取比较大的结果。不过与第一题相比，没法做得那么紧凑，得开2个数组保存动态规划的中间状态。嗯，毕竟来富人区吃自助，也得有点成本。

实现代码如下：

# Python
class Solution:
    """
    @param nums: An array of non-negative integers.
    @return: The maximum amount of money you can rob tonight
    """
    def houseRobber2(self, nums):
        # write your code here
        if (not nums) or (len(nums) == 2):
            return 0
        if len(nums) == 1:
            return nums[0]
        dp_1 = [0] * (len(nums) - 1) # 0到倒数第2间
        dp_2 = [0] * (len(nums) - 1) # 1到最后一间
        for i in range(0, len(nums) - 1):
            if i == 0:
                dp_1[i] = nums[0]
            if i == 1:
                dp_1[i] = max(nums[0], nums[1])
            if i > 1:
                dp_1[i] = max(dp_1[i - 2] + nums[i], dp_1[i - 1])
        for i in range(1, len(nums)):
            if i == 1:
                dp_2[i - 1] = nums[1]
            if i == 2:
                dp_2[i - 1] = max(nums[1], nums[2])
            if i > 2:
                dp_2[i - 1] = max(dp_2[i - 3] + nums[i], dp_2[i - 2])
        return max(dp_1[-1], dp_2[-1])

// Java
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) {
        // write your code here
        if ((nums.length == 0) || (nums.length == 2)) {
            return 0;
        }
        if (nums.length == 1) {
            return nums[0];
        }
        int[] dp1 = new int[nums.length - 1]; // # 0到倒数第2间
        int[] dp2 = new int[nums.length - 1]; // # 1到最后一间
        for (int i = 0; i < nums.length - 1; ++i) {
            if (i == 0) {
                dp1[i] = nums[0];
            } else if (i == 1) {
                dp1[i] = Math.max(nums[0], nums[1]);
            } else {
                dp1[i] = Math.max(dp1[i - 2] + nums[i], dp1[i - 1]);
            }
        }
        for (int i = 1; i < nums.length; ++i) {
            if (i == 1) {
                dp2[i - 1] = nums[1];
            } else if (i == 2) {
                dp2[i - 1] = Math.max(nums[1], nums[2]);
            } else {
                dp2[i - 1] = Math.max(dp2[i - 3] + nums[i], dp2[i - 2]);
            }
        }
        return Math.max(dp1[dp1.length - 1], dp2[dp2.length - 1]);
    }
}

OK，愉快的通过了测试，开始欢乐自助！