day 39 代码随想录 | 打家劫舍 动态规划

198.打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

• 示例 1：
• 输入：[1,2,3,1]
• 输出：4

这题其实就是一个动态规划的题，经典题目，房屋排成一排，看到底打劫不打劫。

同样，动态规划5部曲

1. dp数组定义

dp[j] 这里要认真去想，我觉得这个是个难点，dp数组代表下标从0到j 房屋截取的最大金额数。j不代表房屋数量！

2. dp递推公式

这个其实就去想，对每个房屋，我就只有两种选择，偷或者不偷

如果偷 那么你前面的那一个房屋就不能投，j-1不能投，但是j-2以及前面可以

结合dp数组定义,此时dp[j] = dp[j-2] + nums[j]

如果不偷，那么dp[j] = dp[j-1]

结合起来，两者取最大的 dp[j] = max(dp[j-1], dp[j-2] + nums[j])

3. dp数组初始化

从递推公式可以看出，需要初始化dp[0], dp[1]

dp[0] = nums[0]

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

4. dp遍历顺序

这个其实就是遍历房屋，单层遍历。

def rob(nums: List[int]) -> int:
    if len(nums) <= 2:
        return max(nums)

    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-1], dp[i-2] + nums[i])
    
    return dp[len(nums)-1]
        

213.打家劫舍II

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。

给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，能够偷窃到的最高金额。

示例 1：

• 输入：nums = [2,3,2]

• 输出：3

• 解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

这个题与上一个题的唯一不同在于这个编程了环形，其实可以进行转换成上一个题一样的思路。

由于首尾相邻，如果不看尾部或者不看首部，那其实就是和第一个题一样。

那么，我们拿是否打劫1号房屋为例进行说明转换。

1号房屋只有打劫和不打劫两种可能

如果打劫1号房屋，那么从1-n-1就是可以利用上面的题一样按照线操作

因为最后一个房屋n就必然不会打劫。

如果不打劫1号房屋，那么打劫的房屋就是从2-n这个区间，又是一条线段。因此转换成立第一个问题。

代码如下。

def rob(self, nums: List[int]) -> int:
    
     if len(nums) <= 3:
            return max(nums)
        # 假设我偷了第一个 正常的话就是下标2开始走 但是是到n-1
        dp = [0] * len(nums)
        dp[0] = nums[0]
        dp[2] = nums[2] + dp[0]
        dp[3] = max(nums[2], nums[3]) + dp[0] 
        for i in range(4, len(nums)-1):
            dp[i] = max(dp[i-1], dp[i-2] + nums[i])
        
        tempA = dp[len(nums)-2]

        # 假设我没偷第一个 正常的话就从下标1开始走，直到n 相当于直接往走一步
        dp1 = [0] * (len(nums))
        dp1[0] = 0
        dp1[1] = nums[1]
        dp1[2] = max(nums[1], nums[2])
        for i in range(3, len(nums)):
            dp1[i] = max(dp1[i-1], dp1[i-2] + nums[i])
        
        tempB = dp1[len(nums)-1]

        return max(tempA, tempB)

337.打家劫舍 III

小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。

除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。

给定二叉树的 root 。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额 。

这个题变成了树形结构，就与前面完全不同的。得用递归去做。

对于二叉树，你得知道怎么递归，这个题很简单，只能有后序遍历，从下往上，左右中。

那么就回到递归三部曲了

1. 确定递归参数和返回值

二叉树遍历，递归参数就是我们的节点。

主要是返回值，我们应该返回什么。对于这个题，我们应该返回一个元组，包含两个元素。索引0下标为0记录不偷该节点所得到的的最大金钱，下标为1记录偷该节点所得到的的最大金钱。

2. 确定终止条件

如果遇到空节点，无论偷还是不偷都是0，所以就返回0,0

3. 确定遍历顺序

首先明确的是使用后序遍历。 因为要通过递归函数的返回值来做下一步计算。

通过递归左节点，得到左节点偷与不偷的金钱。

通过递归右节点，得到右节点偷与不偷的金钱。

4 . 单层递归

如果是偷当前节点，那么左右孩子就不能偷，val1 = cur->val + left[0] + right[0]; （如果对下标含义不理解就再回顾一下dp数组的含义）

如果不偷当前节点，那么左右孩子就可以偷，至于到底偷不偷一定是选一个最大的，所以：val2 = max(left[0], left[1]) + max(right[0], right[1]);

最后当前节点的状态就是{val2, val1}; 即：{不偷当前节点得到的最大金钱，偷当前节点得到的最大金钱}

class Solution:

    def rob(self, root: Optional[TreeNode]) -> int:


        res = self.dfs(root)
        return max(res)

    def dfs(self, node):

        if not node:
            return [0, 0]

        left = self.dfs(root.left)
        right = self.dfs(root.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]