这是我参与2022首次更文挑战的第16天，活动详情查看：2022首次更文挑战
打家劫舍Ⅱ
你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。
示例 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
题解
算法一：动态规划（Java）
本题是打家劫舍的变形题，基本思路是一样的，唯一的区别是成环了
对于一个数组，成环的话主要有以下三种情况:
- a 不考虑首尾元素
- b 不考虑尾元素
- c 不考虑首元素 而b,c其实已经包含了a这种情况，所以只需要考虑b,c这两种情况，最后比较两种情况下的最大值，取较大值即可。
那么就有如下的状态转移方程：
边界条件为：
class Solution {
public int rob(int[] nums) {
if (nums == null || nums.length == 0) {
return 0;
}
if (nums.length < 2) {
return nums[0];
}
int first = rob2Helper(nums, 0, nums.length - 1);
int second = rob2Helper(nums, 1, nums.length);
return Math.max(first, second);
}
public int rob2Helper(int[] nums, int start, int end) {
int first = 0;
int second = 0;
for (int i = start; i < end; i++) {
int temp = second;
second = Math.max(nums[i] + first, second);
first = temp;
}
return second;
}
}
时间复杂度：O（N）
空间复杂度：O（1）
算法一：动态规划（Go）
思路同上
// rob 时间复杂度O(N),空间复杂度O(1)
func rob(nums []int)int{
maxValue := 0
n := len(nums)
switch n{
case 0:
maxValue = 0
case 1:
maxValue = nums[0]
case 2:
maxValue = Max(nums[0], nums[1])
default:
c1 := robRange(nums, 0, n-2)
c2 := robRange(nums, 1, n-1)
maxValue = Max(c1, c2)
}
return maxValue
}
func robRange(nums []int, start, end int)int{
if start == end{
return nums[start]
}
dp := make([]int, 2)
dp[0] = nums[start]
dp[1] = Max(nums[start], nums[start+1])
for i:=start+2;i<=end;i++{
newMax := Max(dp[0]+nums[i], dp[1])
dp[0] = dp[1]
dp[1] = newMax
}
return dp[1]
}
func Max(a, b int) int {
if a > b {
return a
}
return b
}
时间复杂度：O（N）
空间复杂度：O（1）
