代码随想录算法训练营Day47 | 198.打家劫舍、213.打家劫舍II、337.打家劫舍III | Python | 个人记录向

198.打家劫舍

代码随想录：198.打家劫舍
Leetcode：198.打家劫舍

做题

将偷窃的房间设置为True，然后缓存结果？但是实现起来思路有点乱。

看文章

思路没问题，dp[i]的含义为：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]；递归公式为dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])；初始化为dp[0] = nums[0]，dp[1] = max(nums[0], nums[1])。看完思路后，自己实现代码，AC了，如下：

class Solution:
    def rob(self, nums: List[int]) -> int:
        size = len(nums)
        if size == 1:
            return nums[0]
        if size == 2:
            return max(nums[0], nums[1])
        dp = [0] * size
        dp[0] = nums[0]
        dp[1] = max(nums[0], nums[1])
        for i in range(2, size):
            dp[i] = max(dp[i-2] + nums[i], dp[i-1])
        return dp[size-1]

时间复杂度: O(n)
空间复杂度: O(n)

213.打家劫舍II

代码随想录：213.打家劫舍II
Leetcode：213.打家劫舍II

做题

感觉和198.打家劫舍，但对于开始和结尾的元素，一直尝试不到合适的方法来解决。

看文章

分为3种情况：

1. 不考虑首元素、尾元素
2. 只考虑首元素，不考虑尾元素
3. 只考虑尾元素，不考虑首元素

情况二和情况三包含情况一。

class Solution:
    def rob(self, nums: List[int]) -> int:
        if len(nums) == 0:
            return 0
        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)
    # 198.打家劫舍的逻辑
    def robRange(self, nums: List[int], start: int, end: int) -> int:
        if end == start:
            return nums[start]
        
        prev_max = nums[start]
        curr_max = max(nums[start], nums[start + 1])
        
        for i in range(start + 2, end + 1):
            temp = curr_max
            curr_max = max(prev_max + nums[i], curr_max)
            prev_max = temp
        
        return curr_max

时间复杂度: O(n)
空间复杂度: O(n)

337.打家劫舍III

代码随想录：337.打家劫舍III
Leetcode：337.打家劫舍III

做题

无思路。

看文章

后序遍历，考虑偷当前节点和偷左右子节点。

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

以往忽略的知识点小结

• 打家劫舍基础解法
• 将环分情况，转成非环
• 在二叉树上的打家劫舍：后序遍历，考虑偷当前节点和偷左右子节点

个人体会

完成时间：2h30min。
心得：学习打家劫舍、将环分解、在二叉树上操作的思路。

​