【算法与数据结构相关】【LeetCode】【198 打家劫舍】【Python】

题目：你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

示例：

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

思路：采用递归方法，最大的结果一定从（1）偷第一个房间，然后从第三个房间开始重新考虑偷不偷的问题；（2）不偷第一个房间，然后从第二个房间开始考虑偷不偷的问题；这两者之间产生。所以可以递归地解决，注意边界条件，房间数为0时返回0，房间数为1时返回该房间的财富值。

代码：

class Solution(object):
    def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 0:
            return 0
        elif len(nums)==1:
            return nums[0]
        else:
            return max(nums[0]+self.rob(nums[2:]), self.rob(nums[1:]))

运行结果超出时间限制！！！

所以采用二分递归：将数组分为两半，最大结果一定从这三者中产生：（1）前一半中偷了最后一个房间时的最大值+后一半中没偷第一个房间时的最大值；（2）前一半中没偷最后一个房间时的最大值+后一半中偷了第一个房间时的最大值；（3）前一半中没偷最后一个房间时的最大值+后一半中没偷第一个房间时的最大值；

class Solution(object):
    def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 0:
            return 0
        elif len(nums)==1:
            return nums[0]
        else:
            mid = len(nums)//2
            x1 = self.rob(nums[:mid-2]) + nums[mid-1] + self.rob(nums[mid+1:])
            x2 = self.rob(nums[:mid-1]) + nums[mid] + self.rob(nums[mid+2:])
            x3 = self.rob(nums[:mid-1]) + self.rob(nums[mid+1])
            return max([x1, x2, x3])

结果边界条件没考虑清楚，运行不出来。

参考了别人的代码，思路跟第一种是一样的，但是不是通过递归实现的，而是通过循环，相比于递归，循环所消耗的时间和空间要小得多。所以动态规划问题中，递归和循环两种方式都要考虑！！！

class Solution(object):
    def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if nums==[]:
            return 0
        if len(nums)==1:
            return max(nums)
        dp = [0]*len(nums)
        dp[0] = nums[0]
        dp[1] = max(nums[1],nums[0])
        for i in range(2,len(nums)):
            dp[i] = max(dp[i-1],dp[i-2]+nums[i])
            
        return dp[len(nums)-1]