动态规划之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]