LeetCode-198. 打家劫舍 C/C++实现 超详细思路及过程[M]

题目描述

198. 打家劫舍
难度：中等
相关标签：动态规划、数组

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

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

运行示例
示例 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,7,9,3,1]为例，在偷第一个房子的时候，我们可以获得2。在偷第二个房子的时候，由于我们不能偷连续的两个房子，也就是不能第一个和第二个房子一起被偷，那么我们就要比较一下第一个房子更值钱，还是第二个房子更值钱了。因而可以得到 当前能获得的最大金额 = max（第一个房子的价值，第二个房子的价值）。因此，我们偷到第二个房子的时候，可以获得的最大金额数为7。


确定完初始状态后，我们就要考虑状态转移方程了，其实就是找规律了。这里我们依然以[2,7,9,3,1]为例。在偷盗第三个房子的时候，我们不能偷第二个房子，但我们能偷第一个房子。因此，可以得到 第三个房屋能得到的最大金额 = max（（第一个房子价值 + 第三个房子价值） ， 第二个房子价值）。

按照动态规划问题的常规套路，此时我们要创建一个dp数组，一般这个dp数组的长度要≥输入数组的长度。这里我们创建一个长度为5的dp数组，因为第一个房子能偷到的最大金额为2，所以dp[0]=2；第二个房子能偷到的最大金额为7，所以dp[1]=7；根据上面的公式，我们可以得到第三个房子能偷到的最大金额为11，所以dp[2]=11。

分析第四个房子的思路和第三个房子的思路是一样的，即 第四个房屋能得到的最大金额 = max（（第二个房子处得到的价值 + 第三个房子价值） ， 第三个房子处得到的价值）。这里为什么不是第三个房子的价值，而是第三个房子处得到的价值呢？因为我们是一个累计的过程，第三个房子处得到的价值是累计了一号房子和三号房子的结果的。因而，dp[3]=max(dp[1]+nums[4] , dp[2])。

经过上面的一波分析，我们可以得到，dp[i] = max(dp[i-1], dp[i - 2]+nums[i])。接下来我们来看看实现代码吧。

C语言

int rob(int* nums, int numsSize){
	//如果numsSize为1时，可能数组越界，需要特殊考虑
    if(numsSize == 1)
        return nums[0];
    int* dp = (int*)malloc(sizeof(int) * numsSize);
    dp[0] = nums[0];
    dp[1] = nums[1] > nums[0] ? nums[1] : nums[0];
    for(int i = 2; i < numsSize; i++)
        dp[i] = dp[i - 1] > dp[i - 2] + nums[i] ? dp[i - 1] : dp[i - 2] + nums[i];
    return dp[numsSize - 1];
}

C++

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

上面有三四行代码是在特殊处理0、1下标位置。下面的方法，通过多开辟2个位置的空间，并将这两个位置置为0，此时就不再需要特殊考虑0、1下标了。
C语言

int rob(int* nums, int numsSize){
    int* dp = (int*)malloc(sizeof(int) * (numsSize + 2));
    memset(dp, 0, sizeof(int) * (numsSize + 2));
    for(int i = 2; i < numsSize + 2; i++)
        dp[i] = dp[i - 1] > dp[i - 2] + nums[i - 2] ? dp[i - 1] : dp[i - 2] + nums[i - 2];
    return dp[numsSize + 1];
}

C++

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

为什么要多开两个位置的空间呢？为什么要初始化为0呢？


在动态规划问题中，可以通过多开辟几个元素的空间，以此简化初始化操作。此处，i=0代入循环遍历语句 * “dp[i] = dp[i - 1] > dp[i - 2] + nums[i - 2] ? dp[i - 1] : dp[i - 2] + nums[i - 2];” * 时，因为该语句会向前访问两个元素，多开辟这两个元素就不用再担心数组越界了。

初始化操作要遵循不影响结果的元素，上述初始化为0时恰好不影响dp[0]，dp[1]的结果。具体初始化为什么，还需要具体问题具体分析。

上面就是今天分享的所有内容啦！下一文章见！
🎇有更优秀的算法，欢迎在评论区讨论！！