代码随想录训练营第48天 | 198.打家劫舍 ● 213.打家劫舍II ● 337.打家劫舍III

198.打家劫舍 

题目链接：https://leetcode.com/problems/house-robber/

解法：

1. 确定dp数组（dp table）以及下标的含义

dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]。

2. 确定递推公式

决定dp[i]的因素就是第i房间偷还是不偷。

如果偷第i房间，那么dp[i] = dp[i - 2] + nums[i] ，即：第i-1房一定是不考虑的，找出 下标i-2（包括i-2）以内的房屋，最多可以偷窃的金额为dp[i-2] 加上第i房间偷到的钱。

如果不偷第i房间，那么dp[i] = dp[i - 1]，i-1房间可偷也可不偷。

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

3. dp数组如何初始化

从递推公式dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);可以看出，递推公式的基础就是dp[0] 和 dp[1]

从dp[i]的定义上来讲，dp[0] 一定是 nums[0]，dp[1]就是nums[0]和nums[1]的最大值即：dp[1] = max(nums[0], nums[1])。

边界条件：元素为1个

时间复杂度：O(n)

空间复杂度：O(n)

class Solution(object):
    def rob(self, nums):
        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 

题目链接：https://leetcode.com/problems/house-robber-ii/

解法：

对于一个数组，成环的话主要有如下三种情况：

• 情况一：考虑不包含首尾元素
• 情况二：考虑包含首元素，不包含尾元素
• 情况三：考虑包含尾元素，不包含首元素

而情况二 和 情况三 都包含了情况一了，所以只考虑情况二和情况三就可以了。

那么就是打家劫舍1的代码，跑两个结果，取最大值即可。

边界条件：元素为1个

时间复杂度：O(n)

空间复杂度：O(n)

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

    def robRange(self, nums):
        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

题目链接：https://leetcode.com/problems/house-robber-iii/

解法：

这道题很有意思，虽然结合了动态规划和二叉树的后序遍历，但是每个部分都是比较简单的。

题解看：打家劫舍3

值得注意的是，虽然从root进入，但是计算确实从叶子结点先开始。如果当前节点不偷，并不代表着一定要偷左右孩子，可以是偷左孙子和右孩子。

边界条件：无

时间复杂度：O(n)，每个节点只遍历了一次

空间复杂度：O(log n)，算上递推系统栈的空间

# 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) + max(right)

        # 偷当前节点, 不偷子节点
        val_1 = node.val + left[0] + right[0]

        return (val_0, val_1)