算法题：动态规划之打家劫舍问题

问题描述

假设你是一个专业的小偷，计划偷窃一条街上的所有房屋。每个房屋都有一定的现金，你不能同时打劫相邻的两个房屋。给定一个代表每个房屋存放金额的非负整数数组，计算你能够偷窃到的最高金额。

算法思路

这个问题可以用动态规划来解决。「动态规划是一种解决最优化问题的算法思想」，在某些情况下能够大大降低问题的复杂度。在打家劫舍问题中，动态规划的状态转移方程如下：

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

其中，dp[i] 表示偷到第 i 个房屋时的最大金额，nums[i] 表示第 i 个房屋的现金数。如果你偷第 i 个房屋，那么你就不能偷第 i-1 个房屋，所以偷到第 i 个房屋时的最大金额为偷到第 i-2 个房屋时的最大金额加上第 i 个房屋里的现金数。如果你不偷第 i 个房屋，那么你可以偷到第 i-1 个房屋，所以偷到第 i 个房屋时的最大金额为偷到第 i-1 个房屋时的最大金额。

最终要求的是最后一个房屋的最大金额，所以返回 dp[n-1]，其中 n 表示房屋数量。

代码实现

Python代码实现

def rob(nums: List[int]) -> int:
    if not nums:
        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[-1]

时间复杂度：O(n)，其中 n 表示房屋数量。

空间复杂度：O(n)，需要用一个数组来保存偷到每个房屋时的最大金额。

Java代码实现

public int rob(int[] nums) {
    if (nums == null || nums.length == 0) {
        return 0;
    }
    int n = nums.length;
    if (n == 1) {
        return nums[0];
    }
    int[] dp = new int[n];
    dp[0] = nums[0];
    dp[1] = Math.max(nums[0], nums[1]);
    for (int i = 2; i < n; i++) {
        dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]);
    }
    return dp[n - 1];
}

相比于Python代码，Java代码只是语法上的差异。Java使用了数组来保存偷到每个房屋时的最大金额，数组的长度为房屋数量。Java中数组的下标从0开始，所以dp[0]表示偷到第一个房屋时的最大金额，dp[1]表示偷到第二个房屋时的最大金额，以此类推。Java中的for循环语法和Python有所不同，但是实现的思路是一样的。