打家劫舍问题1、2、3（动态规划、递归）

一、打家劫舍1

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

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

示例 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.1 冗余dp

状态定义：

dp [ i ] [ 0 ] 表示不偷第 i 号房屋能偷到的最多的钱；
dp [ i ] [ 0 ] 表示偷第 i 号房屋能偷到的最多的钱。

状态转移方程：

dp[ i ][ 0 ] = max( dp[ i-1 ][ 1 ], dp[ i-1 ][ 0 ] )；

因为这家不偷，上家可以不偷、或者偷。

dp[ i ][ 1 ] = max( dp[ i-1 ][ 0 ] + nums[ i ] )。

这家要偷，肯定是上一家不偷。

class Solution {
   
    public int rob(int[] nums) {
   
        if( nums.length<1 )return 0;
        if( nums.length<2 )return nums[0];
        int[][] dp = new int[nums.length][2];
        dp[0][0] = 0;
        dp[0][1] = nums[0];

        for( int i=1; i<nums.length; i++ ){
   
            dp[i][0] = Math.max( dp[i-1][1], dp[i-1][0] );
            dp[i][1] = dp[i-1][0]+nums[i];
        }
        return Math.max( dp[nums.length-1][0], dp[nums.length-1][1] );
    }
}

1.2 压缩版本1

前面对于 dp 的定义太细化，分了拿和不拿第 i 家的情况下能够获取的最大值，事实上这是一个重复的计算，如果dp本来就是最大值，何必再分拿还是不拿呢？

状态定义：

dp[ i ] 表示到了第 i 号房的时候能够获得的最大金额。

转移方程：

dp[ i ] = max( dp[ i-2 ] + nums[ i ] , dp[ i-1 ] )

这时候不用考虑上一家的屋子要不要偷，因为 dp[ i-1 ] 就是更新的最大值，包含了偷或不偷的情况。

class Solution {
   
    public int rob(