leetcode打家劫舍

题目要求

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

暴力递归

• 由于两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警，所以不可以偷两间相邻的，则可以分解为是否偷当前位置的房屋，即index位置，若偷当前位置则下一次偷的必须是index + 2 位置的房屋，若不偷index位置的，则相当于从index + 1 位置开始重新考虑，周而复始。

class Solution {
    public int rob(int[] nums) {
        return process(nums, 0);
    }
    private int process(int[] nums, int index) {
        if (index >= nums.length) {
            return 0;
        }
        int haveCurCargo = nums[index] + process(nums, index + 2);
        int donHaveCurCargo = process(nums, index + 1);
        return Math.max(haveCurCargo,donHaveCurCargo);
    }
}

但是该方法没有ac， 超出时间限制。检测以后 测试用例[114,117,207,117,235,82,90,67,143,146,53,108,200,91,80,223,58,170,110,236,81,90,222,160,165,195,187,199,114,235,197,187,69,129,64,214,228,78,188,67,205,94,205,169,241,202,144,240] 运行时间确实挺长。。。

记忆化搜索

加傻缓存

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

    private int process2(int[] nums, int index, int[] dp) {
        if (index >= nums.length) {
            return 0;
        }
        if (dp[index] != -1) {
            return dp[index];
        }
        int haveCurCargo = nums[index] + process2(nums, index + 2, dp);
        int donHaveCurCargo = process2(nums, index + 1, dp);
        dp[index] = Math.max(haveCurCargo,donHaveCurCargo);
        return dp[index];
    }

}

改写动态规划

由暴力递归的index的取值可以得到 dp数组 的范围设置为 nums.length + 2

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

}