198. 打家劫舍

题目分析

动态规划数组初始化：

• dp[0]被初始化为0，因为没有房屋可以盗窃时的最大金额为0。
• dp[1]被初始化为nums[0]，意味着如果只有一家房屋，盗贼将盗取这家的金额。
• dp[2]被初始化为std::max(nums[0], nums[1])，这表示如果有两家房屋，盗贼将选择金额较大的那家进行盗窃。

动态规划解法：

• 循环从i = 3开始，因为前两个情况（即dp[1]和dp[2]）已经被手动设定。
• 对于dp数组中的每个后续位置i，都通过比较不盗窃当前房屋（即dp[i - 1]的值）和盗窃当前房屋（即dp[i - 2] + nums[i - 1]的值）之间的较大值来进行更新。这反映了一个事实：盗窃当前房屋意味着必须跳过前一个房屋，而不盗窃则保留前一个房屋的决策结果。
• 循环结束后，通过dp数组可以看出从第一家到每家房屋盗窃的最大金额。

输出和返回结果：

• 打印出dp数组的内容，这有助于验证和理解动态规划的逐步解答过程。
• 返回dp[nums.size()]作为最终结果，表示考虑所有房屋时可以盗窃的最大金额。

acm模式代码

#include <iostream>
#include <vector>class Solution {
public:int rob(std::vector<int>& nums) {if (nums.size() == 0) return 0;if (nums.size() == 1) return nums[0];std::vector<int> dp(nums.size() + 1, 0);dp[1] = nums[0];dp[2] = std::max(nums[0],nums[1] );for (int i = 3; i <= nums.size(); i++) {dp[i] = std::max(dp[i - 2] + nums[i - 1], dp[i - 1]);}// for (int i : dp) {//     std::cout << i << " ";// }return dp[nums.size()];}
};int main() {Solution sol;std::vector<int> nums = {2, 7, 9 ,3 ,1};int res = sol.rob(nums);std::cout << std::endl;std::cout << "res:" << res << std::endl;return 0;
}

213 打家劫舍2

. - 力扣（LeetCode）

题目分析

在这个变种中，房屋排列成一个圈，这意味着第一家和最后一家是相邻的，盗贼不能同时从这两家盗窃。因此，问题变成了两个子问题：

1. 不考虑最后一家房屋：即只考虑从第一家到倒数第二家的房屋。
2. 不考虑第一家房屋：即只考虑从第二家到最后一家的房屋。

对这两个子问题分别使用“打家劫舍”问题的解决方案，然后取这两个解的最大值作为最终答案。

robliner方法

robliner方法实现了原始的“打家劫舍”问题的解决方案，用于处理一排线性排列的房屋（即没有首尾相连）。它首先处理一些基本情况：

• 如果没有房屋，则返回0。
• 如果只有一家房屋，则返回这家的金额。

然后，它初始化一个动态规划数组dp，其中dp[i]表示到达第i个位置时能够盗取的最大金额。通过动态规划的方法填充这个数组，并返回最大可能的盗窃金额。

rob方法

rob方法解决了房屋排列成圈的问题。它首先创建了两个子数组nums1和nums2：

• nums1包含从第一家到倒数第二家的所有房屋，即不考虑最后一家。
• nums2包含从第二家到最后一家的所有房屋，即不考虑第一家。

接着，它对这两个子数组分别调用robliner方法来解决线性排列的“打家劫舍”问题，并取这两个结果的最大值作为最终答案。

总结

这种方法巧妙地将圈形排列的房屋问题转化为了两个线性排列的房屋问题，并复用了原始“打家劫舍”问题的解决方案。这样不仅提高了代码的复用性，也简化了问题的解决流程。最终，通过比较两种情况下的最大盗窃金额来得到全局的最大值。

acm代码

