打家劫舍

方法一：暴力法

计算到达每一个房间时所能盗窃的最大金额。

设当前为第i个房间，那么可以从【0，i-2】中任意一个房间直接到达第i个房间，所以需要在这里面找到最大值。

class Solution {
    public int rob(int[] nums) {
       int length = nums.length;
        if (length == 0){
            return 0;
        }
        if (length == 1){
            return nums[0];
        }
        if (length == 2){
            return Math.max(nums[0],nums[1]);
        }

        int result = 0;
        for (int i = 2; i < length; i++){
            int temp = i - 2;
            int temp2 = 0;
            for (int k = 0; k <= temp;k++){
               temp2 = Math.max(temp2, nums[i]+nums[k]);
            }
            nums[i] = temp2;
            result = Math.max(nums[i-1],nums[i]);
        }
        return result;
    }
}

方法二：动态规划

思路：每当到达一个房间时，需要判断当前房间该不该抢。如何判断？如果不能抢当前房间，那么说明当前房间的前一个房间被抢了，同时也说明抢前一个房间的含金量比抢当前房间的含金量高。用一个额外的数组来维护每个房间的价值。

举例说明：

nums = {3, 2, 1, 5}

result【0】 = 3 没什么疑问。

result【1】 = MAX（nums【0】，nums【1】）因为第二个房间的价值比第一个房间小，所以不抢第二个房间。

result【2】 = 4  因为相邻的房间不能抢，所以当准备抢第三个房间时，那么第一个房间也可以抢。

result【3】 = 8 到达第4个房间的可能有两种：从第二个房间过来或者从第一个房间过来。因为第二个房间不抢，所以只能从第一个房间过来。

这里面的关键就是：比较抢当前房间的金额与前一个房间进行比较，两者取最大值才是当前房间的最大金额。

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

空间优化：

public int rob3(int[] nums) {
        final int length = nums.length;
        if (length == 0){
            return 0;
        }
        if (length == 1){
            return nums[0];
        }
        if (length == 2){
            return Math.max(nums[0],nums[1]);
        }
        nums[1] = Math.max(nums[0],nums[1]);
        for (int i = 2; i < length; i++){
            nums[i] = Math.max(nums[i-2]+nums[i],nums[i-1]);
        }
        return nums[length-1];
    }