算法D47 | 动态规划9 | 198.打家劫舍 213.打家劫舍II 337.打家劫舍III

最新推荐文章于 2025-12-18 17:00:31 发布

原创最新推荐文章于 2025-12-18 17:00:31 发布 · 547 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#动态规划 #算法 #数据结构 #c++ #python

算法训练营专栏收录该内容

43 篇文章

订阅专栏

本文详细介绍了在LeetCode中使用Python和C++解决打家劫舍系列（198、213、337）的问题，通过动态规划和暴力/递归方法实现，展示了如何在不同情况（单房间、房间连成环、房间连成树）下计算最大收益。

今天就是打家劫舍的一天，这个系列不算难，大家可以一口气拿下。

198.打家劫舍

视频讲解：动态规划，偷不偷这个房间呢？| LeetCode：198.打家劫舍_哔哩哔哩_bilibili

代码随想录

Python:

class Solution:
    def rob(self, nums: List[int]) -> int:
        n = len(nums)
        if n<=2: return max(nums)
        dp = [0]*n
        dp[0] = nums[0]
        dp[1] = max(nums[:2])
        for i in range(2, n):
            dp[i] = max(dp[i-1], dp[i-2]+nums[i])
        return dp[n-1]

C++:

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

213.打家劫舍II

视频讲解：动态规划，房间连成环了那还偷不偷呢？| LeetCode：213.打家劫舍II_哔哩哔哩_bilibili

代码随想录

Python:

分别考虑[0, n-2] 和 [1, n-1]范围的打家劫舍198，选择两者最大值。

class Solution:
    def robRange(self, nums, start, end):
        if start==end: return nums[start]
        dp = [0] * (end-start+1)
        dp[0] = nums[start]
        dp[1] = max(nums[start], nums[start+1])
        for i in range(start+2, end+1):
            dp[i-start] = max(dp[i-start-1], dp[i-start-2]+nums[i])
        return dp[-1]

    def rob(self, nums: List[int]) -> int:
        n = len(nums)
        if n==1: return nums[0]
        result1 = self.robRange(nums, 0, n-2)
        result2 = self.robRange(nums, 1, n-1)
        return max(result1, result2)

C++:

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

337.打家劫舍III

视频讲解：动态规划，房间连成树了，偷不偷呢？| LeetCode：337.打家劫舍3_哔哩哔哩_bilibili

代码随想录

Python暴力:

class Solution:
    def __init__(self):
        self.umap = {}

    def rob(self, root: Optional[TreeNode]) -> int:
        if not root: return 0
        if not root.left and not root.right: return root.val
        if root in self.umap.keys(): return self.umap[root]
        # 偷root
        val1 = root.val
        if root.left: val1 += self.rob(root.left.left) + self.rob(root.left.right)
        if root.right: val1 += self.rob(root.right.left) + self.rob(root.right.right)
        # 不偷root
        val2 = self.rob(root.left) + self.rob(root.right)
        self.umap[root] = max(val1, val2) 
        return max(val1, val2)

C++:暴力

class Solution {
public:
    unordered_map<TreeNode*, int> umap;
    int rob(TreeNode* root) {
        if (root==NULL) return 0;
        if (root->left==NULL && root->right==NULL) return root->val;
        if (umap[root]) return umap[root];
        // 偷root
        int val1 = root->val;
        if (root->left) val1 += rob(root->left->left) + rob(root->left->right);
        if (root->right) val1 += rob(root->right->left) + rob(root->right->right);
        // 不偷root
        int val2 = rob(root->left) + rob(root->right);
        umap[root] = max(val1, val2);
        return max(val1, val2);
    }
};

Python动态规划：

class Solution:
    def traversal(self, node):
        if not node: return (0, 0)
        left = self.traversal(node.left)
        right = self.traversal(node.right)
        # 不偷node
        val1 = max(left[0], left[1]) + max(right[0], right[1])
        # 偷node
        val2 = node.val + left[0] + right[0]
        return (val1, val2)

    def rob(self, root: Optional[TreeNode]) -> int:
        dp = self.traversal(root)
        return max(dp)

C++动态规划:

class Solution {
public:
    vector<int> traversal(TreeNode* node) {
        if (node==NULL) return vector<int>{0, 0};
        vector<int> left = traversal(node->left);
        vector<int> right = traversal(node->right);
        //不偷node
        int val1 = max(left[0], left[1]) + max(right[0], right[1]);
        //偷node
        int val2 = node->val + left[0] + right[0];
        return {val1, val2};
    }
    int rob(TreeNode* root) {
        vector<int> dp = traversal(root);
        return max(dp[0], dp[1]);
    }
};