leetcode: house-robber [打家劫舍] 递归法、动态规划、滚动数组

'''
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，
如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例 1:
输入: [1,2,3,1]
输出: 4
解释: 偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
     偷窃到的最高金额 = 1 + 3 = 4 。

示例 2:
输入: [2,7,9,3,1]
输出: 12
解释: 偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
     偷窃到的最高金额 = 2 + 9 + 1 = 12 。
'''

1. 如果只有一间房屋，则偷窃该房屋，可以偷窃到最高总金额。

2. 如果只有两间房屋，则由于两间房屋相邻，不能同时偷窃，只能偷窃其中的一间房屋，因此选择其中金额较高的房屋进行偷窃。

3. 如果房屋数量大于两间，应该如何计算能够偷窃到的最高总金额呢？对于第 k (k>2) 间房屋，有两个选项：

   • 偷第 k 间房屋，那么就不能偷窃第 k-1 间房屋，偷窃总金额为前 k−2 间房屋的最高总金额与第 k 间房屋的金额之和
   • 不偷第 k 间房屋，偷窃总金额为前 k−1 间房屋的最高总金额。
   • 在以上两个选项中选择偷窃总金额较大的选项，该选项对应的偷窃总金额即为前 k 间房屋能偷窃到的最高总金额。

状态转移方程：

dp[i] = max(dp[i−2] + nums[i], dp[i−1])

边界条件：

dp[0] = nums[0]
dp[1] = max(nums[0], nums[1])

以下使用递归的方法进行处理。

Python3 代码实现：

from typing import List

def dp(nums, i):
    if i == 0:
        return nums[0]
    elif i == 1:
        return max(nums[1], nums[0])
    return max(dp(nums, i - 1), dp(nums, i - 2) + nums[i])

class Solution:
    def rob(self, nums: List[int]) -> int:
        nums = tuple(nums)
        if not nums:
            return 0
        return dp(nums, len(nums) - 1)

if __name__ == '__main__':
    s = Solution()
    print(s.rob([1, 2, 3, 1]))
    print(s.rob([2, 7, 9, 3, 1]))

在 leetcode 网页上提交后，提交结果为“超出时间限制”，可以猜到的是使用递归法时，当测试数据足够大的时候会产生大量的重复计算，这些就是无用的耗时。同样的入参、同样的函数，计算几遍后是否能够缓存起来呢？当下次使用时直接拿来用，而不用再次计算。

我突然想到了之前阅读 《流畅的Python》时记得有一个函数 lru_cache 。

functools.lru_cache 是非常实用的装饰器，它实现了备忘（memoization）功能。这是一项优化技术，它把耗时的函数的结果保存起来，避免传入相同的参数时重复计算。LRU 三个字母是“Least Recently Used”的缩写，表明缓存不会无限制增长，一段时间不用的缓存条目会被扔掉。（关于一些实用的装饰器的使用）

使用 functools 中的 lru_cache：

from typing import List
from functools import lru_cache  # 缓存
import time

# 计时：仅仅用来观察是否使用 lru_cache 装饰被执行函数的影响
def clock(func):
    def clocked(*args):
        t0 = time.perf_counter()
        res = func(*args)
        elapsed = time.perf_counter() - t0
        name = func.__name__
        args_str = ', '.join(repr(arg) for arg in args)
        print(f'[{elapsed:>2.8}s], {name}({args_str})--> {res}')
        return res
    return clocked

@lru_cache()
@clock
def dp(nums, i):
    if i == 0:
        return nums[0]
    elif i == 1:
        return max(nums[1], nums[0])
    return max(dp(nums, i - 1), dp(nums, i - 2) + nums[i])

class Solution:
    def rob(self, nums: List[int]) -> int:
        nums = tuple(nums)  # 使用lru_cache，它的所有参数都必须是可散列的。
        if not nums:
            return 0
        return dp(nums, len(nums) - 1)

if __name__ == '__main__':
    s = Solution()
    # print(s.rob([1, 2, 3, 1]))
    print(s.rob([2, 7, 9, 3, 1]))

提交后，执行通过：

其他方法：

from typing import List

class Solution:
    # 动态规划
    def rob2(self, nums: List[int]) -> int:
        if not nums:
            return 0
        length = len(nums)
        dp = [0] * length
        dp[0] = nums[0]
        dp[1] = max(nums[0], nums[1])
        for i in range(2, length):
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])
        return dp[length - 1]

    # 滚动数组
    def rob3(self, nums: List[int]) -> int:
        if not nums:
            return 0
        length = len(nums)
        if length == 1:
            return nums[0]
        first, second = nums[0], max(nums[0], nums[1])
        for i in range(2, length):
            first, second = second, max(first + nums[i], second)
        print(second)
        return second

Reference