编程训练第一百二十期——打家劫舍 III

编程问题：

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

---

问题描述：

• 输入: [3,2,3,null,3,null,1]
  输出: 7

• 输入: [3,4,5,1,3,null,1]
  输出: 9

---

解法：

1.递归
打不打劫根节点，会影响打劫一棵树的收益：打劫根节点，则不能打劫左右子节点，但是能打劫左右子节点的四个子树（如果有）。不打劫根节点，则能打劫左子节点和右子节点，收益是打劫左右子树的收益之和。

时间复杂度O(6^N)
空间复杂度O(N)

/**
 * 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) {
        if (!root)
            return 0;
        int money = root->val;
        if (root->left)
            money += rob(root->left->left) + rob(root->left->right);
        if (root->right)
            money += rob(root->right->left) + rob(root->right->right);
        return max(money, rob(root->left) + rob(root->right));
    }
};

2.记忆化递归
由于在计算根节点时，计算了两个儿子以及四个孙子，当轮到儿子结点时，孙子结点已经被根节点计算过了，因此可以通过哈希表存储，减少重复计算。
时间复杂度O(4^N)
空间复杂度O(N)

/**
 * 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> tmp;
    int rob(TreeNode* root) {
        if (!root)
            return 0;
        if (tmp.count(root))
            return tmp[root];
        int money = root->val;
        if (root->left)
            money += rob(root->left->left) + rob(root->left->right);
        if (root->right)
            money += rob(root->right->left) + rob(root->right->right);
        tmp[root] = max(money, rob(root->left) + rob(root->right));
        return tmp[root];
    }
};

3.动态规划
可以用select[root]表示选择 root 节点的情况下，root 节点的子树上被选择的节点的最大权值和；unselect[root]表示不选择 root节点的情况下，root 节点的子树上被选择的节点的最大权值和；l 和 r 代表 root 的左右孩子。
当 root 被选中时，root 的左右孩子都不能被选中，故 root 被选中情况下子树上被选中点的最大权值和为 l 和 r 不被选中的最大权值和相加，即 select[root] = unselect[l] + unselect[r]。
当 root 不被选中时，root 的左右孩子可以被选中，也可以不被选中。对于root 的某个具体的孩子 x，它对 root 的贡献是 x 被选中和不被选中情况下权值和的较大值。

时间复杂度O(N)
空间复杂度O(N)

/**
 * 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 {
    void dfs(TreeNode* root)
    {
        if (!root)
            return;
        rob(root->left);
        rob(root->right);
        select[root] = root->val + unselect[root->left] + unselect[root->right];
        unselect[root] = max(select[root->left], unselect[root->left]) + max(select[root->right], unselect[root->right]);
    }

public:
    unordered_map<TreeNode*, int> select, unselect;
    int rob(TreeNode* root) {
        dfs(root);
        return max(select[root], unselect[root]);
    }
};