具体思想：

自己第一次想的是自顶向下进行判断，该节点选或者不选，进行爆搜；

但是发现爆时间；

后来发现存在递归子问题，从底向上搜即可，同时使用map记录；

题解写的更简单；

具体代码：

1.My version:

/**
 * 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) {
        preorder(root);
        return record[root];
    }

    void preorder(TreeNode* root){
        if(!root)
            return;
        preorder(root->left);
        preorder(root->right);
        if(!root->left&&!root->right){
            //如果是叶子节点；
            record[root]=root->val;
            return;
        }
        //如果不选择该节点；
        int count=0;
        count+=root->left?record[root->left]:0;
        count+=root->right?record[root->right]:0;
        //如果选择该节点；
        int temp=cnt(root->left);
        temp+=cnt(root->right);
        count=max(count,temp+root->val);
        record[root]=count;
        return;
    }
    int cnt(TreeNode* root){
        if(!root)
            return 0;
        int count=0;
        count+=root->left?record[root->left]:0;
        count+=root->right?record[root->right]:0;
        return count;
    }

    int dfs(TreeNode* root,bool flag){
        if(!root){
            return 0;
        }
        if(!flag){
            //当前节点不能选择；
            return dfs(root->left,true)+dfs(root->right,true);
        }else{
            //当前节点可以选择;
            //选了，或者可以选但是不选；
            int ret=0;
            ret=max(ret,dfs(root->left,false)+dfs(root->right,false)+root->val);//选择当前节点；
            ret=max(ret,dfs(root->left,true)+dfs(root->right,true));//不选择当前节点；
            return ret;
        }
    }

    unordered_map<TreeNode*,int>record;//记录子树信息；
};

2.官方 version：

class Solution {
public:
    unordered_map <TreeNode*, int> f, g;

    void dfs(TreeNode* node) {
        if (!node) {
            return;
        }
        dfs(node->left);
        dfs(node->right);
        f[node] = node->val + g[node->left] + g[node->right];
        g[node] = max(f[node->left], g[node->left]) + max(f[node->right], g[node->right]);
    }

    int rob(TreeNode* root) {
        dfs(root);
        return max(f[root], g[root]);
    }
};