代码随想录算法训练营第45天（py）| 动态规划 | 198.打家劫舍、213.打家劫舍II、337.打家劫舍III

198.打家劫舍

力扣链接
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金。
如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组nums，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

思路

当前房屋偷与不偷取决于 前一个房屋和前两个房屋是否被偷了。
当前状态和前面状态会有一种依赖关系，那么这种依赖关系都是动规的递推公式。

1. 确定dp含义
   在[0:i]的房屋内，能窃取的最高金额为dp[i]
2. 确定递推公式

如果当前房间要偷，dp[i] = dp[i-2] + num[i] #注意是i-2，否则就报警了
如果当前房间不偷，dp[i] = dp[i-1]
综上，dp[i] = max( dp[i-2] + nums[i] , dp[i-1] )

3. 初始化
   显然dp[0]=nums[0]，dp[1]=max(nums[0],nums[1])
   由于递推公式用到了max，那么剩下全部都全部都为0
4. 确定遍历顺序
   从前向后

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


        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

力扣链接
题目和上一题一样，不过这个地方所有的房屋都 围成一圈

思路

这题唯一的改动就是数组成环形了。可以分成两种情况考虑：

1. 完全不考虑nums[0]，只对后面的元素进行打家劫舍
2. 完全不考虑nums[-1]，只对前面的元素进行打家劫舍

class Solution:
    def rob(self, nums: List[int]) -> int:
        if len(nums)==1:
            return nums[0]
        list1 = nums[1:]# 不考虑第一个元素
        list2 = nums[:-1]# 不考虑最后一个元素

        res1 = self.single_rob(list1)
        res2 = self.single_rob(list2)
        return max(res1, res2)

    def single_rob(self, nums: List[int]) -> int: ##非环形打家劫舍的函数
        if len(nums)==1:
            return nums[0]


        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]

337.打家劫舍III

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

思路

如果抢了当前节点，两个孩子就不能动。
并且，遍历二叉树需要后序遍历（左右中）,因为需要返回值来进行下一步计算。

使用一个长度为2的数组，记录当前节点偷与不偷所得到的的最大金钱。
递归三部曲+动规五部曲：

1. 确定递归函数参数和返回值
   返回值：表示i节点偷与不偷两个状态所得到的金钱，返回一个长度为2的数组dp，参数为当前节点
2. 确定终止条件
   碰到空节点就返回
3. 确定遍历顺序
   后序遍历：
   递归左节点，得到左节点偷与不偷的钱。
   递归右节点，得到右节点偷与不偷的钱。
4. 确定单层递归逻辑

如果偷当前节点，那其孩子节点不能偷
val1 = cur.val + left[0] + right[0]
如果不偷当前节点，那其孩子节点可以偷
val2 = max(left[0], left[1]) + max(right[0], right[1]);

# 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)