打家劫舍系列

打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

这个题目一看就是动态规划，想到了爬楼梯的那个题。

动态规划套路：
设置一个普遍情况：假设有k户人家，则：

• 偷第k-1户人家（则不偷第k户）；
• 偷第k户人家，加上rob(k-2)

所以最高金额 money = max(rob(k-1), rob(k-2)+nums[k])
边界情况：

• k = 1，money = nums[0]
• k = 2，money = max(nums[0], nums[1])

所以我们只需要保存前两个最高金额即可：

• first：抢劫到第k-2家时的最高金额
• second：抢劫到第k-1家时的最高金额

class Solution:
    def rob(self, nums: List[int]) -> int:
        if not nums:
            return 0
        lenth = len(nums)
        if lenth == 1:
            return nums[0]
        first, second = nums[0], max(nums[0], nums[1])
        for i in range(2,lenth):
        # 向右遍历滑动，下一个的first即为前一个的second
        # 下一个的second为前一个max(second, first+nums[i])
            first, second = second, max(second, first+nums[i])
        return second

打家劫舍 II

变动：这个地方所有的房屋都围成一圈

本来我的想法是设置个标签啥的，但是感觉很复杂，然后看了一下官方题解。。。我果然还是太笨了/(ㄒoㄒ)/~~

只需要分两种情况：

• 打劫最后一家：遍历范围为（1， k-1);
• 不打劫最后一家：遍历范围为（0，k-1）。

class Solution:
    def rob(self, nums: List[int]) -> int:
        def robbbb(begin, end): # 第一版的代码
            first, second = nums[begin], max(nums[begin], nums[begin+1])
            for i in range(begin+2,end):
                first, second = second, max(second, first+nums[i])
            return second

        length = len(nums)
        if not length:
            return 0
        elif length == 1:
            return nums[0]
        elif length == 2:
            return max(nums[0], nums[1])
        else:
            return max(robbbb(0, length-1), robbbb(1, length))

打家劫舍 III

在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。

计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

哦豁，改成我最讨厌的二叉树了。。。

仔细一看，这似乎就是将二叉树的每层的和计算出来，然后组成一个数组，就变成了版本Ⅰ了！结果搞了半天，测试集就把我搞没了，在评论区发现了很多和我一样想的兄弟。。。明明可以不用选同一层的呀！示例害人系列！

我果然是一个题也没做出来呢。。（微笑着透露出疲惫.jpg）

• selected：选择当前节点时的最大金额，= notselected[left] + notselected[right]
• notselected ：不选择当前节点时的最大金额，= max(selected[left], notselected[left]) + max(selected[right ], notselected[right ])

class Solution:
    def rob(self, root: TreeNode):
        def dfs(root):
            if not root:
                return [0, 0]
            left = dfs(root.left)
            right = dfs(root.right)
            selected = root.val + left[1] + right[1]
            notselected = max(left[0], left[1]) + max(right[0], right[1])
            return [selected, notselected]

        choice = dfs(root)
        return max(choice[0], choice[1])