題目：
你是一個專業的小偷，計劃偷竊沿街的房屋，每間房內都藏有一定的現金。這個地方所有的房屋都圍成一圈，這意味著第一個房屋和最后一個房屋是緊挨著的。同時，相鄰的房屋裝有相互連通的防盜系統，如果兩間相鄰的房屋在同一晚上被小偷闖入，系統會自動報警。

給定一個代表每個房屋存放金額的非負整數數組，計算你在不觸動警報裝置的情況下，能夠偷竊到的最高金額。

示例 1:

輸入: [2,3,2]
輸出: 3
解釋: 你不能先偷竊 1 號房屋（金額 = 2），然后偷竊 3 號房屋（金額 = 2）, 因為他們是相鄰的。

示例 2:

輸入: [1,2,3,1]
輸出: 4
解釋: 你可以先偷竊 1 號房屋（金額 = 1），然后偷竊 3 號房屋（金額 = 3）。
     偷竊到的最高金額 = 1 + 3 = 4 。

鏈接：https://leetcode-cn.com/problems/house-robber-ii

思路：
1、環形打家劫舍相當于 找[0:n-1]、[1:n]房屋劫舍的最大值
2、對于對列式打家劫舍，采用動態規劃的解法，轉移方程 dp[n] = max(dp[n-2]+nums[n], dp[n-1])

Python代碼:

class Solution(object):

    def sub_rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        dp = []
        if len(nums)==0:
            return 0
        elif len(nums)==1:
            return nums[0]
        elif len(nums)==2:
            return max(nums)
        
        dp.append(nums[0])
        dp.append(max(nums[:2]))

        for i in range(2, len(nums)):
            mmax = max(dp[i-2]+nums[i], dp[i-1])
            dp.append(mmax)
        return dp[-1]
        

    def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        # 環形打家劫舍相當于 找[0:n-1]、[1:n]房屋劫舍的最大值
        size = len(nums)
        if size==0:
            return 0
        elif size==1:
            return nums[0]
        elif size==2:
            return max(nums)
        
        return max(self.sub_rob(nums[:size-1]), self.sub_rob(nums[1:size]))

C++代碼：

class Solution {
public:
    int sub_rob(vector<int>& ls){
        int size=ls.size();
        if (size==0) return 0;
        if (size==1) return ls[0];
        if (size==2) return max(ls[0],ls[1]);

        vector<int> dp;
        dp.push_back(ls[0]);
        dp.push_back(max(ls[0], ls[1]));
        for (int i=2; i<size; i++){
            int mmax = max(dp[i-2]+ls[i], dp[i-1]);
            dp.push_back(mmax);
        }
        return dp[dp.size()-1];
    }

    int rob(vector<int>& nums) {
        int size = nums.size();
        if (size==0) return 0;
        if (size==1) return nums[0];
        if (size==2) return max(nums[0], nums[1]);

        vector<int> nums_a(nums.begin(), nums.begin()+size-1);
        vector<int> nums_b(nums.begin()+1, nums.begin()+size);
        return max(sub_rob(nums_a), sub_rob(nums_b));
    }
};