add new solution

Author: DSXiangLi

script/[173]二叉搜索树迭代器.py

@@ -0,0 +1,100 @@
+# 实现一个二叉搜索树迭代器类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, 105] 内 
+#  0 <= Node.val <= 106 
+#  最多调用 105 次 hasNext 和 next 操作 
+#  
+# 
+#  
+# 
+#  进阶： 
+# 
+#  
+#  你可以设计一个满足下述条件的解决方案吗？next() 和 hasNext() 操作均摊时间复杂度为 O(1) ，并使用 O(h) 内存。其中 h 是树的高
+# 度。 
+#  
+#  Related Topics 栈 树 设计 二叉搜索树 二叉树 迭代器 
+#  👍 620 👎 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):
+        self.root = root
+        self.stack = []
+        while self.root:
+            self.stack.append(self.root)
+            self.root = self.root.left
+
+    def next(self) -> int:
+        node = self.stack.pop()
+        root = node.right
+        while root:
+            self.stack.append(root)
+            root = root.left
+        return node.val
+
+    def hasNext(self) -> bool:
+        if self.stack:
+            return True
+        else:
+            return False
+
+
+
+# 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)

script/[437]路径总和 III.py

@@ -0,0 +1,68 @@
+# 给定一个二叉树的根节点 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 
+#  
+#  Related Topics 树 深度优先搜索 二叉树 
+#  👍 1398 👎 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 pathSum(self, root: Optional[TreeNode], targetSum: int) -> int:
+        def helper(root, targetSum):
+            if not root:
+                return 0
+            # 注意这里不要返回因为在node.val可能<0
+            if targetSum==root.val:
+                mid =1
+            else:
+                mid=0
+            left = helper(root.left, targetSum-root.val)
+            right = helper(root.right, targetSum-root.val)
+            return left + right+mid
+
+        def dfs(root, target):
+            if not root:
+                return 0
+            left = dfs(root.left, target)
+            right = dfs(root.right, target)
+            mid = helper(root, target)
+            return left+right+mid
+        return dfs(root, targetSum)
+
+
+# leetcode submit region end(Prohibit modification and deletion)

script/[623]在二叉树中增加一行.py

@@ -0,0 +1,79 @@
+# 给定一个二叉树的根 root 和两个整数 val 和 depth ，在给定的深度 depth 处添加一个值为 val 的节点行。 
+# 
+#  注意，根节点 root 位于深度 1 。 
+# 
+#  加法规则如下: 
+# 
+#  
+#  给定整数 depth，对于深度为 depth - 1 的每个非空树节点 cur ，创建两个值为 val 的树节点作为 cur 的左子树根和右子树根。 
+#  cur 原来的左子树应该是新的左子树根的左子树。 
+#  cur 原来的右子树应该是新的右子树根的右子树。 
+#  如果 depth == 1 意味着 depth - 1 根本没有深度，那么创建一个树节点，值 val 作为整个原始树的新根，而原始树就是新根的左子树。 
+#  
+# 
+#  
+# 
+#  示例 1: 
+# 
+#  
+# 
+#  
+# 输入: root = [4,2,6,3,1,5], val = 1,
+#
+# depth = 2
+# 输出: [4,1,1,2,null,null,6,3,1,5] 
+# 
+#  示例 2: 
+# 
+#  
+# 
+#  
+# 输入: root = [4,2,null,3,1], val = 1, depth = 3
+# 输出:  [4,2,null,1,1,3,null,null,1]
+#  
+# 
+#  
+# 
+#  提示: 
+# 
+#  
+#  节点数在 [1, 104] 范围内 
+#  树的深度在 [1, 104]范围内 
+#  -100 <= Node.val <= 100 
+#  -105 <= val <= 105 
+#  1 <= depth <= the depth of tree + 1 
+#  
+#  Related Topics 树 深度优先搜索 广度优先搜索 二叉树 
+#  👍 122 👎 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 addOneRow(self, root: TreeNode, val: int, depth: int) -> TreeNode:
+        def dfs(root, depth):
+            if not root:
+                return None
+            if depth ==1:
+                node = TreeNode(val)
+                node.left =root
+                return node
+            if depth==2:
+                left =TreeNode(val)
+                right = TreeNode(val)
+                left.left = root.left
+                right.right = root.right
+                root.left = left
+                root.right = right
+                return root
+            root.left = dfs(root.left, depth-1)
+            root.right = dfs(root.right, depth-1)
+            return root
+        return dfs(root, depth )
+
+# leetcode submit region end(Prohibit modification and deletion)

