feat: ^_^

Signed-off-by: Luozhou (Siyuan Cao) <luozhou.csy@alibaba-inc.com>

Author: SR2k

105.从前序与中序遍历序列构造二叉树.ts

@@ -0,0 +1,83 @@
+/*
+ * @lc app=leetcode.cn id=105 lang=typescript
+ *
+ * [105] 从前序与中序遍历序列构造二叉树
+ *
+ * https://leetcode.cn/problems/construct-binary-tree-from-preorder-and-inorder-traversal/description/
+ *
+ * algorithms
+ * Medium (71.32%)
+ * Likes:    1699
+ * Dislikes: 0
+ * Total Accepted:    406.1K
+ * Total Submissions: 569.3K
+ * Testcase Example:  '[3,9,20,15,7]\n[9,3,15,20,7]'
+ *
+ * 给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder
+ * 是同一棵树的中序遍历，请构造二叉树并返回其根节点。
+ *
+ *
+ *
+ * 示例 1:
+ *
+ *
+ * 输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
+ * 输出: [3,9,20,null,null,15,7]
+ *
+ *
+ * 示例 2:
+ *
+ *
+ * 输入: preorder = [-1], inorder = [-1]
+ * 输出: [-1]
+ *
+ *
+ *
+ *
+ * 提示:
+ *
+ *
+ * 1 <= preorder.length <= 3000
+ * inorder.length == preorder.length
+ * -3000 <= preorder[i], inorder[i] <= 3000
+ * preorder 和 inorder 均 无重复 元素
+ * inorder 均出现在 preorder
+ * preorder 保证 为二叉树的前序遍历序列
+ * inorder 保证 为二叉树的中序遍历序列
+ *
+ *
+ */
+
+import { TreeNode } from './commons/Tree'
+
+export
+// @lc code=start
+function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
+  const inOrderIndexMapping: Record<number, number> = {}
+  inorder.forEach((n, i) => {
+    inOrderIndexMapping[n] = i
+  })
+
+  function build(preBegin: number, preEnd: number, inBegin: number, inEnd: number) {
+    if (preBegin > preEnd) return null
+
+    const rootVal = preorder[preBegin]
+    const inRoot = inOrderIndexMapping[rootVal]
+
+    const leftLength = inRoot - 1 - inBegin + 1
+
+    const leftPreBegin = preBegin + 1
+    const leftPreEnd = leftPreBegin + leftLength - 1
+    const rightPreBegin = leftPreEnd + 1
+    const rightPreEnd = preEnd
+
+    const rootNode = new TreeNode(rootVal)
+    rootNode.left = build(leftPreBegin, leftPreEnd, inBegin, inRoot - 1)
+    rootNode.right = build(rightPreBegin, rightPreEnd, inRoot + 1, inEnd)
+    return rootNode
+  }
+
+  const m = preorder.length
+  return build(0, m - 1, 0, m - 1)
+}
+// @lc code=end

124.二叉树中的最大路径和.ts

@@ -0,0 +1,81 @@
+/*
+ * @lc app=leetcode.cn id=124 lang=typescript
+ *
+ * [124] 二叉树中的最大路径和
+ *
+ * https://leetcode.cn/problems/binary-tree-maximum-path-sum/description/
+ *
+ * algorithms
+ * Hard (45.21%)
+ * Likes:    1687
+ * Dislikes: 0
+ * Total Accepted:    263.6K
+ * Total Submissions: 583K
+ * Testcase Example:  '[1,2,3]'
+ *
+ * 路径 被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个
+ * 节点，且不一定经过根节点。
+ *
+ * 路径和 是路径中各节点值的总和。
+ *
+ * 给你一个二叉树的根节点 root ，返回其 最大路径和 。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ * 输入：root = [1,2,3]
+ * 输出：6
+ * 解释：最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6
+ *
+ * 示例 2：
+ *
+ *
+ * 输入：root = [-10,9,20,null,null,15,7]
+ * 输出：42
+ * 解释：最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42
+ *
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 树中节点数目范围是 [1, 3 * 10^4]
+ * -1000
+ *
+ *
+ */
+
+import { TreeNode } from './commons/Tree'
+
+export
+// @lc code=start
+function maxPathSum(root: TreeNode | null): number {
+  let result = root?.val ?? Number.MIN_SAFE_INTEGER
+
+  function helper(node: TreeNode | null) {
+    if (!node) return Number.MIN_SAFE_INTEGER
+
+    const leftResult = helper(node.left)
+    const rightResult = helper(node.right)
+
+    const singleLineResult = Math.max(
+      node.val,
+      leftResult + node.val,
+      rightResult + node.val,
+    )
+
+    result = Math.max(
+      result,
+      singleLineResult,
+      node.val + leftResult + rightResult,
+    )
+    return singleLineResult
+  }
+
+  helper(root)
+  return result
+}
+// @lc code=end

128.最长连续序列.py

