万恶打家劫舍

写在前头 :

【PS】: 还不咋会压缩空间呢， 之后学会再回来改进hhhhh

leetcode.198. 打家劫舍

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

2.coding

class Solution {
    public int rob(int[] nums) {
        int len = nums.length;

        int[][] dp = new int[len][2];
        // dp[i][i_isStolen]
        // i          : 当前第 i 间
        // i_isStolen : 第 i 间是否上房揭瓦？
        dp[0][0] = 0;
        dp[0][1] = nums[0];

        for (int i = 1; i < len; i ++) {
            // 第 i 间没搞事:
            //      1. 前一间就很乖
            //      2. 前一间刚上房揭瓦
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1]);

            // 第 i 间搞事:
            //      1. 前一间没搞事
            dp[i][1] = dp[i - 1][0] + nums[i];
        }
        return Math.max(dp[len - 1][0], dp[len - 1][1]);
    }
}

leetcode.213. 打家劫舍 II

1.题目描述

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。

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

 

示例 1：

输入：nums = [2,3,2]
输出：3
解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

示例 2：

输入：nums = [1,2,3,1]
输出：4
解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
  偷窃到的最高金额 = 1 + 3 = 4 。

示例 3：

输入：nums = [1,2,3]
输出：3

 

提示：

• 1 <= nums.length <= 100
• 0 <= nums[i] <= 1000

2.coding

class Solution {
    public int rob(int[] nums) {
        int len = nums.length;
        if (len == 1) {
            return nums[0];
        }
        // 没有什么是 + 一层解决不了的hhhhh
        int[][][] dp = new int[len][2][2];
        // dp[i][i_isStolen][0_isStolen]
        // i          : 当前第 i 间
        // i_isStolen : 第 i 间是否上房揭瓦？
        // 0_isStolen : 第 0 间是否上房揭瓦？
        dp[0][0][0] = 0;
        dp[0][1][1] = nums[0];
        for (int i = 1; i < len; i ++) {
            // 多一层循环, 用来区分第 0 间是否干坏事hhhh
            for (int j = 0; j < 2; j ++) {
                dp[i][0][j] = Math.max(dp[i - 1][0][j], dp[i - 1][1][j]);
                dp[i][1][j] = dp[i - 1][0][j] + nums[i];
            }
        }
        return Math.max(dp[len - 1][0][1], dp[len - 1][1][0]);
    }
}