LeetCode-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 = [0]
输出：0
 

提示：

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

 

成环的情况，考虑：

0~n-1 和 1~n 两种情况。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;


/*
  动态转移方程：dp[i] = max(dp[i-2]+num[i],dp[i-1]);
  边界值：
  (1) 0 <= i <= n-1  (n = nums.size()-1)
  (1) 1 <= i <= n    (n = nums.size()-1)
  成环的情况，考虑0~n-1和 1到n两种情况，
  再选取这两种方案的最大值即可.
*/


class Solution {
public:
	int rob(vector<int>& nums) {
		vector<int> dp1(nums.size(), 0);
		vector<int> dp2(nums.size(), 0);

		if (nums.size() < 2) {
			return nums[0];
		}

		/* 从0到num.size()-2，从0开始算起 */
		dp1[0] = nums[0];
		dp1[1] = max(nums[0], nums[1]);

		if (nums.size() == 2) {
			return dp1[1];
		}


		/* 从1到num.size()-1，从1开始算起 */
		dp2[1] = nums[1];
		dp2[2] = max(nums[1], nums[2]);


		for (int i = 2; i < nums.size() - 1; i++) {
			dp1[i] = max(dp1[i - 2] + nums[i], dp1[i - 1]);
		}

		for (int i = 3; i < nums.size(); i++) {
			dp2[i] = max(dp2[i - 2] + nums[i], dp2[i - 1]);
		}

		return max(dp1[nums.size() - 2], dp2[nums.size() - 1]);
	}
};

int main() {
	vector<int> v = { 1,2,3,1 };
	//vector<int> v1 = { 2,1,1,2 };

	Solution* ps = new Solution();
	cout << ps->rob(v) << endl;
	system("pause");
	return 0;
}