198.打家劫舍

1.dp经典入门题目，dp[i]：考虑下标i（包括i）以内的房屋，最多可以偷窃的金额为dp[i]。dp[i]的值不一定是偷了下标为i的那一家，只是这一家能偷，如果不偷这一家能带来更高的收益，那就不偷。理解递推公式的时候应紧密联系定义，随想录中的考虑我觉得不够形象。事实上dp[0]和dp[1]不一定需要特判，可以通过在dp数组插入两个初始状态来使代码简洁，但我认为特判更好理解一点。（注：本题还可以通过两个变量来优化空间）

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

1.本题是打家劫舍的进阶版，题解基本上都是把环拆开两次打劫取较大值。但为什么这样收益最大其实并没有说的很明白，我个人反复思考之后想出了一种自己觉得相对容易理解的解释。本题房屋是首尾相连的，第一家和最后一家不能同时偷。那么我先选择最后一家不偷，钱再多我也不偷，那么问题就退化成最初的打家劫舍版本。偷完之后我有点后悔，心里好像有只蚂蚁在爬，会不会最后一家钱很多呢？如果上天给我一次重来的机会，我选择不偷第一家，这样我就可以偷最后一家了，虽然不一定偷最后一家。这时候问题依然退化成最初的打家劫舍，比较两次收益，选取那个较大的。为什么这两种情况就包含了所有情况呢？考虑以上两种方案代表的是可以偷第一家和不可以偷第一家，或者说是不可以偷最后一家和可以偷最后一家，因此可以包含所有情况。（可以偷第一家不能偷最后一家，除了最后一家随便偷虽然不一定偷。不可以偷第一家可以偷最后一家，除了第一家随便偷虽然不一定偷）

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

1.记忆化递推，在递归的过程中我们会进行许多重复的计算导致超时，所以我们可以用map记录计算过的值，然后在出现重复计算时把之前的结果拿来用。（如果对重复计算不理解可参考这句话：我们计算了root的四个孙子（左右孩子的孩子）为头结点的子树的情况，又计算了root的左右孩子为头结点的子树的情况，计算左右孩子的时候其实又把孙子计算了一遍。）

/*** Definition for a binary tree node.* struct TreeNode {*     int val;*     TreeNode *left;*     TreeNode *right;*     TreeNode() : val(0), left(nullptr), right(nullptr) {}*     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: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]; // 如果umap里已经有记录则直接返回// 偷父节点int val1 = root->val;if (root->left)val1 += rob(root->left->left) +rob(root->left->right); // 跳过root->leftif (root->right)val1 += rob(root->right->left) +rob(root->right->right); // 跳过root->right// 不偷父节点int val2 = rob(root->left) + rob(root->right); // 考虑root的左右孩子umap[root] = max(val1, val2);                  // umap记录一下结果return max(val1, val2);}
};

2.树形DP。注意使用的后序遍历。 因为要通过递归函数的返回值来做下一步计算。

/*** Definition for a binary tree node.* struct TreeNode {*     int val;*     TreeNode *left;*     TreeNode *right;*     TreeNode() : val(0), left(nullptr), right(nullptr) {}*     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:int rob(TreeNode* root) {vector<int> result = robTree(root);return max(result[0], result[1]);}// 长度为2的数组，0：不偷，1：偷vector<int> robTree(TreeNode* cur) {if (cur == NULL)return vector<int>{0, 0};vector<int> left = robTree(cur->left);vector<int> right = robTree(cur->right);// 偷cur，那么就不能偷左右节点。int val1 = cur->val + left[0] + right[0];// 不偷cur，那么可以偷也可以不偷左右节点，则取较大的情况int val2 = max(left[0], left[1]) + max(right[0], right[1]);return {val2, val1};}
};

今日总结：打家劫舍。