leetcode198.打家劫舍

一.题目描述

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

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

示例 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 <= nums.length <= 100
0 <= nums[i] <= 400

二.题目解析

1.递归

public int rob1(int[] nums) {
        /*递归
        * */
        if(nums == null || nums.length == 0){
            return 0;
        }
        return tryRob1(0,nums);
    }

    private int tryRob1(int i, int[] nums) {
        /*考虑偷[i,n-1]的房屋所能获得的最大利润
        * */
        if(i == nums.length - 1){
            return nums[i];
        }
        if(i >= nums.length){
            return 0;
        }
        int noSkip = tryRob1(i + 2,nums) + nums[i];
        int skip = tryRob1(i + 1,nums);
        return Math.max(noSkip,skip);
    }

2.记忆化递归

int[] memo;
    public int rob(int[] nums) {
        /*记忆化递归
         * */
        if(nums == null || nums.length == 0){
            return 0;
        }
        memo = new int[nums.length];
        //设初值
        Arrays.fill(memo,-1);
        return tryRob(0,nums);
    }

    private int tryRob(int i, int[] nums) {
        /*考虑偷[i,n-1]的房屋所能获得的最大利润
         * */
        //递归出口
        if(i == nums.length - 1){
            return nums[i];
        }
        if(i >= nums.length){
            return 0;
        }
        //是否已被计算过
        if(memo[i] != -1){
            return memo[i];
        }
        //选择偷取i房屋，那么下一个考虑偷取的只能从i+2开始
        int noSkip = tryRob(i + 2,nums) + nums[i];
        //不选择偷取i房屋，那么可以考虑从i+1房屋开始
        int skip = tryRob(i + 1,nums);
        //取最大值，实现记忆化
        memo[i] = Math.max(noSkip,skip);
        return memo[i];
    }

3.动态规划

public int rob2(int[] nums) {
        /*动态规划
        状态：dp[i]表示考虑偷[i,n-1]的房屋
        状态转移方程：dp[i]=max(偷下标为i的房屋+下次考虑从i+2开始偷，不偷下标为i房屋+考虑从i+1房屋开始偷）
        时间复杂度O(n),空间复杂度O(n)
        * */
        if(nums == null || nums.length == 0){
            return 0;
        }
        int n = nums.length;
        int[] dp = new int[n];
        //若从最后一个房屋考虑，则最大金额就是nums[n - 1]
        dp[n - 1] = nums[n - 1];
        for (int i = n - 2; i >= 0; i--) {
            dp[i] = Math.max(nums[i] + (i + 2 >= n ? 0 : dp[i + 2]),dp[i + 1]);
        }
        return dp[0];
    }

4.状态压缩

public int rob3(int[] nums) {
        /*动态规划-状态压缩   cur        later
        我们发现 dp[n] 只与 dp[n+1] 和 dp[n+2] 有关系，
        因此我们可以设两个变量 cur和 later 交替记录，将空间复杂度降到 O(1)
        时间复杂度O(n),空间复杂度O(1)
        * */
        if(nums == null || nums.length == 0){
            return 0;
        }
        int n = nums.length;
        //若从最后一个房屋考虑，则最大金额就是nums[n - 1]
        //初始的dp[n+1]
        int cur = nums[n - 1];
        //初始的dp[n+2]
        int later = 0,temp;
        for (int i = n - 2; i >= 0; i--) {
            temp = cur;
            cur = Math.max(nums[i] + (i + 2 >= n ? 0 : later),cur);
            later = temp;
        }
        return cur;
    }

https://leetcode-cn.com/problems/house-robber/solution/yi-ben-ti-wei-li-rang-ni-liao-jie-dong-tai-gui-hua/