力扣刷题-198.打家劫舍

198.打家劫舍

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

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

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

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

提示：

• 1 <= nums.length <= 100
• 0 <= nums[i] <= 400

来源：力扣（LeetCode）
链接：打家劫舍

 记忆化搜索+递归

class Solution {
    public int rob(int[] nums) {
        int max = 0;
        int n = nums.length;
        /*
            maxMon 存储最大金额
            例如：
            maxMon[2]：就是以第三家为开始，继续向后面偷，所得到的最大金额存入maxMon[2]
        */
        int[] maxMon = new int[n];
        for (int i = 0; i < n; i++) {
            maxMon[i]=-1;
        }
        if (n>0){
            max = getMax(nums,0,maxMon);
        }
        return max;
    }
    private int getMax(int[] nums,int now,int[] maxMon){
        int max = 0;
        for (int i = 0; i < 2; i++) {
            if (now+i<nums.length){
                if (maxMon[i+now]==-1){
                    max = Math.max(nums[i+now]+getMax(nums,now+i+2,maxMon),max);
                    maxMon[i+now] = nums[i+now]+getMax(nums,now+i+2,maxMon);
                }else {
                    max = Math.max(maxMon[i+now],max);
                }
            }
        }
        return max;
    }
}

下面两个方法的解题思路都一样

解题思路： 

设偷完前n家的最大金额为 f(n) ,设第n家的财产为nums[n];显而易见:

n=1        =>        f(1) = nums[1]

n=2        =>        f(2) = Math.max(num[1],nums[2])

当 n >= 3 时，我们可以选择第n家是 偷 还是 不偷。

如果 偷 ，则返回 nums[n]+f(n-2)

如果 不偷 ，则返回 f(n-1)

保留两个选择中的最大值

n=3        =>        f(3) = Math.max(f(2),nums[3]+f(1))

n=n        =>        f(n) = Math.max(f(n-1),nums[n]+f(n-2))

 动态规划

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

动态规划+滚动数组

class Solution {
    public int rob(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int length = nums.length;
        if (length == 1) {
            return nums[0];
        }
        int first = nums[0], second = Math.max(nums[0], nums[1]);
        for (int i = 2; i < length; i++) {
            int temp = second;
            second = Math.max(first + nums[i], second);
            first = temp;
        }
        return second;
    }
}