动态规划之Leetcode 198 213

Leetcode上面的打家劫舍和打家劫舍 Ⅱ是非常典型的DP题目。

Leetcode 198

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

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

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

首先找出递推关系

对于每个房屋的arr[]
一间屋 返回arr[0]
两间屋 返回max(arr[0],arr[1])
屋子数量大于三时:

1. 如果最后一间房屋(arr[-1])不偷，那么可以得到的最大金额为前len(arr)-1个arr[]可以偷窃的最大金额.
2. 如果最后一间房屋偷，那么最大的金额为前len(arr)-2个arr[]可以获取的金额 + arr[-1]偷窃的金额.

为了降低代码时间复杂度，使用数组记忆大小为1->numsSize时的子问题的结果，用于计算父问题。

代码实现为:

int rob(int *nums, int numsSize)
{
    if (numsSize <= 0) {
        return 0;
    }
    if (numsSize == 1) {
        return nums[0];
    }
    int arr[1000];
    arr[0] = nums[0];
    arr[1] = nums[1] > nums[0] ? nums[1] : nums[0];
    int a = nums[2] + arr[0];
    int b = nums[1];
    arr[2] = a > b ? a : b;
    for (int i = 3; i < numsSize; i++) {
        int x = nums[i] + arr[i - 2];
        int y = nums[i - 1] + arr[i - 3];
        arr[i] = x > y ? x : y;
    }
    
    return arr[numsSize - 1];
}

Leetcode 213

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

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

示例 1:

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

示例 2:

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

偷窃到的最高金额 = 1 + 3 = 4 。

这道题相对于上一题稍有变化，主要是因为圆形的房屋排布的原因，第一与最后一个房屋不能同时偷窃，所以第一和最后一个房屋不能同时出现，所以分为两种情况:

1. 偷第一个，则最后一个不能偷，即[:-1]的情况。
2. 不偷第一个，则最后一个可以偷,即[1:]的情况。

class Solution:
    def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 0:
            return 0
        if len(nums) == 1:
            return nums[0]

        return max(self.subrob(nums[1:]), self.subrob(nums[:-1]))

    def subrob(self, nums):
        # for i in nums
        n = len(nums)

        ll = [0 for i in range(n)]  # 创建数组
        if n == 0:
            return 0
        if n == 1:
            return nums[0]
        ll[0] = nums[0]
        ll[1] = max(nums[0], nums[1])
        for i in range(2, n):
            ll[i] = max(ll[i - 2] + nums[i], ll[i - 1])
        return ll[n - 1]