LeetCode 213. 打家劫舍 II：

213. 打家劫舍 II

  
你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

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

思路：参考 labuladong题解

时间复杂度：O(n)

空间复杂度：若需额外申请dp数组则为O(n)；若只用常量则空间则为O(1)，例如这里的first,second...

Golang版：

// 一个关键思想在于，环可以拆分成两种情况，分别取nums数组为 0 ~ nums.size()-2 或者nums为 1 ~ num.size()-1，比较两者最大结果即可。其余和之前写过的 打家劫舍I 是一样的。
func rob(nums []int) int {
	l := len(nums)
	if l == 1 {
		return nums[0]
	} else if l == 2 {
		return max(nums[0], nums[1])
	}

	// max(偷第一个不偷最后一个，偷最后一个不偷第一个)
	return max(subRob(nums, 0, l-1), subRob(nums, 1, l))
}

func subRob(nums []int, start, end int) int {
	dp := make([]int, len(nums))
	dp[start], dp[start+1] = nums[start], max(nums[start], nums[start+1])

	for i := start + 2; i < end; i++ {
		// 【上上家偷 上一家不偷 当前偷】 or 【上一家偷 当前不偷】
		dp[i] = max(dp[i-2]+nums[i], dp[i-1])
	}

	return dp[end-1]
}

// 上述方法用dp数组存储结果，考虑到每间房屋的最高总金额只和【该房屋的前两间房屋】的最高总金额相关，因此可以使用滚动数组。在每个时刻只用存储前两间房屋的最高总金额。
// 空间复杂度：O(1)，不分配额外dp数组
// func subRob(nums []int, start, end int) int {
//     first, second := nums[start], max(nums[start], nums[start+1])
//     for i := start + 2; i < end; i++ {
//         // 【上上家偷 上一家不偷 当前偷】 or 【上一家偷 当前不偷】
//         first, second = second, max(first + nums[i], second)
//     }

//     return second
// }

func max(a, b int) int {
	if a > b {
		return a
	}

	return b
}

C++版：

// dp same as leetcode:70
int rob(vector& nums) {
    int n = nums.size();
    if (n == 1)
        return nums[0];
    // max(从第0个到第n-2个, 从第1个到第n-1个) 注：下标为0~n-1
    return max(robRange(0, n - 2, nums), robRange(1, n - 1, nums));
}

int robRange(int start, int end, vector& nums)
{
    int n = nums.size();
    int dp1 = 0;    // dp[i + 1]：不抢当前，抢下一家
    int dp2 = 0;    // dp[i + 2]：抢当前，再抢下下家（因为抢当前家，故下面循环需要加nums[i]表示当前家被抢金额）
    int dpi = 0; 
    for (int i = end; i >= start; i--)
    {
        dpi = max(dp1, dp2 + nums[i]);
        dp2 = dp1;      
        dp1 = dpi;
        // dp1 = dp2;   // error:
        // dp2 = dpi;   // error：
    }
    return dpi;
}