递归专题代码上传

Author: StrayCamel247

README.md

@@ -1,6 +1,7 @@
 # leetcode
-leetcode解题得的源码，解题思路在代码的注释里。
+leetcode解题的源码，解题思路在代码的注释里。
 - 我的[leetcode主页](https://leetcode-cn.com/u/stray_camel/)
 
 ## python@leetcode官方专题
-> 记录刷官方专题的题目
+> 记录刷官方专题的题目
+- [递归专题](/python@leetcode官方递归专题.md)

main.py

@@ -14,22 +14,35 @@
 # print(str(id_x.fixed[0])+'.反转字符串.py')
 
 
-def _search(name):
+def _search(name=''):
+    name = name.split(' ')
+    res = 0
     for _ in _listdir:
-        if name in _:
+        if isinstance(name, list):
+            for n in name:
+                if n in _:
+                    # logging.info(os.path.join(questions_floder, _))
+                    logging.info(questions_floder+'/'+_)
+                    res +=1
+        if isinstance(name, str) and name in _:
             # logging.info(os.path.join(questions_floder, _))
             logging.info(questions_floder+'/'+_)
-            break
-    return _
+            res +=1
+    return res
 
 
 if __name__ == "__main__":
-    # _search('杨辉三角')
-    def test(k):
-        tmp = k
-        res = [0 for _ in range(5)]
-        res2 = [str(_)+tmp for _ in res]
-
-
-    # print(res, res2)
-    test(01)
+    names = sys.argv[1:]
+    for n in names:
+        logging.info('查找{name}问题...'.format(name=n))
+        res = _search(n)
+        if not res:logging.warn('没找到{name}问题'.format(name=n))
+        print()
+    # def test(k):
+    #     tmp = k
+    #     res = [0 for _ in range(5)]
+    #     res2 = [str(_)+tmp for _ in res]
+
+
+    # # print(res, res2)
+    # test(01)

python@leetcode官方专题.md renamed to python@leetcode官方递归专题.md

@@ -2,7 +2,7 @@
 
 ## 递归专题
 [官方专题](https://leetcode-cn.com/leetbook/read/recursion/xk5vw2/)
-
+> 专题描述
 递归 是计算机科学中的一个重要概念。它是许多其他算法和数据结构的基础。然而，对于许多初学者来说，掌握它可能是一件非常棘手的事情。
 
 在开始探索本 LeetBook 之前，我们强烈建议您预先完成 二叉树 和 队列 & 栈 这两本 LeetBook 。
@@ -15,18 +15,18 @@
 如何更好地运用递归？
 完成后，你会对采用递归思想解决问题和自己分析算法的复杂度更有信心。
 
+## 递归专题涉及到的题目
 - [反转字符串](./questions/344.反转字符串.py)
 - [两两交换链表中的节点](./questions/24.两两交换链表中的节点.py)
 - [杨辉三角](./questions/118.杨辉三角.py)
-- [杨辉三角 II]
-- [反转链表]
-- [斐波那契数]
-- [爬楼梯]
-- [二叉树的最大深度]
-- [二叉树的最大深度]
-- [Pow(x, n)]
-- [Pow(x, n)]
-- [合并两个有序链表]
-- [第K个语法符号]
-- [不同的二叉搜索树 II]
-- [不同的二叉搜索树 II]
+- [杨辉三角 II](./questions/119.杨辉三角-ii.py)
+- [反转链表](./questions/206.反转链表.py)
+- [斐波那契数](./questions/509.斐波那契数.py)
+- [爬楼梯](./questions/70.爬楼梯.py)
+- [二叉树的最大深度](./questions/104.二叉树的最大深度.py)
+- [二叉树的最大宽度](./questions/662.二叉树最大宽度.py)
+- [Pow(x, n)](./questions/50.pow-x-n.py)
+- [合并两个有序链表](./questions/21.合并两个有序链表.py)
+- [第K个语法符号](./questions/779.第k个语法符号.py)
+- [不同的二叉搜索树](./questions/96.不同的二叉搜索树.py)
+- [不同的二叉搜索树 II](./questions/95.不同的二叉搜索树-ii.py)

questions/104.二叉树的最大深度.py

@@ -0,0 +1,53 @@
+#
+# @lc app=leetcode.cn id=104 lang=python3
+#
+# [104] 二叉树的最大深度
+#
+# https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/description/
+#
+# algorithms
+# Easy (74.98%)
+# Likes:    697
+# Dislikes: 0
+# Total Accepted:    274K
+# Total Submissions: 365.2K
+# Testcase Example:  '[3,9,20,null,null,15,7]'
+#
+# 给定一个二叉树，找出其最大深度。
+# 
+# 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
+# 
+# 说明: 叶子节点是指没有子节点的节点。
+# 
+# 示例：
+# 给定二叉树 [3,9,20,null,null,15,7]，
+# 
+# ⁠   3
+# ⁠  / \
+# ⁠ 9  20
+# ⁠   /  \
+# ⁠  15   7
+# 
+# 返回它的最大深度 3 。
+# 
+#
+
+# @lc code=start
+# Definition for a binary tree node.
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def maxDepth(self, root: TreeNode) -> int:
+        if not root:return 0
+        # if root.left:
+        #     return 1+self.maxDepth(root.left)
+        # if root.right:
+        #     return 1+maxDepth(root.right)
+        return 1+max(self.maxDepth(root.left),self.maxDepth(root.right))
+# @lc code=end
+

questions/50.pow-x-n.py

@@ -8,13 +8,13 @@
 class Solution:
     def myPow(self, x: float, n: int) -> float:
         # 二分法 log(n)
-        def quickMul(N):
+        def _help(N):
             if N == 0:
                 return 1.0
-            y = quickMul(N // 2)
+            y = _help(N // 2)
             return y * y if N % 2 == 0 else y * y * x
 
-        return quickMul(n) if n >= 0 else 1.0 / quickMul(-n)
+        return _help(n) if n >= 0 else 1.0 / _help(-n)
 
 # @lc code=end
 

questions/509.斐波那契数.py

@@ -3,13 +3,63 @@
 #
 # [509] 斐波那契数
 #
-
+from functools import lru_cache
 # @lc code=start
+
+
 class Solution:
-    def fib(self, N: int) -> int:
+    def __init__(self):
+        super().__init__()
+        self.constants = [[1, 1], [1, 0]]
+
+    @lru_cache(None)
+    def reversion(self, N: int) -> int:
         if N < 2:
+            return self.fub(N-1)+self.fib(N-2)
+
+    def matrix_pow(self, N: int) -> int:
+        """矩阵法
+        """
+        def multiply(A: list, B: list):
+            x = A[0][0] * B[0][0] + A[0][1] * B[1][0]
+            y = A[0][0] * B[0][1] + A[0][1] * B[1][1]
+            z = A[1][0] * B[0][0] + A[1][1] * B[1][0]
+            w = A[1][0] * B[0][1] + A[1][1] * B[1][1]
+
+            A[0][0] = x
+            A[0][1] = y
+            A[1][0] = z
+            A[1][1] = w
+
+        def matrix_power(A: list, N: int):
+            if (N <= 1):
+                return A
+            matrix_power(A, N//2)
+            multiply(A, A)
+            B = self.constants
+            if (N % 2 != 0):
+                multiply(A, B)
+        if (N <= 1):
             return N
-        return self.fib(N-1)+self.fib(N-2)
-        
-# @lc code=end
+        A = self.constants
+        matrix_power(A, N-1)
+        return A[0][0]
 
+    def the_Golden_Ratio(self, N: int) -> int:
+        # 根据黄金分割比生成斐波那契
+        golden_ratio = (1 + 5 ** 0.5) / 2
+        return int((golden_ratio ** N + 1) / 5 ** 0.5)
+
+    @lru_cache(None)
+    def fib(self, N: int) -> int:
+        return {
+            1: lambda N: self.matrix_pow(N),
+            2: lambda N: self.reversion(N),
+            3: lambda N: self.the_Golden_Ratio(N)
+        }[3](N)
+
+
+# @lc code=end
+if __name__ == "__main__":
+    test = Solution()
+    print(test.fib(2))

questions/662.二叉树最大宽度.py

@@ -11,14 +11,29 @@
 #         self.val = x
 #         self.left = None
 #         self.right = None
-
 class Solution:
-    def maxDepth(self, root: TreeNode) -> int:
-        if not root:return 0
-        # if root.left:
-        #     return 1+self.maxDepth(root.left)
-        # if root.right:
-        #     return 1+maxDepth(root.right)
-        return 1+max(self.maxDepth(root.left),self.maxDepth(root.right))
+    def __init__(self):
+        self.leftIds = []
+        self.widths = []
+    
+    def widthOfBinaryTree(self, root: TreeNode) -> int:
+        return self.dfs(root, 0, 0)
+    
+    def dfs(self, node, depth, id):
+        # node: current node of the current layer
+        # depth: depth of a tree, starting from 0
+        # id: current id of the node
+        # returns the max width of all layers
+        if node == None:
+            return 0
+        if len(self.leftIds) == depth:
+            self.leftIds.append(id)
+            self.widths.append(1)
+        else:
+            self.widths[depth] = id - self.leftIds[depth] + 1
+            
+        leftMaxWidth = self.dfs(node.left, depth + 1, id * 2)
+        rightMaxWidth = self.dfs(node.right, depth + 1, id * 2 + 1)
+            
+        return max(max(leftMaxWidth, rightMaxWidth), self.widths[depth])
 # @lc code=end
-

questions/70.爬楼梯.py

@@ -0,0 +1,53 @@
+#
+# @lc app=leetcode.cn id=70 lang=python3
+#
+# [70] 爬楼梯
+#
+# https://leetcode-cn.com/problems/climbing-stairs/description/
+#
+# algorithms
+# Easy (50.51%)
+# Likes:    1229
+# Dislikes: 0
+# Total Accepted:    284.4K
+# Total Submissions: 562.5K
+# Testcase Example:  '2'
+#
+# 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
+# 
+# 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
+# 
+# 注意：给定 n 是一个正整数。
+# 
+# 示例 1：
+# 
+# 输入： 2
+# 输出： 2
+# 解释： 有两种方法可以爬到楼顶。
+# 1.  1 阶 + 1 阶
+# 2.  2 阶
+# 
+# 示例 2：
+# 
+# 输入： 3
+# 输出： 3
+# 解释： 有三种方法可以爬到楼顶。
+# 1.  1 阶 + 1 阶 + 1 阶
+# 2.  1 阶 + 2 阶
+# 3.  2 阶 + 1 阶
+# 
+# 
+#
+
+# @lc code=start
+from functools import lru_cache
+class Solution:
+    def __init__(self):
+        self.res = []
+    @lru_cache(None)
+    def climbStairs(self, n: int) -> int:
+        if n <4:
+            return n
+        return self.climbStairs(n-1)+self.climbStairs(n-2)
+# @lc code=end
+

questions/724.寻找数组的中心索引.py

@@ -0,0 +1,57 @@
+#
+# @lc app=leetcode.cn id=724 lang=python3
+#
+# [724] 寻找数组的中心索引
+#
+# https://leetcode-cn.com/problems/find-pivot-index/description/
+#
+# algorithms
+# Easy (38.36%)
+# Likes:    219
+# Dislikes: 0
+# Total Accepted:    59K
+# Total Submissions: 153.4K
+# Testcase Example:  '[1,7,3,6,5,6]'
+#
+# 给定一个整数类型的数组 nums，请编写一个能够返回数组 “中心索引” 的方法。
+# 
+# 我们是这样定义数组 中心索引 的：数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。
+# 
+# 如果数组不存在中心索引，那么我们应该返回 -1。如果数组有多个中心索引，那么我们应该返回最靠近左边的那一个。
+# 
+# 
+# 
+# 示例 1：
+# 
+# 输入：
+# nums = [1, 7, 3, 6, 5, 6]
+# 输出：3
+# 解释：
+# 索引 3 (nums[3] = 6) 的左侧数之和 (1 + 7 + 3 = 11)，与右侧数之和 (5 + 6 = 11) 相等。
+# 同时, 3 也是第一个符合要求的中心索引。
+# 
+# 
+# 示例 2：
+# 
+# 输入：
+# nums = [1, 2, 3]
+# 输出：-1
+# 解释：
+# 数组中不存在满足此条件的中心索引。
+# 
+# 
+# 
+# 说明：
+# 
+# 
+# nums 的长度范围为 [0, 10000]。
+# 任何一个 nums[i] 将会是一个范围在 [-1000, 1000]的整数。
+# 
+# 
+#
+
+# @lc code=start
+class Solution:
+    def pivotIndex(self, nums: List[int]) -> int:
+# @lc code=end
+