Leetcode--Java--213. 打家劫舍 II

题目描述

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

样例描述

示例 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. 动态规划。本题构建状态转化方程思路与下面这题类似，
   Leetcode–Java–198. 打家劫舍
2. 本题加上了首尾相邻的限制。 因此可以分两种情况：①不选第一间，最后一间选或者不选都行 ②选第一间，最后一间不能选
   取这两种方案的最大值即可
3. 滚动数组，降低空间复杂度到O(1)
   对于当前的情况，只会与前两个情况有关，所以只需要存储前两个

代码

class Solution {
    public int rob(int[] nums) {
         int n = nums.length;
         if (n == 0) return 0;
         if (n == 1) return nums[0];
         int f[] = new int[n + 1]; //必选第i个
         int g[] = new int[n + 1]; //必不选第i个
         //情况一： 不选第一个,直接从第2个房子开始遍历
         for (int i = 2; i <= n; i ++ ) {
             f[i] = g[i - 1] + nums[i - 1];
             g[i] = Math.max(f[i - 1], g[i - 1]);
         }
         int res = Math.max(f[n], g[n]);
         //情况二： 选第一个，最后一个不选g[n]
         f[1] = nums[0];//选第一个,单独写出来让后面的递推与上面保持一致
         g[1] = 0; //则g[1]就不合法，直接取0
          for (int i = 2; i <= n; i ++ ) {
             f[i] = g[i - 1] + nums[i - 1];
             g[i] = Math.max(f[i - 1], g[i - 1]);
         }

         return Math.max(res, g[n]);

     

    }
}

滚动数组

class Solution {
    public int rob(int[] nums) {
        int n = nums.length;
        //先处理好所有边界
        if (n == 0 || nums == null) {
            return 0;
        } 
        else if (n == 1) {
            return nums[0];
        }
        else if (n == 2) {
            return Math.max(nums[0], nums[1]);
        }
        //两种情况，限制范围
        return Math.max(robRange(nums, 0, n - 2), robRange(nums, 1, n - 1));
    }
    //大于等于3的情况才滚动
    public int robRange(int[] nums, int l, int r) {
        int p = nums[l], q = Math.max(p, nums[l + 1]);
        //直接从第三个开始递推滚动
        for (int i = l + 2; i <= r; i ++ ) {
            int t = q;
            q = Math.max(q, p + nums[i]);
            p = t;
        }
        return q;
    }
}