题目:
在上次打劫完一条街道之后和一圈房屋后,小偷又发现了一个新的可行窃的地区。这个地区只有一个入口,我们称之为“根”。除了“根”之外,每栋房子有且只有一个“父“房子与之相连。一番侦察之后,聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。如果两个直接相连的房子在同一天晚上被打劫,房屋将自动报警。
计算在不触动警报的情况下,小偷一晚能够盗取的最高金额。
输入: [3,2,3,null,3,null,1]
3
/ \
2 3
\ \
3 1
输出: 7
解释: 小偷一晚能够盗取的最高金额 = 3 + 3 + 1 = 7.
输入: [3,4,5,1,3,null,1]
3
/ \
4 5
/ \ \
1 3 1
输出: 9
解释: 小偷一晚能够盗取的最高金额 = 4 + 5 = 9.
抛砖引玉
思路
设节点 node:
特殊条件及递归终止条件
/**
* Definition for a binary tree node.
* function TreeNode(val) {
* this.val = val;
* this.left = this.right = null;
* }
*/
/**
* @param {TreeNode} root
* @return {number}
*/
var rob = function (root) {
if (root === null) return 0
// 二叉树中节点值可能重复,则使用map记录节点位置
let dpRoot = new Map(), // 包含key对应的节点
dp = new Map() // 不包含key对应的节点
function dfs(node) {
// 递归终止
if (node === null) return 0
// 递归枚举包含node.left的情况
dfs(node.left)
// 递归枚举包含node.right的情况
dfs(node.right)
let dpRootLeft = dpRoot.get(node.left) || 0,
dpRootRight = dpRoot.get(node.right) || 0,
dpLeft = dp.get(node.left) || 0,
dpRight = dp.get(node.right) || 0
// 包含传入节点这
dpRoot.set(node, node.val + dpLeft + dpRight)
// 选不包含传入节点
dp.set(node, Math.max(dpRootLeft, dpLeft) + Math.max(dpRootRight, dpRight))
}
// 递归枚举包含根据点的情况
dfs(root)
return Math.max(dpRoot.get(root), dp.get(root))
}
/**
* @param {TreeNode} root
* @return {number}
*/
var rob = function (root) {
let [dpRoot, dp] = dfs(root)
function dfs(root) {
if (root === null) return [0, 0]
// 枚举分别包含左右节点的情况
let [dpRootLeft, dpLeft] = dfs(root.left),
[dpRootRight, dpRight] = dfs(root.right)
let dpRoot = root.val + dpLeft + dpRight,
dp = Math.max(dpRootLeft, dpLeft) + Math.max(dpRootRight, dpRight)
return [dpRoot, dp]
}
return Math.max(dpRoot, dp)
}
/**
* @param {TreeNode} root
* @return {number}
*/
var rob = function (root) {
// 递归终止条件
if (root == null) return 0
let Root = 0,// 包含根节点
noRoot = 0 // 不包含根节点
// 累加存在的不相邻节点
let Root = root.val
if (root.left) {
Root += rob(root.left.left) + rob(root.left.right)
}
if (root.right) {
Root += rob(root.right.left) + rob(root.right.right)
}
// 不包含根节点节点累加
let noRoot = rob(root.left) + rob(root.right)
return Math.max(Root, noRoot)
}