【leetcode】198. 打家劫舍

前端小白多阅读

已于 2023-07-01 21:12:40 修改

阅读量518

点赞数 1

分类专栏： leetcode动态规划（基础版）文章标签： leetcode 算法

于 2023-07-01 21:10:58 首次发布

本文链接：https://blog.youkuaiyun.com/qq_63514555/article/details/131494641

版权

leetcode动态规划（基础版）专栏收录该内容

1 篇文章

订阅专栏

该问题是一个经典的动态规划问题，目标是确定不触发警报的情况下，小偷能从沿街房屋中盗取的最大金额。解决方案是通过状态转移方程dp[i]=max(dp[i-3]+nums[i],dp[i-2]+nums[i])，避免相邻房屋被盗，最后比较dp[n-2]和dp[n-1]以找到最大值。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

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

示例 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个或者第2个位置就开始。因为如果从第三个及其以后开始，都会漏掉第一个或第二个位置，总金额不可能是最高的。

因为不能是相邻的，但是又得保证最多。所以只能是当前位置前面两个或者前面三个再加上当前位置的值，因此状态转移方程就是 dp[i] = max(dp[i - 3] + nums[i], dp[i - 2] + nums[i]);

返回最大值时，因为不能相邻，所以最大值可能存在的位置有两种可能，倒数第一个位置以及倒数第二个位置，进行比较之后再返回。

代码实现

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        if(n <= 1){
            return nums[0];
        }
        if(n <= 2){
            return max(nums[0], nums[1]);
        }
        int dp[n];
        dp[0] = nums[0];
        dp[1] = nums[1];
        dp[2] = nums[0] +nums[2];
        for(int i = 3; i < n; i++){
            dp[i] = max(dp[i - 3] + nums[i], dp[i - 2] + nums[i]);
        }
        return max(dp[n - 2], dp[n - 1]);
    }
};

贴一下2022年9月份做这一题的思路，当时有点死板

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.size()==0){
            return 0;
        }
        if(nums.size()==1){
            return nums[0];
        }
        int dp[nums.size()];
        dp[0]=nums[0];
        dp[1]=nums[1];
        for(int i=2;i<nums.size();i++){
            int max=0;
            for(int j=0;j<i-1;j++){
                if(dp[j]>max){
                    max=dp[j];
                } 
            }
            dp[i]=max+nums[i];
        }
        if(dp[nums.size()-2]>dp[nums.size()-1]){
            return dp[nums.size()-2];
        }else{
            return dp[nums.size()-1];
        }
    }
};