【随想录】-【动态规划】337 打家劫舍Ⅲ

重点：

（1）打家劫舍三部曲：数组，环，树；

（2）树的遍历算法：前中后序（深度优先）和层次遍历（广度优先）；

（3）本题使用后序遍历，用递归函数的返回值进行计算；

（4）当前节点的最大值等于max（不抢本节点抢左右孩子，抢本节点）。第一个选择左右孩子产生价值之和，第二个为本节点价值；

（5）记忆化递推：使用map记录每个节点的值，防止重复计算。然后深搜，每次抢不抢当前节点两种情况取最大值，最后得到结果；

（6）动态规划：通过递归三部曲和动规五步曲解决问题。需要明确每个节点的二维数组存的什么，以及单层的逻辑实现。（递归终止条件，单层实现逻辑，返回值）

337. 打家劫舍 III

难度中等1369

小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 root 。

除了 root 之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果 两个直接相连的房子在同一天晚上被打劫 ，房屋将自动报警。

给定二叉树的 root 。返回 在不触动警报的情况下 ，小偷能够盗取的最高金额 。

示例 1:

输入: root = [3,2,3,null,3,null,1]
输出: 7 
解释: 小偷一晚能够盗取的最高金额 3 + 3 + 1 = 7

示例 2:

 

输入: root = [3,4,5,1,3,null,1]
输出: 9
解释: 小偷一晚能够盗取的最高金额 4 + 5 = 9

提示：

• 树的节点数在 [1, 104] 范围内
• 0 <= Node.val <= 104

解析：

打家劫舍三部曲：由一个数组，变成一个环，再变成一棵树。

对于树，首先想到遍历解决。前中后序遍历（深度优先）还是层序遍历（广度优先）。

本题使用后序遍历，需要用递归函数的返回值来做下一步计算。

考虑当前节点抢还是不抢。如果抢，那么就不能抢左右子节点，此时最大收益为本节点val；如果不抢，就考虑抢左右子节点，此时最大收益为左右节点收益之和。

方法1：记忆化递推

使用map记录访问过的节点的收益值，然后更新当前节点为max抢与不抢当前节点，最后得到头节点root的值即为结果。

方法2：动态规划

动态规划就是用数组解决。那么对于当前节点抢还是不抢，应该返回一个二维数组的值，{0, 1}分别对应抢本节点与不抢本节点所产生的最大收益。

代码：

class Solution {
public:
    unordered_map<TreeNode* , int> umap; // 记录计算过的结果
    int rob(TreeNode* root) {
        if(root==nullptr)
            return 0;
        if(root->left==nullptr&&root->right==nullptr)
            return root->val;
        if(umap[root])
            return umap[root];
        int val1=root->val;
        if(root->left)
            val1+=rob(root->left->left)+rob(root->left->right);
        if(root->right)
            val1+=rob(root->right->left)+rob(root->right->right);
        int val2=rob(root->left)+rob(root->right);
        umap[root]=max(val1,val2);
        return umap[root];
    }
};

class Solution {
public:
    int rob(TreeNode* root) {
        vector<int> res=robFun(root);
        return max(res[0],res[1]);
    }
    vector<int> robFun(TreeNode* root) {
        if(root==nullptr)
            return {0,0};
        if(root->left==nullptr&&root->right==nullptr)
            return {0,root->val};
        vector<int> left=robFun(root->left);
        vector<int> right=robFun(root->right);
        int val1=root->val;
        val1+=left[0]+right[0];
        int val2=max(left[0],left[1])+max(right[0],right[1]);
        return {val2,val1};
    }
};