LeetCode刷题（28）～打家劫舍

原创

海轰Pro 2023-01-14 10:15:13 博主文章分类：算法 ©著作权

文章标签 leetcode 动态规划 #include 滚动数组 文章分类 运维

©著作权归作者所有：来自51CTO博客作者海轰Pro的原创作品，请联系作者获取转载授权，否则将追究法律责任

题目描述

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

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

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

提示：

0 <= nums.length <= 100
0 <= nums[i] <= 400

解答 By 海轰

提交代码（动态规划）

int rob(vector<int>& nums) {
       int len=nums.size();
       unordered_map<int,int> a;
       if(len==0) return 0;
       
       else if(len==1) return nums[0];
       else if(len==2) return max(nums[0],nums[1]);
       else
       {
           int result;
           a[0]=nums[0];
           a[1]=max(nums[0],nums[1]);
           for(int i=2;i<len;++i)
           {
               a[i]=max(nums[i]+a[i-2],a[i-1]);
           }
       }
       return a[len-1];
    }

运行结果

LeetCode刷题（28）～打家劫舍_滚动数组

思路

在第n号房屋时，小偷获取的最大值是n号屋+前n-2获取最大值 与 前n-1号屋获取最大值 的较大值。

提交代码（动态规划+滚动数组）

int rob(vector<int>& nums) {
       int len=nums.size();
       if(len==0) return 0;
       if(len==1) return nums[0];
       int p=nums[0];
       int q=max(nums[0],nums[1]);
       for(int i=2;i<len;++i)
       {
            int temp=q;
           q=max(p+nums[i],q);
           p=temp;
       }
       return q;
    }

运行结果

LeetCode刷题（28）～打家劫舍_leetcode_02

C++测试代码

#include <iostream>
#include<vector>
#include<unordered_map>
using namespace std;
// 方法一：动态规划
 int rob_1(vector<int>& nums) {
       int len=nums.size();
       unordered_map<int,int> a;
       if(len==0) return 0;
       
       else if(len==1) return nums[0];
       else if(len==2) return max(nums[0],nums[1]);
       else
       {
           int result;
           a[0]=nums[0];
           a[1]=max(nums[0],nums[1]);
           for(int i=2;i<len;++i)
           {
               a[i]=max(nums[i]+a[i-2],a[i-1]);
           }
       }
       return a[len-1];
    }
// 方法二：动态规划+滚动数组
int rob_2(vector<int>& nums) {
       int len=nums.size();
       if(len==0) return 0;
       if(len==1) return nums[0];
       int p=nums[0];
       int q=max(nums[0],nums[1]);
       for(int i=2;i<len;++i)
       {
            int temp=q;
           q=max(p+nums[i],q);
           p=temp;
       }
       return q;
    }
int main()
{
    vector<int> a;
    a.push_back(2);
    a.push_back(7);
    a.push_back(9);
    a.push_back(3);
    a.push_back(1);
   cout<<rob_2(a)<<endl;
    return 0;
}