代码随想录算法训练营day50 | 198.打家劫舍、213.打家劫舍II、337.打家劫舍III

198.打家劫舍

1. 确定dp数组以及下标的含义：偷盗0-j家房屋能够获取的最高金额为dp[j]
2. 确定递推公式：dp[j] = max(dp[j-1], dp[j-2]+nums[j])
3. dp数组的初始化：金额为非负整数，初始化为0。
4. 确定遍历顺序：从前向后遍历
5. 举例推导dp数组

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:2])
        for i in range(2, len(nums)):
            dp[i] = max(dp[i-1], dp[i-2] + nums[i])
        return dp[-1]

213.打家劫舍II

第一个房屋和最后一个房屋是紧挨着，如何处理？

忽略最后一个房间，其它房间选择最大值；忽略第一个房间，其它房间选择最大值。这两种情况可以避免第一个房间和最后一个房间同时被选中，满足条件。

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

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

337.打家劫舍III 

递归三部曲和动态规划五部曲融合

递归三部曲

1. 确定递归函数的参数和返回值：参数为当前节点，返回值为当前节点 偷与不偷的两个状态所得到的金钱，那么返回值就是一个长度为2的数组
2. 确定终止条件：在遍历的过程中，如果遇到空节点的话，很明显，无论偷还是不偷都是0，所以就返回
3. 确定单层递归的逻辑：

如果是偷当前节点，那么左右孩子就不能偷，val1 = cur->val + left[0] + right[0]

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

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

动态规划五部曲

1. dp数组以及下标的含义：下标为0记录不偷该节点所得到的的最大金钱，下标为1记录偷该节点所得到的的最大金钱。
2. 确定递推公式：和单层递归的逻辑一样
3. dp数组的初始化：空节点返回[0, 0]，和递归的终止条件一样
4. 确定遍历顺序：使用后序遍历，因为要通过递归函数的返回值来做下一步计算
5. 举例推导dp数组

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

    def traversal(self, cur):
        if not cur:
            return [0, 0]
        left = self.traversal(cur.left)
        right = self.traversal(cur.right)
        # 偷当前节点
        val1 = cur.val + left[0] + right[0]
        # 不偷当前节点
        val2 = max(left) + max(right)
        return [val2, val1]