script/[62]不同路径.py

@@ -0,0 +1,64 @@
+# 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。 
+# 
+#  机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。 
+# 
+#  问总共有多少条不同的路径？ 
+# 
+#  
+# 
+#  示例 1： 
+# 
+#  
+# 输入：m = 3, n = 7
+# 输出：28 
+# 
+#  示例 2： 
+# 
+#  
+# 输入：m = 3, n = 2
+# 输出：3
+# 解释：
+# 从左上角开始，总共有 3 条路径可以到达右下角。
+# 1. 向右 -> 向下 -> 向下
+# 2. 向下 -> 向下 -> 向右
+# 3. 向下 -> 向右 -> 向下
+#  
+# 
+#  示例 3： 
+# 
+#  
+# 输入：m = 7, n = 3
+# 输出：28
+#  
+# 
+#  示例 4： 
+# 
+#  
+# 输入：m = 3, n = 3
+# 输出：6 
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  1 <= m, n <= 100 
+#  题目数据保证答案小于等于 2 * 109 
+#  
+#  Related Topics 数学 动态规划 组合数学 
+#  👍 1468 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def uniquePaths(self, m: int, n: int) -> int:
+        dp = [[0] *n for i in range(m)]
+        for i in range(n):
+            dp[0][i] =1
+        for i in range(m):
+            dp[i][0] =1
+        for i in range(1,m):
+            for j in range(1,n):
+                dp[i][j] = dp[i-1][j] + dp[i][j-1]
+        return dp[-1][-1]
+# leetcode submit region end(Prohibit modification and deletion)

script/[63]不同路径 II.py

@@ -0,0 +1,63 @@
+# 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。 
+# 
+#  机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。 
+# 
+#  现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？ 
+# 
+#  网格中的障碍物和空位置分别用 1 和 0 来表示。 
+# 
+#  
+# 
+#  示例 1： 
+# 
+#  
+# 输入：obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
+# 输出：2
+# 解释：3x3 网格的正中间有一个障碍物。
+# 从左上角到右下角一共有 2 条不同的路径：
+# 1. 向右 -> 向右 -> 向下 -> 向下
+# 2. 向下 -> 向下 -> 向右 -> 向右
+#  
+# 
+#  示例 2： 
+# 
+#  
+# 输入：obstacleGrid = [[0,1],[0,0]]
+# 输出：1
+#  
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  m == obstacleGrid.length 
+#  n == obstacleGrid[i].length 
+#  1 <= m, n <= 100 
+#  obstacleGrid[i][j] 为 0 或 1 
+#  
+#  Related Topics 数组 动态规划 矩阵 
+#  👍 838 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
+        m = len(obstacleGrid)
+        n = len(obstacleGrid[0])
+        dp = [[0] *n for i in range(m)]
+        for i in range(n):
+            if obstacleGrid[0][i]==1:
+                break
+            dp[0][i] =1
+        for i in range(m):
+            if obstacleGrid[i][0]==1:
+                break
+            dp[i][0] =1
+        for i in range(1,m):
+            for j in range(1,n):
+                if obstacleGrid[i][j]==1:
+                    continue
+                dp[i][j] = dp[i-1][j] + dp[i][j-1]
+        return dp[-1][-1]
+# leetcode submit region end(Prohibit modification and deletion)