feat: add solutions to lc problem: No.0836

No.0836.Rectangle Overlap

solution/0800-0899/0831.Masking Personal Information/README_EN.md

@@ -116,7 +116,11 @@ Thus, the resulting masked number is "***-***-7890".
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Simulation
+
+According to the problem description, we can first determine whether the string $s$ is an email or a phone number, and then handle it accordingly.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the string $s$.
 
 <!-- tabs:start -->
 

solution/0800-0899/0832.Flipping an Image/README.md

@@ -75,11 +75,9 @@ tags:
 
 ### 方法一：双指针
 
-我们可以遍历矩阵，对于遍历到的每一行 $row$：
+我们可以遍历矩阵，对于遍历到的每一行 $\textit{row}$，我们使用双指针 $i$ 和 $j$ 分别指向该行的首尾元素，如果 $\textit{row}[i] = \textit{row}[j]$，交换后两者的值仍然保持不变，因此，我们只需要对 $\textit{row}[i]$ 和 $\textit{row}[j]$ 进行异或反转即可，然后将 $i$ 和 $j$ 分别向中间移动一位，直到 $i \geq j$。如果 $\textit{row}[i] \neq \textit{row}[j]$，此时交换后再反转两者的值，仍然保持不变，因此，可以不进行任何操作。
 
-我们使用双指针 $i$ 和 $j$ 分别指向该行的首尾元素，如果 $row[i] = row[j]$，交换后两者的值仍然保持不变，因此，我们只需要对 $row[i]$ 和 $row[j]$ 进行异或反转即可，然后将 $i$ 和 $j$ 分别向中间移动一位，直到 $i \geq j$。如果 $row[i] \neq row[j]$，此时交换后再反转两者的值，仍然保持不变，因此，可以不进行任何操作。
-
-最后，如果 $i = j$，我们直接对 $row[i]$ 进行反转即可。
+最后，如果 $i = j$，我们直接对 $\textit{row}[i]$ 进行反转即可。
 
 时间复杂度 $O(n^2)$，其中 $n$ 是矩阵的行数或列数。空间复杂度 $O(1)$。
 

solution/0800-0899/0832.Flipping an Image/README_EN.md

@@ -69,7 +69,13 @@ Then invert the image: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Two Pointers
+
+We can traverse the matrix, and for each row $\textit{row}$, we use two pointers $i$ and $j$ pointing to the first and last elements of the row, respectively. If $\textit{row}[i] = \textit{row}[j]$, swapping them will keep their values unchanged, so we only need to XOR invert $\textit{row}[i]$ and $\textit{row}[j]$, then move $i$ and $j$ one position towards the center until $i \geq j$. If $\textit{row}[i] \neq \textit{row}[j]$, swapping and then inverting their values will also keep them unchanged, so no operation is needed.
+
+Finally, if $i = j$, we directly invert $\textit{row}[i]$.
+
+The time complexity is $O(n^2)$, where $n$ is the number of rows or columns in the matrix. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 

solution/0800-0899/0833.Find And Replace in String/README.md

@@ -87,7 +87,7 @@ tags:
 
 ### 方法一：模拟
 
-我们遍历每个替换操作，对于当前第 $k$ 个替换操作 $(i, src)$，如果 $s[i..i+|src|-1]$ 与 $src$ 相等，此时我们记录下标 $i$ 处需要替换的是 $targets$ 的第 $k$ 个字符串，否则不需要替换。
+我们遍历每个替换操作，对于当前第 $k$ 个替换操作 $(i, \text{src})$，如果 $s[i..i+|\text{src}|-1]$ 与 $\text{src}$ 相等，此时我们记录下标 $i$ 处需要替换的是 $\text{targets}$ 的第 $k$ 个字符串，否则不需要替换。
 
 接下来，我们只需要遍历原字符串 $s$，根据记录的信息进行替换即可。
 

solution/0800-0899/0833.Find And Replace in String/README_EN.md

