leetcode刷题（29）——198.打家劫舍

一、题目

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

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

示例 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 。

二、思路及代码实现

动态规划（一）：

采用动态规划的四个步骤：

• 问题拆解：
  我们要求解的是从这 n 间房能偷到的最大金额，用状态数组 dp[] 记录前 k(0 <= k <= n) 间房能偷到的最大金额。假设小偷从第一间房开始偷，走到第 k 间房时，有偷与不偷两个选择：如果选择偷，则能得到的金额为 dp[k - 2] +nums[k]；如果选择不偷，则能得到的金额为 dp[k - 1]。两种选择的最大值就是前 k 间房能偷到的最大金额，这样就建立起第 i 个子问题和第 i - 1 个子问题与第 i - 2 个子问题的关系。
• 定义状态：
  根据上面的分析，将状态定义为：前 k 间房能偷到的最大金额。
• 推导状态转移方程：
  根据上面的分析，取两种选择中的最大值就得到前 k 间房能偷到的最大金额，即
  $$dp[k]=Math.max((dp[k-2]+nums[k])，dp[k-1])$$
• 寻找边界条件：
  当只有一间房时，只有一种选择，即 $dp[0]=nums[0]$；有两间房时，取两者的最大值，即 $dp[1]=Math.max(nums[0],nums[1])$。

参考代码：

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

也可以把数组为空时的情况记录在状态数组中，这时候状态数组就要多开一位，用来存储 0 间房子的情况，参考代码如下（来自题解）：

class Solution {
    public int rob(int[] nums) {
        if(nums.length == 0)
            return 0;
        int n = nums.length;
        int[] dp = new int[n + 1];// 多开一位，保存 0 间房的状态
        dp[0] = 0;
        dp[1] = nums[0];
        for(int i = 2; i < nums.length + 1; i++){
        	// 这里要注意 dp[i] 和 nums[i] 的对应关系，状态转移方程要稍作改动
            dp[i] = Math.max((dp[i - 2] + nums[i - 1]), (dp[i - 1]));
        }
        return dp[n];
    }
}

动态规划（二）：

上面的方法中用状态数组保存了每个 k 的状态，但实际上，在计算第 i 个子问题时只用到了第 i - 1 个子问题与第 i - 2 个子问题的结果，i - 3 之前的子问题，实际上早就已经用不到了。因此，我们只需要两个变量记录前两个状态就可以了。参考代码如下：

class Solution {
    public int rob(int[] nums) {
        int preMax = 0;
        int curMax = 0;
        // 每次循环，计算偷到当前房子的最大金额
        for(int i = 0; i < nums.length; i++){
        	// 循环开始时，curMax 表示 dp[i - 1]，preMax 表示 dp[i - 2]
            int temp = Math.max(preMax + nums[i], curMax);// 计算偷到当前房子的最大金额
            preMax = curMax;
            curMax = temp;
            // 循环结束时，curMax 表示 dp[i]，preMax 表示 dp[i - 1]
        }
        return curMax;
    }
}

这样一来，我们只用两个变量保存两个子问题的结果，就可以依次计算出所有的子问题。相比创建长度为 n 的状态数组，空间复杂度也从 O(n) 降到了 O(1) ，做到了空间优化。