198.打家劫舍 

213.打家劫舍II  

337.打家劫舍III

198.打家劫舍

class Solution:
    def rob(self, nums: List[int]) -> int:
        n = len(nums)
        if n == 0:
            return  0
        dp = [0 for _ in range(n+1)]
        dp[1] = nums[0]
        for i in range(2, n+1):
            dp[i] = max(dp[i-1], dp[i-2]+nums[i-1])
        return dp[n]

213.打家劫舍II

有环的问题

考虑有第一个和无第一个

class Solution:
    def rob(self, nums: List[int]) -> int:
        n = len(nums)
        if n == 1:
            return nums[0]

        dp1 = [0 for _ in range(n+1)]
        dp1[1] = nums[0]
        for i in range(2, n):
            dp1[i] = max(dp1[i-1], dp1[i-2]+nums[i-1])
        
        dp2 = [0 for _ in range(n+1)]
        for i in range(2, n+1):
            dp2[i] = max(dp2[i-1], dp2[i-2]+nums[i-1])
        
        return max(dp1[n-1], dp2[n])

337.打家劫舍 III

这道题目算是树形dp的入门题目，因为是在树上进行状态转移，我们在讲解二叉树的时候说过递归三部曲，那么下面我以递归三部曲为框架，其中融合动规五部曲的内容来进行讲解。

1. 确定递归函数的参数和返回值

　　　　这里我们要求一个节点 偷与不偷的两个状态所得到的金钱，那么返回值就是一个长度为2的数组。

　　　　其实这里的返回数组就是dp数组。

　　　　所以dp数组（dp table）以及下标的含义：下标为0记录不偷该节点所得到的的最大金钱，下标为1记录偷该节点所得到的的最大金钱。

2. 确定终止条件

　　　　在遍历的过程中，如果遇到空节点的话，很明显，无论偷还是不偷都是0，所以就返回

3. 确定遍历顺序

　　　　首先明确的是使用后序遍历。 因为要通过递归函数的返回值来做下一步计算。

　　　　通过递归左节点，得到左节点偷与不偷的金钱。

　　　　通过递归右节点，得到右节点偷与不偷的金钱。

4. 确定单层递归的逻辑

　　　　如果是偷当前节点，那么左右孩子就不能偷，val1 = cur->val + left[0] + right[0]; （如果对下标含义不理解就再回顾一下dp数组的含义）

　　　　如果不偷当前节点，那么左右孩子就可以偷，至于到底偷不偷一定是选一个最大的，所以：val2 = max(left[0], left[1]) + max(right[0], right[1]);

　　　　最后当前节点的状态就是{val2, val1}; 即：{不偷当前节点得到的最大金钱，偷当前节点得到的最大金钱

5. 举例推导dp数组

　　　　以示例1为例，dp数组状态如下：（注意用后序遍历的方式推导）

# 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: Optional[TreeNode]) -> int:
        # dp数组（dp table）以及下标的含义：
        # 1. 下标为 0 记录 **不偷该节点** 所得到的的最大金钱
        # 2. 下标为 1 记录 **偷该节点** 所得到的的最大金钱
        dp = self.traversal(root)
        return max(dp)

    # 要用后序遍历, 因为要通过递归函数的返回值来做下一步计算
    def traversal(self, node):
        
        # 递归终止条件，就是遇到了空节点，那肯定是不偷的
        if not node:
            return (0, 0)

        left = self.traversal(node.left)
        right = self.traversal(node.right)

        # 不偷当前节点, 偷子节点
        val_0 = max(left[0], left[1]) + max(right[0], right[1])

        # 偷当前节点, 不偷子节点
        val_1 = node.val + left[0] + right[0]

        return (val_0, val_1)