打家劫舍问题

198. 打家劫舍

分析：
dp[i]：前i个房间（包括房间i）可以盗窃到的最大金额
对第i个房间，可以选择不偷，也可以选择偷 两种情况取最大
①偷：获得的金额等于当前房子的金额+前i-2个房间可以得到的最大金额（不是i-1是因为相邻的不能偷）
②不偷：获得的金额等于前i-1个房子能获得的金额

递推公式： dp[i] = max(dp[i-2]+nums[i], dp[i-1])
初始化：dp[0], dp[1]
遍历顺序：从小到大

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

        dp = [0]*len(nums)
        dp[0] = nums[0]
        dp[1] = max(nums[0],nums[1])

        # 递推：
        for i in range(2,len(nums)):
            dp[i] = max(dp[i-2]+nums[i], dp[i-1])

        return dp[-1]

213. 打家劫舍 II

在Ⅰ的基础上改变：房间是环形的，首尾不能都偷
解决办法：两种方式中选最大（不考虑首元素/不考虑尾元素——转换为线性打家劫舍）

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

    # 线性的打家劫舍
    def roblist(self, nums: List[int]) -> int:
        n = len(nums)
        if n == 1:
            return nums[0]
        if n == 2:
            return max(nums[0], nums[1])

        dp = [0]*n
        dp[0] = nums[0]
        dp[1] = max(nums[0], nums[1])
        for i in range(2,n):
            dp[i] = max(dp[i-1], dp[i-2]+nums[i])
        print(dp)
        return dp[-1]

337. 打家劫舍 III

树形
需要使用递归对节点遍历——后序（当前的节点的值取决于其孩子的值）
每个节点的返回值应该是两个，偷和不偷获得的最大利益

中间节点
偷：不偷左子数根节点获得的最大金额+不偷右子数根节点获得的最大金额+根节点的值
不偷：偷/不偷左子数根节点获得的最大金额+偷/不偷右子数根节点获得的最大金额 （左右可以偷，具体偷不偷要选最大的

class Solution:
    def rob(self, root: Optional[TreeNode]) -> int:  
        result = self.Traversal(root)
        return max(result[0], result[1])

    def Traversal(self, root):
        if root == None:
            return [0,0]  # 返回的是偷与不偷的量
        
        left = self.Traversal(root.left)  # 左
        right = self.Traversal(root.right)  # 右
        
        # 偷当前节点
        val1 = left[1] +right[1] + root.val

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

        return [val1,val2]