#include <iostream>
#include <vector>class Solution {
public:int robliner(std::vector<int>& nums) {if (nums.size() == 0) return 0;if (nums.size() == 1) return nums[0];std::vector<int> dp(nums.size() + 1, 0);dp[1] = nums[0];dp[2] = std::max(nums[0],nums[1] );for (int i = 3; i <= nums.size(); i++) {dp[i] = std::max(dp[i - 2] + nums[i - 1], dp[i - 1]);}// for (int i : dp) {//     std::cout << i << " ";// }// std::cout << std::endl;return dp[nums.size()];}int rob(std::vector<int>& nums) {std::vector<int> nums1(nums.begin(), nums.end() - 1);std::vector<int> nums2(nums.begin() + 1, nums.end());int res = std::max(robliner(nums1), robliner(nums2));return res;}
};int main() {Solution sol;std::vector<int> nums = {1, 2 ,3 ,1};int res = sol.rob(nums);std::cout << std::endl;std::cout << "res:" << res << std::endl;return 0;
}

337. 打家劫舍 III

题目分析

• robtree 方法：这是一个递归函数，用于计算从当前节点开始可以偷窃的最大金额。

  • 如果当前节点为nullptr，返回两个0，表示没有可偷窃的金额。
  • 否则，递归调用robtree方法计算左右子节点的最大偷窃金额。因为left和right是std::unique_ptr，所以使用.get()方法来获取它们所管理的裸指针，以符合robtree函数的参数要求。
  • 计算当前节点偷窃(dp[0])和不偷窃(dp[1])的情况下的最大金额，然后返回这两个值。

• rob 方法：接收树的根节点的裸指针，调用robtree方法，并返回从根节点开始可以偷窃的最大金额。

acm模式代码

#include <iostream>
#include <vector>
#include <memory>struct TreeNode
{int val;// TreeNode *left;// TreeNode *right;std::unique_ptr<TreeNode> left;std::unique_ptr<TreeNode> right;TreeNode(int x):val(x), left(nullptr), right(nullptr) {}TreeNode(int x, TreeNode* left, TreeNode* right): val(x), left(left), right(right) {}
};class Solution{
public:std::vector<int> robtree(TreeNode* cur) {//下标为0,偷当前节点，下标为1,不偷当前节点std::vector<int> dp = {0,0};if (cur == nullptr) return {0, 0};std::vector<int> leftdp = robtree(cur->left.get());// 使用.get()访问原始指针std::vector<int> rightdp = robtree(cur->right.get());//偷dp[0] =  cur->val + leftdp[1] + rightdp[1];//不偷dp[1] = std::max(leftdp[0], leftdp[1]) + std::max(rightdp[0], rightdp[1]);return dp;}int rob(TreeNode* root) {std::vector<int> result = robtree(root);return std::max(result[0], result[1]);}
};int main() {// 使用 unique_ptr 构建树std::unique_ptr<TreeNode> root = std::make_unique<TreeNode>(3);root->left = std::make_unique<TreeNode>(2);root->right = std::make_unique<TreeNode>(3);root->left->right = std::make_unique<TreeNode>(3);root->right->right = std::make_unique<TreeNode>(1);Solution solution;std::cout << "Maximum amount of money the thief can rob: " << solution.rob(root.get()) << std::endl;// 无需手动释放内存return 0;
}// int main() {
//     // 构建一个示例树：        3
//     //                      / \
//     //                     2   3
//     //                      \   \ 
//     //                       3   1
//     TreeNode* root = new TreeNode(3);
//     root->left = new TreeNode(2);
//     root->right = new TreeNode(3);
//     root->left->right = new TreeNode(3);
//     root->right->right = new TreeNode(1);//     Solution solution;
//     std::cout << "Maximum amount of money the thief can rob: " << solution.rob(root) << std::endl;//     // 删除分配的内存
//     delete root->left->right;
//     delete root->right->right;
//     delete root->left;
//     delete root->right;
//     delete root;//     return 0;
// }