198. 打家劫舍 [力扣/LeetCode，讲解]

最新推荐文章于 2026-04-05 23:11:29 发布

原创最新推荐文章于 2026-04-05 23:11:29 发布 · 331 阅读

9 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

题目背景

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

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

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

思路

很简单很基础的动态规划

设数组dp，长度为输入数组的长度，其中dp[i]表示第i个数以及之前的所有数小偷能够偷盗的最大值。即第i个数的解。（设家的数组是nums[n]）

然后考虑状态转换方程。显然，dp[i]完全来自这几个数：dp[i-1]， dp[i-2]， dp[i-3]。

原因很简单：dp[i]与dp[i-4]无关。因为无论nums[i-4]是否被偷盗，一定可以偷盗nums[i-2]（偷盗后可以偷盗nums[i]），因此dp[i-2]一定大于dp[i-4]。无论是通过dp[i-4]还是dp[i-2]产生dp[i]，转换都是同样加上nums[i]，因此由dp[i-4]产生的dp[i]一定小于dp[i-2]产生的dp[i]。

dp[i-4]以前同理，dp[i]一定不会来自这些数。

显然，如果来自于dp[j]，那么意味着在j(不含)到当前i中只能偷盗dp[i]。因为如果在j到i偷盗任何一家，都意味着不来自dp[j]，而是来自dp[偷盗家的下标]。

另外，dp[i-1]比较特殊，转换不能加num[i]，因为如果dp[i-1]被盗，dp[i]不能偷盗。

所以写出来的转换方程就是：

$dp[i]=max(dp[i-1], dp[i-2]+nums[i], dp[i-3]+nums[i])$

最后考虑边界条件，即dp[0]，dp[1]，dp[2]即可，这三个的计算算法不赘述了，需要可以直接看代码。

代码

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

PS. LeetCode 的debug要会员，，写的代码不好直接复制到自己的编译器进行调试，，难绷。。。

标签