Leetcode刷题(11) 打家劫舍系列问题

Leetcode刷题(11) 打家劫舍系列问题

方法参考labuladong的实现团灭 LeetCode 打家劫舍问题，并自己用python重写了一遍

198. 打家劫舍

方法一: 递归+备忘录

class Solution(object):
    def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        
        # 有多少户人家
        nums_len = len(nums)
        if nums_len == 0:
            return 0 

        # 备忘录
        mome = [-1] * nums_len
        
        # dp[start]表示由start--->end(nums_len) 能最多打劫到多少
        # 注意: start的遍历是倒着来的
        def dp(start):
            if start >= nums_len:
                return 0

            # 发现备忘录里面不是初始值的说明已经计算过了, 直接返回
            elif mome[start] != -1:
                return mome[start]
            else:
                mome[start] = max(dp(start + 1), nums[start] + dp(start + 2))
                return mome[start]
        # 最终要得到的是start = 0
        return dp(0)

用end自顶向下的递归，要处理的临界比较繁琐了，我就没有写代码

方法二: 动态规划

start是递减的(反着来的), 需要处理的临界情况比较少

class Solution(object):
    def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        len_nums = len(nums)
        if len_nums == 0:
            return 0
        # n+1和n+2是空屋子，假想的
        dp = [0] * (len_nums + 2)
       
        for i in range(len_nums-1, -1, -1):
            dp[i] =  max(dp[i+1], dp[i+2] + nums[i])
        return dp[0]

下面的递归方法的end是递增的(顺着来的)，比较好理解但是要处理的临界情况比较繁琐

class Solution(object):
    def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        len_nums = len(nums)
        if len_nums == 0:
            return 0

        # 这里是用0初始化，
        dp = [0] * len_nums
        
        # 这个代码的start是顺着来的, 要处理的临界情况比较繁琐
        if len_nums >= 1:
            dp[0] = nums[0]
        if len_nums >= 2:
            dp[1] = max(nums[1], nums[0])
        

        for i in range(2, len_nums):
            dp[i] =  max(dp[i-1], dp[i-2] + nums[i])
        return dp[-1]

213. 打家劫舍 II

将nums划分为两段，然后取最大的那段即可

方法: 动态规划(状态压缩)

class Solution(object):
    def rob(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        len_nums = len(nums)
        if len_nums == 0:
            return 0
        if len_nums == 1:
            return nums[0]

        start1 = -1
        end1 = len_nums - 2

        start2 = 0
        end2 = len_nums - 1

        def robRange(start, end):
            # 第一次迭代的时候，这个是后里两个空屋子
            dp_i_1 = 0  
            dp_i_2 = 0

            dp_i = 0
            for i in range(end, start, -1):
                dp_i = max(dp_i_1, nums[i] + dp_i_2)
                # 先更新dp_i_2 和 再更新dp_i_2
                dp_i_2 = dp_i_1
                dp_i_1 = dp_i
                

            return dp_i
        
        return max(robRange(start1, end1), robRange(start2, end2))

337. 打家劫舍 III

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def __init__(self):
        self.mome = dict()
    def rob(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        # 树结构的备忘录用字典来做底层结构
        
        def dp(root):
            if root == None:
                return 0 
            # 结果在备忘录内直接返回
            if root in self.mome:
                return self.mome[root]

            # 抢这家
            do_it = root.val
            if root.left != None:
                do_it += dp(root.left.left) + dp(root.left.right)
            if root.right != None:
                do_it += dp(root.right.left) + dp(root.right.right)

            # 不抢，去下家
            not_do = dp(root.left) + dp(root.right);

            self.mome[root] = max(do_it, not_do);

            return self.mome[root]
        return dp(root)