代码随想录算法训练营第四十七天｜198.打家劫舍， 213.打家劫舍II ， 337.打家劫舍III

198.打家劫舍

https://leetcode.com/problems/house-robber/description/

思路： 经典的动态规划问题，首先确定dp 数组记录的是打劫到第i家时的收获， dp[0] = 0， dp[1] = values[0]. 然后到第i 家有两个选择， 一个是打劫第i家， 最大收益是dp[i-2] + values[i-1], 或者不打劫第i 家最大收益是 dp[i-1]。  所以递归方程是 dp[i] = max(dp[i-1], dp[i-2]+nums[i-1])

难点： 无

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

213.打家劫舍II 

https://leetcode.com/problems/house-robber-ii/description/

思路： 和上一题类似， 只不过是原本在一条线上的房子变成首位相连了， 也就是说如果打劫了第一家就不能打劫最后一家， 打劫了最后一家就不能打劫第一家。 那么我们分别考虑 打劫nums[1:] 和nums[0:len(nums)-1] ， 然后两者取最大值就可以了。

难点： 无

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

337.打家劫舍III

思路： 这个问题把二叉树和动态规划结合了起来， 感觉有难度的。如果不考虑用动态规划， 如果打劫了一个 node， 那么就不能打劫 node.left, node.right 那么它的最大就是 node.val + rob(node.left.left) + rob(node.left.right)  + rob(node.right.right) + rob(node.right.left) 如果有。 如果不打劫node， 最大收益就是 rob(node.left) + rob(node.right). 而结合了动态规划就比较巧妙了， 我们通过倒叙遍历的方法， 先遍历一个node 的左右两边， 返回一个 tuple， tuple[0] 表示不打劫这个node 的收益， tuple[1] 表示打劫这个node 的最大收益， 如果node==NULL， 返回(0, 0).

然后回到当前node， 打劫它的最大收益是val_1 = node.val + left_val[0] + right_val[0], 不打劫的话是 val_0 = left_val[1] + right_val[1], 然后返回 (val_0, val_1)

难点： 结合点其实很难想到的， 它要返回两个状态的值。 我记得sell stock 类型的问题也有累似的方法。

# 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 transverse(self, node):
        if not node:
            return (0, 0)
        left_ans = self.transverse(node.left)
        right_ans = self.transverse(node.right)
        
        val_0 = max(left_ans[0], left_ans[1]) + max(right_ans[0], right_ans[1]) # 不偷当前节点， 偷左右
        val_1 = node.val + left_ans[0] + right_ans[0] # 偷当前，不偷左右
        return (val_0, val_1)

    def rob(self, root: Optional[TreeNode]) -> int:
        _ans = self.transverse(root)
        return max(_ans)