Leetcode打家劫舍小结（Python）

打家劫舍的三个题，各有特色，第一题是比较常规的DP；第二题带环；第三题直接是一个树形，那么怎么将后两种转换成常规的DP或者说是常规的递归穷举呢，下面一起来看看吧。

198.打家劫舍
点评：本质还是穷举所有的可能结果。但是如果从头开始直接递归，会有很多重叠的子问题（想想递归树），下面提供了备忘录和DP两种方法来优化这个问题。

class Solution:
    #备忘录写法
    def rob(self, nums: List[int]) -> int:
        a = {}
        def dp(i):
            if i >= len(nums):return 0
            if i in a:return a[i]
            res = max(dp(i+2)+nums[i], dp(i+1))
            if i not in a:a[i] = res
            return res
        return dp(0)

class Solution:
    #DP写法
    def rob(self, nums: List[int]) -> int:
        N = len(nums)
        dp_1, dp_2, dp_i = 0, 0, 0
        for i in range(N-1, -1, -1):
            dp_i = max(dp_2+nums[i], dp_1)
            dp_1, dp_2 = dp_i, dp_1
        return dp_i

213.打家劫舍 II
点评：这题有环，主要思路就是考虑首尾节点的选择情况了。其他部分还是按照之前的规则。这样就得到三种可能，然后分别递归一下，求出三种情况中最大值。

class Solution:
    def rob(self, nums: List[int]) -> int:
        def dp(arr, i):
            if i >= len(arr):return 0
            if i in b:return b[i]
            res = max(dp(arr, i+2)+arr[i], dp(arr, i+1))
            b[i] = res
            return res
        if len(nums) == 1:return nums[0]
        b = {}
        res_1 = dp(nums[:-1], 0)
        b = {}
        return max(res_1, dp(nums[1:], 0)) #三种可能，一种是首尾都不选，一种是选首不选尾，一种是选尾不选首。

class Solution:
    def rob(self, nums: List[int]) -> int:
        def helper(arr):
            N = len(arr)
            dp_1, dp_2 = 0, 0
            dp_i = 0
            for i in range(N-1, -1, -1):
                dp_i = max(dp_2+arr[i], dp_1)
                dp_1, dp_2 = dp_i, dp_1
            return dp_i
        if len(nums) == 1:return nums[0]
        return max(helper(nums[:-1]), helper(nums[1:])) #三种可能，一种是首尾都不选，一种是选首不选尾，一种是选尾不选首。

337.打家劫舍 III
点评：树还是听能够唬人的，很多情况下思路被阻断了，我们思考的方向是将树的每一层看做是一个节点，这样又转换成了原始的问题。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def rob(self, root: TreeNode) -> int:
        def dp(node):
            if not node:return 0
            if node in b:return b[node]
            do_it = node.val
            do_it += ((dp(node.left.left)+dp(node.left.right)) if node.left else 0) + ((dp(node.right.left)+dp(node.right.right)) if node.right else 0)
            not_do = dp(node.left) + dp(node.right)
            res = max(do_it, not_do)
            b[node] = res
            return res
        b = {}
        return dp(root)