leetcode——第337题——打家劫舍V3—树形递归

题目：
在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。

计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

/**
 * 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 {
/*
树的遍历有四种，本题一定是要后序遍历的，因为需要通过递归函数返回值来考虑的返回值，来计算下一步的结果
无需重新定义 递归函数，本题中给的函数已经符合写递归的条件，直接写就好了嘛

方法一：暴力递归
n 表示节点个数
* 时间复杂度：O(n^2) 这个时间复杂度不太标准，也不容易准确化，例如越往下的节点重复计算次数就越多
* 空间复杂度：O(n) 算上递推系统栈的空间
计算了root的四个孙子（左右孩子的孩子）为头结点的子树的情况，又计算了root的左右孩子为头结点的子树的情况，计算左右孩子的时候其实又把孙子计算了一遍。

方法二：记忆化递推
* 时间复杂度：O(n)
* 空间复杂度：O(n) 算上递推系统栈的空间
要点就是使用一个 map 把计算过的结果保存一下，这样就可以对方法一进行优化，
如果计算过孙子，那么计算孩子的时候可以重复用孙子的结果

方法三：动态规划
上面两种方法对一个节点 偷与不偷得到的最大金钱都没有做记录，而是需要实时计算的，
而动态规划其实就是使用状态转移容器来记录状态的变化，这里可以使用一个长度为2的数组
记录当前节点偷与不偷所得到的最大金钱

本题可以称为 树形dp的入门题目，也就是在树上进行状态转移，递归三部曲 + 动规五部曲

*/
public:
/***************************方法一：暴力递归*********************************/
    // int rob(TreeNode* root) 
    // {
    //     // 后序遍历 左 右 中
        
    //     // 终止条件，刚开始我把第二个终止条件写在 主函数中，仔细想想，应该写在递归函数中才对嘛！！！
    //     if(root == nullptr)  return 0;
    //     if(root->right == nullptr && root->left == nullptr) return root->val;

    //     // 写错了！！！是 += ，我怎么就想不到呢，需要累加的关系嘛！！！

    //     // 这里的逻辑没有想到，主要是分两种情况，
    //     // 1、抢当前节点，那么左右孩子就不能考虑了
    //     // 2、不抢当前节点，那么就可以考虑左右孩子

    //     // 情况一：抢当前节点，那么就不考虑左右孩子，直接下一层
    //     int val1 = root->val;
    //     if(root->left != nullptr)
    //     {   // 跳过root->left，相当于不考虑左孩子了
    //         val1 += rob(root->left->left) + rob(root->left->right);
    //     }
    //     if(root->right != nullptr)
    //     {
    //         // 跳过root->right，相当于不考虑左孩子了
    //         val1 += rob(root->right->left) + rob(root->right->right);
    //     }

    //     // 情况二：不抢当前节点，那么就考虑左右孩子
    //     int val2 = rob(root->left) + rob(root->right);

    //     // 中
    //     return max(val1, val2);
    // }

/**************************方法二：记忆递归****************************/
    // unordered_map<TreeNode*, int> mp; //记录计算结果
    // int rob(TreeNode* root)
    // {
    //     // 终止条件  注意多了一个，是判断是否处理过该节点
    //     if(root == nullptr) return 0;
    //     if(root->left == nullptr && root->right == nullptr) return root->val;
    //     if(mp[root] != 0)    return mp[root];   // 如果 mp 里面已经记录过，则直接返回

    //     // 情况一：抢当前节点，不抢左右孩子
    //     int val1 = root->val;
    //     if(root->left != nullptr)
    //     {
    //         val1 += rob(root->left->left) + rob(root->left->right);
    //     }
    //     if(root->right != nullptr)
    //     {
    //         val1 += rob(root->right->left) + rob(root->right->right);
    //     }

    //     // 情况二：不抢当前节点，抢左右孩子
    //     int val2 = rob(root->left) + rob(root->right);

    //     // 别忘了在这里需要更新一下 mp 数组，
    //     mp[root] = max(val1, val2);

    //     return max(val1, val2);
    // }

/********************************方法三：动态规划*********************************/
    int rob(TreeNode* root)
    {
        vector<int> result = robTree(root);
        return max(result[0], result[1]);
    }

    // 递归函数
    vector<int> robTree(TreeNode* cur)
    {
        if(cur == nullptr)  return vector<int>{0, 0};

        vector<int> left = robTree(cur->left);
        vector<int> right = robTree(cur->right);

        // 偷当前节点
        int val1 = cur->val + left[0] + right[0];
        // 不偷当前节点
        int val2 = max(left[0], left[1]) + max(right[0], right[1]);

        // 这个顺序写错了！！！！  第一个参数是记录不偷的！  第二个参数记录的是偷的！
        return {val2, val1};
    }
};