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

1.198.打家劫舍

题目链接：198.打家劫舍
文档讲解： 代码随想录

（1）确定数组和下标
dp[ i ]表示包括下标 i 在内的房屋能够偷窃的最高金额
（2）递推关系式
如果偷 i，则 i-1 则必不偷，那为 dp[ i-2 ] + nums[ i ]；如果不偷 i，则考虑dp[ i-1 ]。那么则为dp[ i ] = max（dp[ i-2 ] + nums[ i ], dp[ i-1 ]）
（3）初始化
dp[0] = nums[0]，dp[1] = max（nums[0], nums[1]），其余为0
（4）遍历顺序
从前往后
（5）打印数组

class Solution(object):
    def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 0:
            return 0
        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 - 1], dp[i - 2] + nums[i])
        return dp[len(nums) - 1]

2.213.打家劫舍II

题目链接：213.打家劫舍II
文档讲解： 代码随想录

如何处理成环是本题的关键。主要考虑2种情况，一是只考虑首元素，不考虑尾元素，二是只考虑尾元素，不考虑首元素。

class Solution(object):
    def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 0:
            return 0
        if len(nums) == 1:
            return nums[0]
        
        top = self.robRange(nums, 0, len(nums) - 2)
        down = self.robRange(nums, 1, len(nums) - 1)
        return max(top, down)

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

3.337.打家劫舍 III

题目链接：337.打家劫舍 III
文档讲解： 代码随想录

动态规划是使用状态转移容器来记录状态的变化，这里对于每个节点，使用一个长度为2的一维数组来记录节点偷与不偷所得的最大金钱。使用递归来遍历二叉树，输入为节点，输出为记录最大金钱的数组。终止条件为，遇到空节点，返回值为0的数组。单层递归逻辑，该节点不偷，左右孩子都可以考虑偷，dp[0] = max（leftdp[0], leftdp[1]）+ max（rightdp[0], rightdp[1]）；该节点偷，那么左右孩子不偷，dp[1] = node.value + leftdp[0] + rightdp[0]。从单层逻辑可以确定，遍历顺序为后序遍历。

class Solution(object):
    def rob(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        dp = self.traversal(root)
        return max(dp[0], dp[1])
        
    def traversal(self, node):
        if not node:
            return (0,0)
        #后序遍历
        leftdp = self.traversal(node.left)
        rightdp = self.traversal(node.right)
        #该节点不偷
        val1 = max(leftdp[0], leftdp[1]) + max(rightdp[0], rightdp[1])
        #该节点偷
        val2 = node.val + leftdp[0] + rightdp[0]
        return (val1, val2)

#会超时
class Solution(object):
    def rob(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        #暴力递归
        if not root:
            return 0
        if not root.left and not root.right:
            #叶子节点
            return root.val
        #不偷父节点
        val1 = self.rob(root.left) + self.rob(root.right)
        #偷父节点
        val2 = root.val
        if root.left:
            val2 += self.rob(root.left.left) + self.rob(root.left.right)
        if root.right:
            val2 += self.rob(root.right.left) + self.rob(root.right.right)
        return max(val1, val2)

因为这样子暴力遍历会重复计算很多节点，可以使用字典对其进行存储，在计算前先在字典里搜索一下是否计算过，以此优化。

class Solution(object):
    mem = {}
    def rob(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        if not root.left and not root.right:
            return root.val
        if self.mem.get(root):
            return self.mem[root]
        val1 = self.rob(root.left) + self.rob(root.right)
        val2 = root.val
        if root.left:
            val2 += self.rob(root.left.left) + self.rob(root.left.right)
        if root.right:
            val2 += self.rob(root.right.left) + self.rob(root.right.right)
        self.mem[root] = max(val1, val2)
        return max(val1, val2)