打家劫舍Ⅲ-力扣

首先想到的方法是对二叉树进行遍历，采用后序遍历，结构化搜索减少重复搜索。

/**
 * 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 {
private:
    unordered_map<TreeNode*, int> mp;
public:
    int rob(TreeNode* root) {
        if(root == nullptr){
            return 0;
        }
        if(root->left == nullptr && root->right == nullptr){
            return root->val;
        }
        if(mp[root]){
            return mp[root];
        }
        int val1 = root->val;
        if(root->left){
            val1 += rob(root->left->left);
            val1 += rob(root->left->right);
        }
        if(root->right){
            val1 += rob(root->right->left);
            val1 += rob(root->right->right);
        }

        int val2 = rob(root->left) + rob(root->right);

        mp[root] = max(val1, val2);
        return max(val1, val2);
    }
};

看了代码随想录的动规解法，这道题是树形DP的入门题目，所谓树形DP就是在树上进行递归公式的推导。

• 这里我们要求一个节点 偷与不偷的两个状态所得到的金钱，那么返回值就是一个长度为2的数组。所以dp数组（dp table）以及下标的含义：下标为0记录不偷该节点所得到的的最大金钱，下标为1记录偷该节点所得到的的最大金钱。

• 在遍历的过程中，如果遇到空节点的话，很明显，无论偷还是不偷都是0，所以就返回

• 首先明确的是使用后序遍历。 因为要通过递归函数的返回值来做下一步计算。
  通过递归左节点，得到左节点偷与不偷的金钱。
  通过递归右节点，得到右节点偷与不偷的金钱。

• 如果是偷当前节点，那么左右孩子就不能偷，val1 = cur->val + left[0] + right[0]; （如果对下标含义不理解就再回顾一下dp数组的含义）

• 如果不偷当前节点，那么左右孩子就可以偷，至于到底偷不偷一定是选一个最大的，所以：val2 = max(left[0], left[1]) + max(right[0], right[1]); 左右孩子可以偷，不代表一定要偷，可以偷，也可以不偷

• 最后当前节点的状态就是{val2, val1}; 即：{不偷当前节点得到的最大金钱，偷当前节点得到的最大金钱}

class Solution {
public:
    vector<int> traversal(TreeNode* root){
        if(root == nullptr){
            return {0, 0};
        }
        vector<int> left = traversal(root->left);
        vector<int> right = traversal(root->right);

        vector<int> result(2);
        result[0] = max(left[0], left[1]) + max(right[0], right[1]);
        result[1] = root->val + left[0] + right[0];

        return result;  
    }
    int rob(TreeNode* root) {
        vector<int> result = traversal(root);
        return max(result[0], result[1]);  
    }