0337打家劫舍III Marathon

在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。

计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

示例 1:

输入: [3,2,3,null,3,null,1]

输出: 7
解释: 小偷一晚能够盗取的最高金额 = 3 + 3 + 1 = 7.
示例 2:

输入: [3,4,5,1,3,null,1]

输出: 9
解释: 小偷一晚能够盗取的最高金额 = 4 + 5 = 9.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/house-robber-iii

参考：

• https://leetcode-cn.com/problems/house-robber-iii/solution/dai-ma-sui-xiang-lu-337-da-jia-jie-she-i-j60v/

python

# 0337.打家劫舍III

class Solution:
    memory = {}
    def rob(self, root: TreeNode) -> int:
        """
        暴力递归， O(2^n)
        :param root:
        :return:
        """
        if root is None: return 0
        if root.left is None and root.right is None:
            return root.val
        # 偷父节点
        val_1 = root.val
        if root.left:
            val_1 += self.rob(root.left.left) + self.rob(root.left.right)
        if root.right:
            val_1 += self.rob(root.right.left) + self.rob(root.right.right)
        # 不偷父节点
        val_2 = self.rob(root.left) + self.rob(root.right)
        return max(val_1, val_2)

    def rob1(self, root: TreeNode) -> int:
        """
        记忆化递归
        :param root:
        :return:
        """
        if not root: return 0
        if not root.left and not root.right:
            return root.val
        if self.memory.get(root) is not None:
            return self.memory[root]
        # 偷父节点
        val_1 = root.val
        if root.left:
            val_1 += self.rob1(root.left.left) + self.rob1(root.left.right)
        if root.right:
            val_1 += self.rob1(root.right.left) + self.rob1(root.right.right)
        # 不偷父节点
        val_2 = self.rob1(root.left) + self.rob1(root.right)
        self.memory[root] = max(val_1,val_2)
        return max(val_1, val_2)


    def rob(self, root: TreeNode) -> int:
        """
        动态规划-时间O(n)
        :param root:
        :return:
        """

        def rob_tree(root):
            if not root:
                return (0,0) # (偷当前节点金额， 不偷当前节点金额)
            left = rob_tree(root.left)
            right = rob_tree(root.right)
            val_1 = root.val + left[1] + right[1] # 偷当前节点
            val_2 = max(left[0], left[1]) + max(right[0], right[1]) # 不偷当前节点，考虑子节点
            return (val_1, val_2)

        result = rob_tree(root)
        return max(result[0], result[1])

golang

package dynamicPrograming

import "leetcode200/binaryTree"

// 动态规划-打家劫舍III
func rob3(root *binaryTree.TreeNode) int {
	var postorder func(node *binaryTree.TreeNode) []int
	postorder = func(node *binaryTree.TreeNode) []int {
		if node == nil {
			return []int{0, 0}
		}
		left := postorder(node.Left)
		right := postorder(node.Right)
		val_1 := node.Val + left[1] + right[1]
		val_2 := max(left[0], left[1]) + max(right[0], right[1])
		return []int{val_1, val_2}
	}
	result := postorder(root)
	return max(result[0], result[1])
}

func max(a,b int) int {
	if a > b {
		return a
	}
	return b
}