@@ -81,7 +81,13 @@ tags:
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Simulation
+
+We iterate through each replacement operation. For the current $k$-th replacement operation $(i, \text{src})$, if $s[i..i+|\text{src}|-1]$ is equal to $\text{src}$, we record that the string at index $i$ needs to be replaced with the $k$-th string in $\text{targets}$; otherwise, no replacement is needed.
+
+Next, we only need to iterate through the original string $s$ and perform the replacements based on the recorded information.
+
+The time complexity is $O(L)$, and the space complexity is $O(n)$, where $L$ is the sum of the lengths of all strings, and $n$ is the length of the string $s$.
 
 <!-- tabs:start -->
 

solution/0800-0899/0834.Sum of Distances in Tree/README_EN.md

@@ -69,7 +69,17 @@ Hence, answer[0] = 8, and so on.
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Tree DP (Re-rooting)
+
+First, we run a DFS to calculate the size of each node's subtree, recorded in the array $size$, and compute the sum of distances from node $0$ to all other nodes, recorded in $ans[0]$.
+
+Next, we run another DFS to enumerate the sum of distances from each node when it is considered as the root. Suppose the answer for the current node $i$ is $t$. When we move from node $i$ to node $j$, the sum of distances changes to $t - size[j] + n - size[j]$, meaning the sum of distances to node $j$ and its subtree nodes decreases by $size[j]$, while the sum of distances to other nodes increases by $n - size[j]$.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the number of nodes in the tree.
+
+Similar problems:
+
+-   [2581. Count Number of Possible Root Nodes](https://github.com/doocs/leetcode/blob/main/solution/2500-2599/2581.Count%20Number%20of%20Possible%20Root%20Nodes/README_EN.md)
 
 <!-- tabs:start -->
 

solution/0800-0899/0835.Image Overlap/README.md

@@ -76,9 +76,9 @@ tags:
 
 ### 方法一：枚举
 
-我们可以枚举 $img1$ 和 $img2$ 的每个 $1$ 的位置，分别记为 $(i, j)$ 和 $(h, k)$。然后我们计算得到偏移量 $(i - h, j - k)$，记为 $(dx, dy)$，用哈希表 $cnt$ 记录每个偏移量出现的次数。最后我们遍历哈希表 $cnt$，找到出现次数最多的偏移量，即为答案。
+我们可以枚举 $\textit{img1}$ 和 $\textit{img2}$ 的每个 $1$ 的位置，分别记为 $(i, j)$ 和 $(h, k)$。然后我们计算得到偏移量 $(i - h, j - k)$，记为 $(dx, dy)$，用哈希表 $\textit{cnt}$ 记录每个偏移量出现的次数。最后我们遍历哈希表 $\textit{cnt}$，找到出现次数最多的偏移量，即为答案。
 
-时间复杂度 $O(n^4)$，空间复杂度 $O(n^2)$。其中 $n$ 是 $img1$ 的边长。
+时间复杂度 $O(n^4)$，空间复杂度 $O(n^2)$。其中 $n$ 是 $\textit{img1}$ 的边长。
 
 <!-- tabs:start -->
 

solution/0800-0899/0835.Image Overlap/README_EN.md

@@ -68,7 +68,11 @@ The number of positions that have a 1 in both images is 3 (shown in red).
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Enumeration
+
+We can enumerate each position of $1$ in $\textit{img1}$ and $\textit{img2}$, denoted as $(i, j)$ and $(h, k)$ respectively. Then we calculate the offset $(i - h, j - k)$, denoted as $(dx, dy)$, and use a hash table $\textit{cnt}$ to record the number of occurrences of each offset. Finally, we traverse the hash table $\textit{cnt}$ to find the offset that appears the most, which is the answer.
+
+The time complexity is $O(n^4)$, and the space complexity is $O(n^2)$, where $n$ is the side length of $\textit{img1}$.
 
 <!-- tabs:start -->
 

solution/0800-0899/0836.Rectangle Overlap/README.md

@@ -65,16 +65,16 @@ tags:
 
 ### 方法一：判断不重叠的情况
 
-我们记矩形 $rec1$ 的坐标点为 $(x_1, y_1, x_2, y_2)$，矩形 $rec2$ 的坐标点为 $(x_3, y_3, x_4, y_4)$。
+我们记矩形 $\text{rec1}$ 的坐标点为 $(x_1, y_1, x_2, y_2)$，矩形 $\text{rec2}$ 的坐标点为 $(x_3, y_3, x_4, y_4)$。
 
-那么当满足以下任一条件时，矩形 $rec1$ 和 $rec2$ 不重叠：
+那么当满足以下任一条件时，矩形 $\text{rec1}$ 和 $\text{rec2}$ 不重叠：
 
--   满足 $y_3 \geq y_2$，即 $rec2$ 在 $rec1$ 的上方；
--   满足 $y_4 \leq y_1$，即 $rec2$ 在 $rec1$ 的下方；
--   满足 $x_3 \geq x_2$，即 $rec2$ 在 $rec1$ 的右方；
--   满足 $x_4 \leq x_1$，即 $rec2$ 在 $rec1$ 的左方。
+-   满足 $y_3 \geq y_2$，即 $\text{rec2}$ 在 $\text{rec1}$ 的上方；
+-   满足 $y_4 \leq y_1$，即 $\text{rec2}$ 在 $\text{rec1}$ 的下方；
+-   满足 $x_3 \geq x_2$，即 $\text{rec2}$ 在 $\text{rec1}$ 的右方；
+-   满足 $x_4 \leq x_1$，即 $\text{rec2}$ 在 $\text{rec1}$ 的左方。
 
-当以上条件都不满足时，矩形 $rec1$ 和 $rec2$ 重叠。
+当以上条件都不满足时，矩形 $\text{rec1}$ 和 $\text{rec2}$ 重叠。
 
 时间复杂度 $O(1)$，空间复杂度 $O(1)$。
 
@@ -125,6 +125,16 @@ func isRectangleOverlap(rec1 []int, rec2 []int) bool {
 }
 ```
 
+#### TypeScript
+
+```ts
+function isRectangleOverlap(rec1: number[], rec2: number[]): boolean {
+    const [x1, y1, x2, y2] = rec1;
+    const [x3, y3, x4, y4] = rec2;
+    return !(y3 >= y2 || y4 <= y1 || x3 >= x2 || x4 <= x1);
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/0800-0899/0836.Rectangle Overlap/README_EN.md

@@ -50,7 +50,20 @@ tags:
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Determine Non-Overlap Cases
+
+Let the coordinates of rectangle $\text{rec1}$ be $(x_1, y_1, x_2, y_2)$, and the coordinates of rectangle $\text{rec2}$ be $(x_3, y_3, x_4, y_4)$.
+
+The rectangles $\text{rec1}$ and $\text{rec2}$ do not overlap if any of the following conditions are met:
+
+-   $y_3 \geq y_2$: $\text{rec2}$ is above $\text{rec1}$;
+-   $y_4 \leq y_1$: $\text{rec2}$ is below $\text{rec1}$;
+-   $x_3 \geq x_2$: $\text{rec2}$ is to the right of $\text{rec1}$;
+-   $x_4 \leq x_1$: $\text{rec2}$ is to the left of $\text{rec1}$.
+
+If none of the above conditions are met, the rectangles $\text{rec1}$ and $\text{rec2}$ overlap.
+
+The time complexity is $O(1)$, and the space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -99,6 +112,16 @@ func isRectangleOverlap(rec1 []int, rec2 []int) bool {
 }
 ```
 
+#### TypeScript
+
+```ts
+function isRectangleOverlap(rec1: number[], rec2: number[]): boolean {
+    const [x1, y1, x2, y2] = rec1;
+    const [x3, y3, x4, y4] = rec2;
+    return !(y3 >= y2 || y4 <= y1 || x3 >= x2 || x4 <= x1);
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/0800-0899/0836.Rectangle Overlap/Solution.ts

@@ -0,0 +1,5 @@
+function isRectangleOverlap(rec1: number[], rec2: number[]): boolean {
+    const [x1, y1, x2, y2] = rec1;
+    const [x3, y3, x4, y4] = rec2;
+    return !(y3 >= y2 || y4 <= y1 || x3 >= x2 || x4 <= x1);
+}