問題描述

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

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

提示：

• 1 <= nums.length <= 100
• 0 <= nums[i] <= 1000

示例

示例 1：

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

示例 2：

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

示例 3：

輸入：nums = [1,2,3]
輸出：3

解題思路

這是一個簡單的動態規劃問題，其中一個複雜的點是所有房屋圍成了一圈，不能同時選第一和最後的房子，如何保證這一點呢？如果我們按常規的動態規劃思路來解，我們就要記錄之前的狀態是否選擇了第一間房子，這增加了程式碼的複雜性。

另一個思路是，直接執行兩次動態規劃，第一次可選房子的範圍是[0, n - 2]，第二次可選房子的範圍是[1, n - 1]。這樣就保證了第一和最後一間房子不會同時被選中。

接著就是常規的動態規劃問題，狀態轉移方程為：

dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])

邊界條件為：

dp[i] = nums[0], 當nums.size() == 1 時
dp[i] = max(nums[1], nums[2]), 當nums.size() == 2 時

程式碼如下：

class Solution {
public:

    int robRange(vector<int>& nums, int start, int end){
        if(start == end){
            return nums[start];
        }
        int a = nums[start];
        int b = max(nums[start], nums[start + 1]);
        int maxProfit = b;
        int cnt = 0;
        for(int i = start + 2; i <= end; i++){ // 動態規劃
            if(cnt & 1){
                maxProfit = max(b + nums[i], a);
                b = maxProfit;
            }
            else{
                maxProfit = max(a + nums[i], b);
                a = maxProfit;
            }
            cnt ^= 1;
        }
        return maxProfit;
    }

    int rob(vector<int>& nums) {
        const int n = nums.size();
        if(n == 1){ // 邊界條件
            return nums[0];
        }
        else if(n == 2){ // 邊界條件
            return max(nums[0], nums[1]);
        }
        else{ // 進行兩次動態規劃，選擇其中最大值
            return max(robRange(nums, 0, n - 2), robRange(nums, 1, n - 1));
        }
    }
};