10-今日一扣(LeetCode)-198-E-动态规划-213-E-动态规划

198-打家劫舍-E

Leetcode

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

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

示例 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 。

题解

动态规划

时间复杂度O(n)

空间复杂度O(1)

思想：

主要找出递推公式、

假设$s_i$为i家最大收益, num[i]是第i家的钱。

s0 = num[0] //只有一家的情况

s1 = max(s0, s1)

s2 = max(s1, max(s0+num[2]) // 从这里开始，当有3家及以上，有两种情况。

$s_n=\max (s_{n-1},num[n]+s_{n-2})$

当大于等于3家时，有两种情况：

• 抢劫最后一家，那么一定不能抢劫第i-1家，所以此时收益为$s_i-2$ + num[i]
• 不抢劫最后一家，那么收益为前(i-1)家的最大收益，即$s_{i-1}$。注意此时是否抢劫第i-1不一定的。

取上述最大的情况。

class Solution {
    public int rob(int[] nums) {
        // 递推公式： s0 = 0; s1=nums[1]; s2 = max(s1, nums[2]+s0);  sn = max(s_n-1, nums[n]+s_n-2)

        int len = nums.length;
        if(len == 0){
            return 0;
        }
        if(len == 1){
            return nums[0];
        }
        int pre2 = nums[0];
        int pre = Math.max(nums[0],nums[1]);
        for(int i = 2; i<len; i++){
            int cur = Math.max(pre, nums[i]+pre2);
            pre2 = pre;
            pre = cur;
        }
        return pre;
    }
}

213-打家劫舍2-M

LeetCode

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

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

示例 1:

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

示例 2:

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

题解

和198-打家劫舍的进阶版。却别是首尾不可以同时抢劫。那么我们可以把环形的拆成两个队列：

• 抢头不抢尾部
• 抢尾不抢头

这样问题就变成了两个非环形的问题。即两个198号问题。

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

        int ans1 = robLine(Arrays.copyOfRange(nums, 0, len-1));
        int ans2 = robLine(Arrays.copyOfRange(nums, 1, len));
        return Math.max(ans1, ans2);
    }

    //非环形抢劫问题解决方法
    private int robLine(int[] nums){
        int len = nums.length;
        if(len ==1){
            return nums[0];
        }
        int pre2 = nums[0];
        int pre1 = Math.max(pre2, nums[1]);
        
        for(int i=2; i<len; i++){
            int cur = Math.max(pre1, nums[i]+pre2);
            pre2 = pre1;
            pre1 = cur;
        }
        return pre1;
    }
}