213. 打家劫舍 II

題目連結：213. 打家劫舍 II(中等)

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

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

示例 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

提示：

• 1 <= nums.length <= 100

• 0 <= nums[i] <= 1000

解題思路

該題與198. 打家劫舍 差不多，只是所有的房屋都 圍成一圈了。

具體可以分成兩種情況，具體如程式碼中的註釋。

C++

class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 0) return 0;
        if (nums.size() == 1) return nums[0
 
];
        if (nums.size() == 2) return max(nums[0], nums[1]);
        // 情況一：不偷最後一個房間(下標為nums.size()-1)，那第一個房間（下標為0）可偷可不偷(具體交給遞迴演算法)
        int result1 = robfun(nums, 0, nums.size() - 2);
        // 情況二：不偷第一個房間（下標為0），那最後一個房間(下標為nums.size()-1)可偷可不偷(具體交給遞迴演算法)
        int result2 = robfun(nums, 1, nums.size() - 1
 
);
        // 最後取兩種情況的最大值
        return max(result1, result2);
    }
​
    // 該演算法與 198. 打家劫舍 一樣
    int robfun(vector<int> nums, int start, int end) {
//        說明：被註釋的寫法和沒有被註釋的寫法都可
//        vector<int> dp( nums.size(), 0 );
//        dp[start] = nums[start];
//        dp[start + 1] = max(nums[start], nums[start + 1]);
//        for (int i = start + 2; i <= end; i++) {
//            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
//        }
//        return dp[end];
​
        vector<int> dp((end - start) + 1, 0 );
        dp[0] = nums[start];
        dp[1] = max(nums[start], nums[start + 1]);
        for (int i = 2; i <= end - start; i++) {
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[start + i]);
        }
        return dp[end - start];
    }
};

JavaScript

/**
 * @param {number[]} nums
 * @return {number}
 */
var rob = function(nums) {
    if (nums.length === 0) return 0;
    if (nums.length === 1) return nums[0];
    if (nums.length === 2) return Math.max(nums[0], nums[1]);
    let result1 = robfun(nums, 0, nums.length - 2);
    let result2 = robfun(nums, 1, nums.length - 1);
    return Math.max(result1, result2);
};
​
/**
 * @param {number[]} nums
 * @param {number} start
 * @param {number} end
 * @return {number}
 */
var robfun = function(nums, start, end) {
    const dp = new Array(nums.length).fill(0);
    dp[start] = nums[start];
    dp[start + 1] = Math.max(nums[start], nums[start + 1]);
    for (let i = start + 2; i <= end; i++) {
        dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
    }
    return dp[end];
};