【举一反三】力扣刷题-打家劫舍（Python 实现）

题目快速通道

打家劫舍
打家劫舍II
打家劫舍III

1、打家劫舍

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/house-robber
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

理解

题目的意思就是一列数组，计算这个数组中数据总和的最大值（不能取连续的两个值）

解题

该题是非常经典的动态规划题型（也可说贪心算法），比如我现在是数组的第六个位置，那我只需要取出 max(第五个位置最大值，第四个位置最大值 + 当前位置），根据思路，很容易编写迭代的写法：

class Solution:
    def rob(self, nums: List[int]) -> int:
        # 试一下用迭代做
        def trackback(n):
            if n < 0:
                return 0,0
            add, notadd = trackback(n - 1)
            return notadd + nums[n],max(add, notadd)
        n = len(nums)
        add, notadd = trackback(n-1)
        return max(add, notadd)

稍微再深入思考下，可以尝试用贪心的方式写，我们可以构建相同长度的数组 dp，用来存储每个位置的最大值

class Solution:
    def rob(self, nums: List[int]) -> int:
        # 空间复杂度n
        n = len(nums)
        if n == 1:
            return nums[0]
        dp = [0] * n
        dp[0] = nums[0]
        dp[1] = max(nums[0], nums[1])
        for i in range(2,n):
            dp[i] = max(dp[i-1], dp[i-2] + nums[i])
        return dp[n-1]

仔细思考上述代码，发现每次循环只是用到了前两次的值，可以尝试用两个变量进行记录，优化一下代码

class Solution:
    def rob(self, nums: List[int]) -> int:
        # 空间复杂度 n(1)
        n = len(nums)
        if n == 1:
            return nums[0]
        pre = nums[0]
        cur = max(nums[0], nums[1])
        for idx in range(2,n):
            pre, cur = cur, max(pre + nums[idx], cur)
        return cur

终极写法

class Solution:
    def rob(self, nums: List[int]) -> int:
        pren = 0
        curn = 0

        for k in nums:
            pren,curn = curn ,max(curn, pren+k)
        return curn

2、打家劫舍II

该题对打家劫舍进行了一些升级，本来是数组，现在是环形了，也就是说不能同时去sum[0] 和 sum[n-1]，很容易就想到分别求第一家到倒数第二家 和 第二家到倒数第一家，取最大即可，逻辑跟第一题一样。

class Solution:
    def rob(self, nums: List[int]) -> int:
        # 考虑到是环形，分两种情况，(0,n-2) 和 (1,n-1)
        # 先编写一个函数，用于计算(start, end) 的最大值
        def getMaxSum(start, end):
            pre = nums[start]
            cur = max(nums[start], nums[start+1])
            for idx in range(start+2, end):
                pre, cur = cur, max(pre + nums[idx], cur)
            return cur
        
        # 开始
        n = len(nums)
        if n == 1:
            return nums[0]
        elif n == 2:
            return max(nums[0], nums[1])
        else:
            return max(getMaxSum(0,n-1), getMaxSum(1,n))

3、打家劫舍III

该题相对于前面两题变成了二叉树的形式，思考一下该题，必然是需要用到节点与子节点的关系，很显然需要用到后序遍历，使用迭代的方法，参考第一题最开始的迭代思想

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def rob(self, root: TreeNode) -> int:
        # 后序遍历
        def robback(node):
            if not node:
                return 0,0
            ladd, lnotadd = robback(node.left)
            radd, rnotadd = robback(node.right)
            return lnotadd + rnotadd + node.val, max(ladd, lnotadd) + max(radd, rnotadd)
        add,notadd = robback(root)
        return max(add,notadd)