diff --git "a/script/leetcode/editor/cn/doc/[124]\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214.py" "b/script/[124]\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214.py"
similarity index 74%
rename from "script/leetcode/editor/cn/doc/[124]\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214.py"
rename to "script/[124]\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214.py"
index 96851b2..61e93a2 100644
--- "a/script/leetcode/editor/cn/doc/[124]\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214.py"
+++ "b/script/[124]\344\272\214\345\217\211\346\240\221\344\270\255\347\232\204\346\234\200\345\244\247\350\267\257\345\276\204\345\222\214.py"
@@ -27,10 +27,11 @@
# 提示：
#
#
-# 树中节点数目范围是 [1, 3 * 10⁴]
+# 树中节点数目范围是 [1, 3 * 104]
# -1000 <= Node.val <= 1000
#
-# Related Topics 树 深度优先搜索 动态规划 二叉树 👍 1657 👎 0
+# Related Topics 树 深度优先搜索 动态规划 二叉树
+# 👍 1663 👎 0
# leetcode submit region begin(Prohibit modification and deletion)
@@ -42,4 +43,16 @@
# self.right = right
class Solution:
def maxPathSum(self, root: Optional[TreeNode]) -> int:
+ maxpath = -2**31
+
+ def dfs(root):
+ nonlocal maxpath
+ if not root:
+ return 0
+ left = max(dfs(root.left),0)
+ right = max(dfs(root.right),0)
+ maxpath = max(left+right+root.val, maxpath)
+ return max(left, right) + root.val
+ dfs(root)
+ return maxpath
# leetcode submit region end(Prohibit modification and deletion)
diff --git "a/script/[654]\346\234\200\345\244\247\344\272\214\345\217\211\346\240\221.py" "b/script/[654]\346\234\200\345\244\247\344\272\214\345\217\211\346\240\221.py"
new file mode 100644
index 0000000..200f40b
--- /dev/null
+++ "b/script/[654]\346\234\200\345\244\247\344\272\214\345\217\211\346\240\221.py"
@@ -0,0 +1,71 @@
+# 给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:
+#
+#
+# 创建一个根节点，其值为 nums 中的最大值。
+# 递归地在最大值 左边 的 子数组前缀上 构建左子树。
+# 递归地在最大值 右边 的 子数组后缀上 构建右子树。
+#
+#
+# 返回 nums 构建的 最大二叉树 。
+#
+#
+#
+# 示例 1：
+#
+#
+# 输入：nums = [3,2,1,6,0,5]
+# 输出：[6,3,5,null,2,0,null,null,1]
+# 解释：递归调用如下所示：
+# - [3,2,1,6,0,5] 中的最大值是 6 ，左边部分是 [3,2,1] ，右边部分是 [0,5] 。
+# - [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1] 。
+# - 空数组，无子节点。
+# - [2,1] 中的最大值是 2 ，左边部分是 [] ，右边部分是 [1] 。
+# - 空数组，无子节点。
+# - 只有一个元素，所以子节点是一个值为 1 的节点。
+# - [0,5] 中的最大值是 5 ，左边部分是 [0] ，右边部分是 [] 。
+# - 只有一个元素，所以子节点是一个值为 0 的节点。
+# - 空数组，无子节点。
+#
+#
+# 示例 2：
+#
+#
+# 输入：nums = [3,2,1]
+# 输出：[3,null,2,null,1]
+#
+#
+#
+#
+# 提示：
+#
+#
+# 1 <= nums.length <= 1000
+# 0 <= nums[i] <= 1000
+# nums 中的所有整数 互不相同
+#
+# Related Topics 栈 树 数组 分治 二叉树 单调栈
+# 👍 460 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+# Definition for a binary tree node.
+# class TreeNode:
+# def __init__(self, val=0, left=None, right=None):
+# self.val = val
+# self.left = left
+# self.right = right
+class Solution:
+ def constructMaximumBinaryTree(self, nums: List[int]) -> TreeNode:
+ def dfs(start, end):
+ if start>end:
+ return None
+ if start==end:
+ return TreeNode(nums[start])
+ maxval = max(nums[start:(end+1)])
+ pos = nums.index(maxval)
+ root=TreeNode(maxval)
+ root.left = dfs(start, pos-1)
+ root.right = dfs(pos+1, end)
+ return root
+ return dfs(0, len(nums)-1)
+# leetcode submit region end(Prohibit modification and deletion)
diff --git "a/script/leetcode/editor/cn/doc/[110]\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.py" "b/script/leetcode/editor/cn/doc/[110]\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.py"
deleted file mode 100644
index 3fc60a9..0000000
--- "a/script/leetcode/editor/cn/doc/[110]\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.py"
+++ /dev/null
@@ -1,52 +0,0 @@
-# 给定一个二叉树，判断它是否是高度平衡的二叉树。
-#
-# 本题中，一棵高度平衡二叉树定义为：
-#
-#
-# 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。
-#
-#
-#
-#
-# 示例 1：
-#
-#
-# 输入：root = [3,9,20,null,null,15,7]
-# 输出：true
-#
-#
-# 示例 2：
-#
-#
-# 输入：root = [1,2,2,3,3,null,null,4,4]
-# 输出：false
-#
-#
-# 示例 3：
-#
-#
-# 输入：root = []
-# 输出：true
-#
-#
-#
-#
-# 提示：
-#
-#
-# 树中的节点数在范围 [0, 5000] 内
-# -10⁴ <= Node.val <= 10⁴
-#
-# Related Topics 树 深度优先搜索 二叉树 👍 1075 👎 0
-
-
-# leetcode submit region begin(Prohibit modification and deletion)
-# Definition for a binary tree node.
-# class TreeNode:
-# def __init__(self, val=0, left=None, right=None):
-# self.val = val
-# self.left = left
-# self.right = right
-class Solution:
- def isBalanced(self, root: TreeNode) -> bool:
-# leetcode submit region end(Prohibit modification and deletion)
diff --git "a/script/leetcode/editor/cn/doc/[173]\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\277\255\344\273\243\345\231\250.py" "b/script/leetcode/editor/cn/doc/[173]\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\277\255\344\273\243\345\231\250.py"
deleted file mode 100644
index 1b10584..0000000
--- "a/script/leetcode/editor/cn/doc/[173]\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\277\255\344\273\243\345\231\250.py"
+++ /dev/null
@@ -1,86 +0,0 @@
-# 实现一个二叉搜索树迭代器类BSTIterator ，表示一个按中序遍历二叉搜索树（BST）的迭代器：
-#
-#
-#
-# BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构造函数的一部分给出
-# 。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。
-# boolean hasNext() 如果向指针右侧遍历存在数字，则返回 true ；否则返回 false 。
-# int next()将指针向右移动，然后返回指针处的数字。
-#
-#
-# 注意，指针初始化为一个不存在于 BST 中的数字，所以对 next() 的首次调用将返回 BST 中的最小元素。
-#
-#
-#
-# 你可以假设 next() 调用总是有效的，也就是说，当调用 next() 时，BST 的中序遍历中至少存在一个下一个数字。
-#
-#
-#
-# 示例：
-#
-#
-# 输入
-# ["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next",
-# "hasNext", "next", "hasNext"]
-# [[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
-# 输出
-# [null, 3, 7, true, 9, true, 15, true, 20, false]
-#
-# 解释
-# BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]);
-# bSTIterator.next(); // 返回 3
-# bSTIterator.next(); // 返回 7
-# bSTIterator.hasNext(); // 返回 True
-# bSTIterator.next(); // 返回 9
-# bSTIterator.hasNext(); // 返回 True
-# bSTIterator.next(); // 返回 15
-# bSTIterator.hasNext(); // 返回 True
-# bSTIterator.next(); // 返回 20
-# bSTIterator.hasNext(); // 返回 False
-#
-#
-#
-#
-# 提示：
-#
-#
-# 树中节点的数目在范围 [1, 10⁵] 内
-# 0 <= Node.val <= 10⁶
-# 最多调用 10⁵ 次 hasNext 和 next 操作
-#
-#
-#
-#
-# 进阶：
-#
-#
-# 你可以设计一个满足下述条件的解决方案吗？next() 和 hasNext() 操作均摊时间复杂度为 O(1) ，并使用 O(h) 内存。其中 h 是树的高
-# 度。
-#
-# Related Topics 栈 树 设计 二叉搜索树 二叉树 迭代器 👍 619 👎 0
-
-
-# leetcode submit region begin(Prohibit modification and deletion)
-# Definition for a binary tree node.
-# class TreeNode:
-# def __init__(self, val=0, left=None, right=None):
-# self.val = val
-# self.left = left
-# self.right = right
-class BSTIterator:
-
- def __init__(self, root: TreeNode):
-
-
- def next(self) -> int:
-
-
- def hasNext(self) -> bool:
-
-
-
-# Your BSTIterator object will be instantiated and called as such:
-# obj = BSTIterator(root)
-# param_1 = obj.next()
-# param_2 = obj.hasNext()
-# leetcode submit region end(Prohibit modification and deletion)
diff --git "a/\346\240\221\346\200\273\347\273\223.md" "b/\346\240\221\346\200\273\347\273\223.md"
index 3800dbf..5d3414c 100644
--- "a/\346\240\221\346\200\273\347\273\223.md"
+++ "b/\346\240\221\346\200\273\347\273\223.md"
@@ -2273,6 +2273,71 @@ Tips
2. 外层递归加入是否遍历当前节点的选择，可以遍历可以不遍历，每一步只判断当前节点是否符合要求，并向下一个节点进行递归
+### 437 路经总和III
+
+给定一个二叉树的根节点 root ，和一个整数 targetSum ，求该二叉树里节点值之和等于 targetSum 的 路径 的数目。
+
+路径 不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。
+
+
+
+示例 1：
+
+输入：root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8
+输出：3
+解释：和等于 8 的路径有 3 条，如图所示。
+
+示例 2：
+
+输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
+输出：3
+
+
+
+提示:
+
+ 二叉树的节点个数的范围是 [0,1000]
+ -109 <= Node.val <= 109
+ -1000 <= targetSum <= 1000
+
+
+
+1. 两层递归
+
+```python
+# Definition for a binary tree node.
+# class TreeNode:
+# def __init__(self, val=0, left=None, right=None):
+# self.val = val
+# self.left = left
+# self.right = right
+class Solution:
+ def pathSum(self, root: TreeNode, targetSum: int) -> int:
+ if not root:
+ return 0
+ def dfs(root, target):
+ if not root:
+ return 0
+ if target==root.val:
+ mid = 1
+ else:
+ mid =0
+ left = dfs(root.left, target-root.val)
+ right = dfs(root.right, target-root.val)
+ return mid+left+right
+ return dfs(root, targetSum)+self.pathSum(root.left, targetSum)+ self.pathSum(root.right, targetSum)
+
+```
+
+
+
+Tips
+
+1. 内层递归就是常规的路径求和，区别在于不再中间停止，只在中间记录等于target的路径进行累加
+2. 外层递归加入是否遍历当前节点的选择，可以遍历可以不遍历，每一步只判断当前节点是否符合要求，并向下一个节点进行递归
+
+
+
### 450. 删除二叉搜索树中的节点.md
给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。
pFad - Phonifier reborn
Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.
Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.
Alternative Proxies:
Alternative Proxy
pFad Proxy
pFad v3 Proxy
pFad v4 Proxy