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:
        if not root:
            return 0
        deque = [root]
        length = len(deque)
        res = []
        while length!=0:
            sum = 0
            for _ in range(length):
                root = deque.pop(0)
                sum+=root.val
                if root.left:
                    deque.append(root.left)
                if root.right:
                    deque.append(root.right)
            res.append(sum)
            length = len(deque)
        cur,pre = 0,0
        for num in res:
            cur,pre = max(pre+num,cur),cur
        return cur

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

class Solution:
    
    def dp(self , cur : TreeNode) -> List[int] :
        
        
        if not cur :
            return [0,0]
        
        l = self.dp(cur.left)
        r = self.dp(cur.right)
        
        #       根节点没偷     根节点偷了
        return [max(l)+max(r),cur.val+l[0]+r[0]]
    def rob(self, root: TreeNode) -> int:
        return max(self.dp(root))
        
        

       用递归的中序遍历，父节点偷子节点就不能偷，所以金额就直接加上父节点的金额。父节点不偷，金额就得加上左子树的最大金额与右子树的最大金额之和。