leetcode 198 / 213 打家劫舍 / 打家劫舍II

题干1：
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

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

示例 1：

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
     偷窃到的最高金额 = 1 + 3 = 4 。
     
示例 2：

输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
     偷窃到的最高金额 = 2 + 9 + 1 = 12 。

解题思路：
由于只能隔一间屋子抢一次，因此，想要抢到最高金额，只需要对比抢到最后一间屋子和倒数第二间屋子时，总金额哪个更大即可，使用动态规划。
1.状态定义
dp[ i ]是抢到第i间屋子时抢到的总数
2.状态转移方程
dp[ i ] = max(dp[ i - 1 ], dp[ i - 2 ] + nums[i])
3.边界条件
dp[ 0 ] = nums[ 0 ];
dp[ 1 ] = max(nums[ 0 ], nums[ 1 ]);

代码实现：

#define MAX(a, b) (a > b) ? a : b
int rob(int* nums, int numsSize)
{
    if (numsSize == 0 || nums == NULL)
    {
        return 0;
    }
    if (numsSize == 1)
    {
        return nums[0];
    }
	int* dp = (int*)malloc(sizeof(int) * numsSize);
	int i;
	dp[0] = nums[0];
	dp[1] = MAX(nums[0], nums[1]);
	for (i = 2; i < numsSize; i++)
	{
		dp[i] = MAX(dp[i - 1], dp[i - 2] + nums[i]);
	}
	return dp[i - 1];
}

题目二：

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

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

示例 1:

输入: [2,3,2]
输出: 3
解释: 你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

示例 2:

输入: [1,2,3,1]
输出: 4
解释: 你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
     偷窃到的最高金额 = 1 + 3 = 4 。

解题思路：
这道题与上一道题的区别在于，首位相连，意味着，如果从第一家开始抢劫，那么就不能抢劫最后一家，如果从第二家开始抢劫，那么就可以抢最后一家。
因此，动态规划的范围需要做出改变：
1.抢劫了第一家，那么此时范围为[ 0 , numsSize - 2];
2.抢劫了第二家，此时的范围为[ 1 , numsSize - 1];

代码实现：

#define MAX(a, b) (a > b) ? a : b
int rob(int* nums, int numsSize)
{
    if (numsSize == 0 || nums == NULL)
    {
        return 0;
    }
    if (numsSize == 1)
    {
        return nums[0];
    }
	int* dp1 = (int*)malloc(sizeof(int) * numsSize);
	int* dp2 = (int*)malloc(sizeof(int) * numsSize);
	int i;
	dp1[0] = nums[0];
	dp1[1] = MAX(nums[0], nums[1]);
	dp2[0] = 0;
	dp2[1] = MAX(0, nums[1]);
	for (i = 2; i < numsSize; i++)
	{
		dp1[i] = MAX(dp1[i - 1], dp1[i - 2] + nums[i]);
		dp2[i] = MAX(dp2[i - 1], dp2[i - 2] + nums[i]);
	}
	return MAX(dp1[i - 2], dp2[i - 1]);
}