@@ -0,0 +1,72 @@
+#
+# @lc app=leetcode.cn id=128 lang=python3
+#
+# [128] 最长连续序列
+#
+# https://leetcode.cn/problems/longest-consecutive-sequence/description/
+#
+# algorithms
+# Medium (55.15%)
+# Likes:    1374
+# Dislikes: 0
+# Total Accepted:    308.7K
+# Total Submissions: 559.8K
+# Testcase Example:  '[100,4,200,1,3,2]'
+#
+# 给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。
+# 
+# 请你设计并实现时间复杂度为 O(n) 的算法解决此问题。
+# 
+# 
+# 
+# 示例 1：
+# 
+# 
+# 输入：nums = [100,4,200,1,3,2]
+# 输出：4
+# 解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。
+# 
+# 示例 2：
+# 
+# 
+# 输入：nums = [0,3,7,2,5,8,4,6,0,1]
+# 输出：9
+# 
+# 
+# 
+# 
+# 提示：
+# 
+# 
+# 0 
+# -10^9 
+# 
+# 
+#
+
+# @lc code=start
+class Solution:
+    def longestConsecutive(self, nums: list[int]) -> int:
+        num_set = set(nums)
+        result = 0
+
+        while num_set:
+            n = num_set.pop()
+            curr = 1
+
+            x = n - 1
+            while x in num_set:
+                curr += 1
+                num_set.remove(x)
+                x = x - 1
+
+            x = n + 1
+            while x in num_set:
+                curr += 1
+                num_set.remove(x)
+                x = x + 1
+
+            result = max(result, curr)
+
+        return result
+# @lc code=end

133.克隆图.ts

@@ -0,0 +1,133 @@
+/*
+ * @lc app=leetcode.cn id=133 lang=typescript
+ *
+ * [133] 克隆图
+ *
+ * https://leetcode.cn/problems/clone-graph/description/
+ *
+ * algorithms
+ * Medium (68.53%)
+ * Likes:    530
+ * Dislikes: 0
+ * Total Accepted:    99.8K
+ * Total Submissions: 145.5K
+ * Testcase Example:  '[[2,4],[1,3],[2,4],[1,3]]'
+ *
+ * 给你无向 连通 图中一个节点的引用，请你返回该图的 深拷贝（克隆）。
+ *
+ * 图中的每个节点都包含它的值 val（int） 和其邻居的列表（list[Node]）。
+ *
+ * class Node {
+ * ⁠   public int val;
+ * ⁠   public List<Node> neighbors;
+ * }
+ *
+ *
+ *
+ * 测试用例格式：
+ *
+ * 简单起见，每个节点的值都和它的索引相同。例如，第一个节点值为 1（val = 1），第二个节点值为 2（val =
+ * 2），以此类推。该图在测试用例中使用邻接列表表示。
+ *
+ * 邻接列表 是用于表示有限图的无序列表的集合。每个列表都描述了图中节点的邻居集。
+ *
+ * 给定节点将始终是图中的第一个节点（值为 1）。你必须将 给定节点的拷贝 作为对克隆图的引用返回。
+ *
+ *
+ *
+ * 示例 1：
+ *
+ *
+ *
+ * 输入：adjList = [[2,4],[1,3],[2,4],[1,3]]
+ * 输出：[[2,4],[1,3],[2,4],[1,3]]
+ * 解释：
+ * 图中有 4 个节点。
+ * 节点 1 的值是 1，它有两个邻居：节点 2 和 4 。
+ * 节点 2 的值是 2，它有两个邻居：节点 1 和 3 。
+ * 节点 3 的值是 3，它有两个邻居：节点 2 和 4 。
+ * 节点 4 的值是 4，它有两个邻居：节点 1 和 3 。
+ *
+ *
+ * 示例 2：
+ *
+ *
+ *
+ * 输入：adjList = [[]]
+ * 输出：[[]]
+ * 解释：输入包含一个空列表。该图仅仅只有一个值为 1 的节点，它没有任何邻居。
+ *
+ *
+ * 示例 3：
+ *
+ * 输入：adjList = []
+ * 输出：[]
+ * 解释：这个图是空的，它不含任何节点。
+ *
+ *
+ * 示例 4：
+ *
+ *
+ *
+ * 输入：adjList = [[2],[1]]
+ * 输出：[[2],[1]]
+ *
+ *
+ *
+ * 提示：
+ *
+ *
+ * 节点数不超过 100 。
+ * 每个节点值 Node.val 都是唯一的，1 <= Node.val <= 100。
+ * 无向图是一个简单图，这意味着图中没有重复的边，也没有自环。
+ * 由于图是无向的，如果节点 p 是节点 q 的邻居，那么节点 q 也必须是节点 p 的邻居。
+ * 图是连通图，你可以从给定节点访问到所有节点。
+ *
+ *
+ */
+
+class Node {
+  val: number
+
+  neighbors: Node[]
+
+  constructor(val?: number, neighbors?: Node[]) {
+    this.val = (val === undefined ? 0 : val)
+    this.neighbors = (neighbors === undefined ? [] : neighbors)
+  }
+}
+
+export
+// @lc code=start
+function cloneGraph(node: Node | null): Node | null {
+  if (!node) return null
+
+  const stack = [node]
+  const mapping = new Map<Node, Node>()
+  const clonedSet = new Set(stack)
+
+  const getOrCreate = (original: Node) => {
+    if (!mapping.has(original)) {
+      const c = new Node(original.val)
+      mapping.set(original, c)
+    }
+    return mapping.get(original)!
+  }
+
+  while (stack.length) {
+    const original = stack.pop()!
+    const cloned = getOrCreate(original)
+
+    for (const n of original.neighbors) {
+      cloned.neighbors.push(getOrCreate(n))
+
+      if (!clonedSet.has(n)) {
+        clonedSet.add(n)
+        stack.push(n)
+      }
+    }
+  }
+
+  return mapping.get(node)!
+}
+// @lc code=end