代码随想录算法训练营第三十九天| DP7— 213. 打家劫舍 II，337. 打家劫舍 III

学习如何打劫的一天。198. 打家劫舍，213. 打家劫舍 II，337. 打家劫舍 III。感觉比背包系列的问题好理解好做一些。

213. 打家劫舍 II

和Ⅰ比较像，只不过换成了环形数组，需要分情况进行讨论，因为首尾不能同时选，但是在Ⅰ中是没有这个限制条件的。一共分三种情况考虑：1.首尾都不选，2.选首不选尾，3.选尾不选首。比如一共5个数，1是考虑中间三个，2和3是考虑前四个或者后四个。但是其实2和3里面包含了1，因为是考虑，不是选择。dp[1] = max(nums[start], nums[start + 1])，如果没有选到在开始的值的时候，那么2就变成了情况1，3也同理，所以只需讨论两种情况就够。

然后就是打家劫舍类型的讨论

1. 下标：dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]
2. 递推公式：

   如果偷第i房间，dp[i] = dp[i - 2] + nums[i] 

   如果不偷第i房间，那么dp[i] = dp[i - 1]，即考 虑i-1房，（考虑，并不是一定要偷i-1房）

   然后dp[i]取最大值，即dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);

3. 初始化：dp[0] 一定是 nums[0]，dp[1]就是nums[0]和nums[1]的最大值即：dp[1] = max(nums[0], nums[1]);
4. 遍历顺序：从前向后

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

        result1 = self.dp(nums, 0, len(nums) - 2) 
        result2 = self.dp(nums, 1, len(nums) - 1) 
        return max(result1, result2)

    def dp(self, nums, start, end):
        if start == end:
            return nums[start]
        dp = [0] * (end - start + 1)
        dp[0] = nums[start]
        dp[1] = max(nums[start], nums[start + 1])
        for i in range(2, end - start + 1):
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[start + i])
        return dp[-1]

37. 打家劫舍 III

337. 打家劫舍 III - 力扣（LeetCode）

这道题卡住的主要原因是有点忘了二叉树写法了，感觉思路还是类似的，就是想到了分类讨论，选这个节点的值和不选这个节点的值，但是不太清楚怎么写，因为是有左右两个子节点，所以没法像之前一样按一维的做。

但是看了题解发现还是比较容易理解的，自己太公式人了，稍微偏离点模板都很难做。首先确定树的遍历顺序，后序遍历（左中右），从下往上逐步把数值加到root上，然后就是关键的几个区别，一是树形DP不需要再新建一个DP数组了，利用树的后序遍历方式就是相当于状态转移方程。而是需要建立一个二元组（记住过程中不是不断修改二元组，而是在每个节点保存二元组的状态供上一层参考），然后一个元素代表不偷，一个元素代表偷，当为叶子节点的时候，终止，返回（0，0）。然后就是对树中间节点的讨论，有偷和不偷两种情况，如果偷，则下面的子节点就不能偷了，所以是node.val+left[0]+right[0]，left0和right0代表了不偷的收益。如果不偷当前节点，那么肯定偷子节点，就在左右两个子节点分别比较偷和不偷的收益取最大值，然后左右节点相加继续往上传递。

还是要熟悉树的定义，遍历方式会好做一点，这道题套dp模板反而会很僵硬。

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