LeetCode 198. House Robber

You are a professional robber planning to rob houses along a street. Each house has a certain amount of money stashed, the only constraint stopping you from robbing each of them is that adjacent houses have security system connected and it will automatically contact the police if two adjacent houses were broken into on the same night.

Given a list of non-negative integers representing the amount of money of each house, determine the maximum amount of money you can rob tonight without alerting the police.

Credits:
Special thanks to @ifanchu for adding this problem and creating all test cases. Also thanks to @ts for adding additional test cases.

【题目分析】

这是一个很经典的动态规划的题目，意思是一个盗贼要偷盗一条街道上的店铺。唯一的限制就是不能同时偷盗连续的两家店铺，否则的话报警器就会被触发，求在不触发警报的情况下该盗贼可偷盗的最多金钱数。

【思路】

1. 用递归来解决

盗贼遍历店铺，从当前店铺开始获取的最大收益 = max（偷盗当前店铺获取的最大收益， 不偷盗当前店铺获取的最大收益）

代码如下：

public class Solution {
    public int rob(int[] nums) {
        return robber(nums, 0);
    }
    
    public int robber(int[] nums, int start) {
        if(start > nums.length-1) return 0;
        if(start == nums.length-1) return nums[start];
        int result1 = 0, result2 = 0;
        result1 = nums[start] + robber(nums, start+2);
        result2 = robber(nums, start+1);
        
        return result1 > result2 ? result1 : result2;
    }
}

上面的代码时间复杂度较高。原因在于递归的时候一些中间的计算结果没有保存下来，导致多次计算已经计算后的结果。对上面的代码进行改进如下：

public class Solution {
    public int rob(int[] nums) {
        int[] mark = new int[nums.length];
        for(int i = 0; i < nums.length; i++) {
            mark[i] = -1;
        }
        return robber(nums, mark, 0);
    }
    
    public int robber(int[] nums, int[] mark, int start) {
        if(start > nums.length-1) return 0;
        if(start == nums.length-1) return nums[start];
        int result1 = 0, result2 = 0;
        if(start+2 < nums.length && mark[start+2] > -1) {
            result1 = nums[start] + mark[start+2];
        } else {
            result1 = nums[start] + robber(nums, mark, start+2);
        }
        
        if(start+1 < nums.length && mark[start+1] > -1) {
            result2 = mark[start+1];
        } else {
            result2 = robber(nums, mark, start+1);
        }
        
        mark[start] = result1 > result2 ? result1 : result2;
        return mark[start];
    }
}

上面的代码用mark数组保存了已经计算过的最优值，递归过程中如果发现该值已经被计算过，则直接取出已经计算过的结果即可。

递归表达式为：rob[start] = max(rob[start+1], nums[start] + rob[start+2])

上面的代码太过冗余，优化后的代码如下：

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

上面代码的空间复杂度为O（n），我们发现其实不必把已经计算过的所有信息保存下来，只要保存后两个记录即可，优化后的空间复杂度为O（1），代码如下：

public class Solution {
    public int rob(int[] nums) {
        int len = nums.length;
        if(len == 0) return 0;
        if(len == 1) return nums[0];
        
        int post2 = nums[len-1];
        int post1 = Math.max(nums[len-2], nums[len-1]);
        
        for(int i = len-3; i >= 0; i--) {
            int temp = post1;
            post1 = Math.max(post1, nums[i] + post2);
            post2 = temp;
        }
        return post1;
    }
}