337. 打家劫舍 III

337. 打家劫舍 III

题目链接：337. 打家劫舍 III(中等)

小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为 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

解题思路

根据题目的意思，每个节点有偷与不偷两种状态。

• 偷当前节点，那左右孩子节点就不能偷了。

• 不偷当前节点，那取左右孩子节点能获得的最大金额(注意：这与两个孩子节点偷或不偷没有关系)。

因为是树形结构，采用递归的方法，有递归三部曲。另外还有动态规划五部曲。

详细分析在代码的注释中。

C++

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {};
};
​
// 此处我们需要对树进行一个**后序遍历**，由叶子节点开始考虑，直至根节点。
class Solution {
public:
    int rob(TreeNode* root) {
        vector<int> result = robTree(root);
        return max(result[0], result[1]);
    }
    // 递归三部曲 1.确定递归函数的参数和返回值
    // 函数参数就是当前的节点
    // 返回dp数组，该数组由两项构成，dp[0]表示不偷当前节点能够得到的最大金额，dp[1]表示偷当前节点能够得到的最大金额
    vector<int> robTree(TreeNode* node) {
        // 递归三部曲 2.确定终止条件
        // 动规五部曲 3.dp数组的初始化
        // 当前节点为空，无论偷与不偷能得到的最大金额都是0
        if (node == nullptr) return {0, 0};
        // 递归三部曲 3.确定单层递归的逻辑
        // 动规五部曲 4.遍历顺序：后序遍历
        vector<int> left = robTree(node->left);
        vector<int> right = robTree(node->right);
        // 动规五部曲 1.dp数组的含义，该数组由两项构成，dp[0]表示不偷当前节点能够得到的最大金额，dp[1]表示偷当前节点能够得到的最大金额
        vector<int> dp(2);
        // 动规五部曲 2.递推公式
        // 当前节点选择不偷：当前节点能偷到的最大钱数 = 左孩子能偷到的最大金额 + 右孩子能偷到的最大金额
        dp[0] = max(left[0], left[1]) + max(right[0], right[1]);
        //当前节点选择偷：当前节点能偷到的最大钱数 = 左孩子选择自己不偷时能得到的钱 + 右孩子选择不偷时能得到的钱 + 当前节点的钱数
        dp[1] = left[0] + right[0] + node->val;
        return dp;
    }
};

JavaScript

/**
 * @param {number} val
 * @param {TreeNode} left
 * @param {TreeNode} right
 */
function TreeNode(val, left, right) {
    this.val = (val === undefined ? 0 : val)
    this.left = (left === undefined ? null : left)
    this.right = (right === undefined ? null : right)
}
​
/**
 * @param {TreeNode} root
 * @return {number}
 */
var rob = function(root) {
    const robTree = node => {
        if (node === null) return [0, 0];
        let leftVal = robTree(node.left);
        let rightVal = robTree(node.right);
        let dp0 = Math.max(leftVal[0], leftVal[1]) + Math.max(rightVal[0], rightVal[1]);
        let dp1 = leftVal[0] + rightVal[0] + node.val;
        return [dp0, dp1];
    }
    let result = robTree(root);
    return Math.max(...result);
};

• 时间复杂度：O(n)，每个节点只遍历了一次

• 空间复杂度：O(log n)，算上递推系统栈的空间