chore: update lc problems (doocs#1153)

Author: yanglbme

solution/2100-2199/2132.Stamping the Grid/README_EN.md

@@ -56,7 +56,7 @@ Apparently, we can maintain a two-dimensional prefix sum array, and in `O(1)` ti
 
 Since the action of affixing a stamp can be generalized to setting the values of all cells in the current sub-area to `1`, it's natural to think of maintaining the state after stamp affixing using a two-dimensional difference array.
 
-Finally, just calculate the two-dimensional prefix sum for this difference array again. 
+Finally, just calculate the two-dimensional prefix sum for this difference array again.
 
 If the sum of the current cell is `0`, it means there are cases that have not been completely covered, and you can directly return `false`.
 
@@ -196,7 +196,7 @@ impl Solution {
             for j in 0..m {
                 prefix_vec[i + 1][j + 1] = prefix_vec[i][j + 1] + prefix_vec[i + 1][j] - prefix_vec[i][j] + grid[i][j];
             }
-        } 
+        }
 
         let mut diff_vec: Vec<Vec<i32>> = vec![vec![0; m + 1]; n + 1];
 

solution/2700-2799/2764.is Array a Preorder of Some ‌Binary Tree/README.md

@@ -0,0 +1,214 @@
+# [2764. is Array a Preorder of Some ‌Binary Tree](https://leetcode.cn/problems/is-array-a-preorder-of-some-binary-tree)
+
+[English Version](/solution/2700-2799/2764.is%20Array%20a%20Preorder%20of%20Some%20%E2%80%8CBinary%20Tree/README_EN.md)
+
+## 题目描述
+
+<!-- 这里写题目描述 -->
+
+<p>Given a <strong>0-indexed</strong> integer <strong>2D array</strong> <code>nodes</code>, your task is to determine if the given array represents the <strong>preorder</strong> traversal of some <strong>binary</strong> tree.</p>
+
+<p>For each index <code>i</code>, <code>nodes[i] = [id, parentId]</code>, where <code>id</code> is the id of the node at the index <code>i</code> and <code>parentId</code> is the id of its parent in the tree (if the node has no parent, then <code>parentId = -1</code>).</p>
+
+<p>Return <code>true</code> <em>if the given array&nbsp;</em><em>represents the preorder traversal of some tree, and</em> <code>false</code> <em>otherwise.</em></p>
+
+<p><strong>Note:</strong> the <strong>preorder</strong> traversal of a tree is a recursive way to traverse a tree in which we first visit the current node, then we do the preorder traversal for the left child, and finally, we do it for the right child.</p>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nodes = [[0,-1],[1,0],[2,0],[3,2],[4,2]]
+<strong>Output:</strong> true
+<strong>Explanation:</strong> The given nodes make the tree in the picture below.
+We can show that this is the preorder traversal of the tree, first we visit node 0, then we do the preorder traversal of the right child which is [1], then we do the preorder traversal of the left child which is [2,3,4].
+</pre>
+
+<p><img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/2700-2799/2764.is%20Array%20a%20Preorder%20of%20Some%20%E2%80%8CBinary%20Tree/images/1.png" style="padding: 10px; background: #fff; border-radius: .5rem; width: 250px; height: 251px;" /></p>
+
+<p><strong class="example">Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nodes = [[0,-1],[1,0],[2,0],[3,1],[4,1]]
+<strong>Output:</strong> false
+<strong>Explanation:</strong> The given nodes make the tree in the picture below.
+For the preorder traversal, first we visit node 0, then we do the preorder traversal of the right child which is [1,3,4], but we can see that in the given order, 2 comes between 1 and 3, so, it&#39;s not the preorder traversal of the tree.
+</pre>
+
+<p><img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/2700-2799/2764.is%20Array%20a%20Preorder%20of%20Some%20%E2%80%8CBinary%20Tree/images/2.png" style="padding: 10px; background: #fff; border-radius: .5rem; width: 250px; height: 251px;" /></p>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nodes.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>nodes[i].length == 2</code></li>
+	<li><code>0 &lt;= nodes[i][0] &lt;= 10<sup>5</sup></code></li>
+	<li><code>-1 &lt;= nodes[i][1] &lt;= 10<sup>5</sup></code></li>
+	<li>The input is generated such that <code>nodes</code> make a binary tree.</li>
+</ul>
+
+## 解法
+
+<!-- 这里可写通用的实现逻辑 -->
+
+**方法一：DFS**
+
+我们先根据 $nodes$ 数据构建图 $g$，其中 $g[i]$ 表示节点 $i$ 的所有子节点。
+
+接下来，设计一个函数 $dfs(i)$，表示从节点 $i$ 开始进行先序遍历，用一个变量 $k$ 表示当前遍历到 $nodes$ 列表的第 $k$ 个节点，初始时 $k=0$。
+
+函数 $dfs(i)$ 的执行逻辑如下：
+
+-   如果 $i \neq nodes[k][0]$，说明当前序列不是二叉树的先序遍历序列，返回 `false`。
+-   否则，我们将 $k$ 加 $1$，然后递归搜索 $i$ 的所有子节点，如果搜索过程中发现 `false`，那么提前返回 `false`，否则搜索结束，返回 `true`。
+
+在主函数中，我们调用 $dfs(nodes[0][0])$，如果返回值为 `true`，并且 $k = |nodes|$，那么 $nodes$ 序列是二叉树的先序遍历序列，返回 `true`，否则返回 `false`。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是 $nodes$ 中的节点数目。
+
+<!-- tabs:start -->
+
+### **Python3**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```python
+class Solution:
+    def isPreorder(self, nodes: List[List[int]]) -> bool:
+        def dfs(i: int) -> int:
+            nonlocal k
+            if i != nodes[k][0]:
+                return False
+            k += 1
+            return all(dfs(j) for j in g[i])
+
+        g = defaultdict(list)
+        for i, p in nodes:
+            g[p].append(i)
+        k = 0
+        return dfs(nodes[0][0]) and k == len(nodes)
+```
+
+### **Java**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```java
+class Solution {
+    private Map<Integer, List<Integer>> g = new HashMap<>();
+    private List<List<Integer>> nodes;
+    private int k;
+
+    public boolean isPreorder(List<List<Integer>> nodes) {
+        this.nodes = nodes;
+        for (var node : nodes) {
+            g.computeIfAbsent(node.get(1), key -> new ArrayList<>()).add(node.get(0));
+        }
+        return dfs(nodes.get(0).get(0)) && k == nodes.size();
+    }
+
+    private boolean dfs(int i) {
+        if (i != nodes.get(k).get(0)) {
+            return false;
+        }
+        ++k;
+        for (int j : g.getOrDefault(i, List.of())) {
+            if (!dfs(j)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool isPreorder(vector<vector<int>>& nodes) {
+        int k = 0;
+        unordered_map<int, vector<int>> g;
+        for (auto& node : nodes) {
+            g[node[1]].push_back(node[0]);
+        }
+        function<bool(int)> dfs = [&](int i) {
+            if (i != nodes[k][0]) {
+                return false;
+            }
+            ++k;
+            for (int j : g[i]) {
+                if (!dfs(j)) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        return dfs(nodes[0][0]) && k == nodes.size();
+    }
+};
+```
+
+### **Go**
+
+```go
+func isPreorder(nodes [][]int) bool {
+	k := 0
+	g := map[int][]int{}
+	for _, node := range nodes {
+		g[node[1]] = append(g[node[1]], node[0])
+	}
+	var dfs func(int) bool
+	dfs = func(i int) bool {
+		if i != nodes[k][0] {
+			return false
+		}
+		k++
+		for _, j := range g[i] {
+			if !dfs(j) {
+				return false
+			}
+		}
+		return true
+	}
+	return dfs(nodes[0][0]) && k == len(nodes)
+}
+```
+
+### **TypeScript**
+
+```ts
+function isPreorder(nodes: number[][]): boolean {
+    let k = 0;
+    const g: Map<number, number[]> = new Map();
+    for (const [i, p] of nodes) {
+        if (!g.has(p)) {
+            g.set(p, []);
+        }
+        g.get(p)!.push(i);
+    }
+    const dfs = (i: number): boolean => {
+        if (i !== nodes[k][0]) {
+            return false;
+        }
+        ++k;
+        for (const j of g.get(i) ?? []) {
+            if (!dfs(j)) {
+                return false;
+            }
+        }
+        return true;
+    };
+    return dfs(nodes[0][0]) && k === nodes.length;
+}
+```
+
+### **...**
+
+```
+
+```
+
+<!-- tabs:end -->