feat: update solutions to lc problems: No.2351~2355 (doocs#2429)

Author: yanglbme

solution/2300-2399/2351.First Letter to Appear Twice/README_EN.md

@@ -49,7 +49,11 @@ The only letter that appears twice is 'd' so we return 'd'.
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Array or Hash Table
+
+We traverse the string $s$, using an array or hash table `cnt` to record the occurrence of each letter. When a letter appears twice, we return that letter.
+
+The time complexity is $O(n)$ and the space complexity is $O(C)$. Here, $n$ is the length of the string $s$, and $C$ is the size of the character set. In this problem, $C = 26$.
 
 <!-- tabs:start -->
 
@@ -164,7 +168,11 @@ char repeatedCharacter(char* s) {
 
 <!-- tabs:end -->
 
-### Solution 2
+### Solution 2: Bit Manipulation
+
+We can also use an integer `mask` to record whether each letter has appeared, where the $i$-th bit of `mask` indicates whether the $i$-th letter has appeared. When a letter appears twice, we return that letter.
+
+The time complexity is $O(n)$ and the space complexity is $O(1)$. Here, $n$ is the length of the string $s$.
 
 <!-- tabs:start -->
 

solution/2300-2399/2352.Equal Row and Column Pairs/README.md

@@ -54,115 +54,7 @@
 
 我们直接将矩阵 $grid$ 的每一行和每一列进行比较，如果相等，那么就是一对相等行列对，答案加一。
 
-时间复杂度 $O(n^3)$，空间复杂度 $O(1)$。其中 $n$ 为矩阵 $grid$ 的行数或列数。
-
-<!-- tabs:start -->
-
-```python
-class Solution:
-    def equalPairs(self, grid: List[List[int]]) -> int:
-        g = [list(col) for col in zip(*grid)]
-        return sum(row == col for row in grid for col in g)
-```
-
-```java
-class Solution {
-    public int equalPairs(int[][] grid) {
-        int n = grid.length;
-        int[][] g = new int[n][n];
-        for (int j = 0; j < n; ++j) {
-            for (int i = 0; i < n; ++i) {
-                g[i][j] = grid[j][i];
-            }
-        }
-        int ans = 0;
-        for (var row : grid) {
-            for (var col : g) {
-                int ok = 1;
-                for (int i = 0; i < n; ++i) {
-                    if (row[i] != col[i]) {
-                        ok = 0;
-                        break;
-                    }
-                }
-                ans += ok;
-            }
-        }
-        return ans;
-    }
-}
-```
-
-```cpp
-class Solution {
-public:
-    int equalPairs(vector<vector<int>>& grid) {
-        int n = grid.size();
-        vector<vector<int>> g(n, vector<int>(n));
-        for (int j = 0; j < n; ++j) {
-            for (int i = 0; i < n; ++i) {
-                g[i][j] = grid[j][i];
-            }
-        }
-        int ans = 0;
-        for (auto& row : grid) {
-            for (auto& col : g) {
-                ans += row == col;
-            }
-        }
-        return ans;
-    }
-};
-```
-
-```go
-func equalPairs(grid [][]int) (ans int) {
-	n := len(grid)
-	g := make([][]int, n)
-	for i := range g {
-		g[i] = make([]int, n)
-		for j := 0; j < n; j++ {
-			g[i][j] = grid[j][i]
-		}
-	}
-	for _, row := range grid {
-		for _, col := range g {
-			ok := 1
-			for i, v := range row {
-				if v != col[i] {
-					ok = 0
-					break
-				}
-			}
-			ans += ok
-		}
-	}
-	return
-}
-```
-
-```ts
-function equalPairs(grid: number[][]): number {
-    const n = grid.length;
-    const g = Array.from({ length: n }, () => Array.from({ length: n }, () => 0));
-    for (let j = 0; j < n; ++j) {
-        for (let i = 0; i < n; ++i) {
-            g[i][j] = grid[j][i];
-        }
-    }
-    let ans = 0;
-    for (const row of grid) {
-        for (const col of g) {
-            ans += Number(row.toString() === col.toString());
-        }
-    }
-    return ans;
-}
-```
-
-<!-- tabs:end -->
-
-### 方法二
+时间复杂度 $O(n^3)$，其中 $n$ 为矩阵 $grid$ 的行数或列数。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/2300-2399/2352.Equal Row and Column Pairs/README_EN.md

@@ -42,115 +42,11 @@
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Simulation
 
-<!-- tabs:start -->
-
-```python
-class Solution:
-    def equalPairs(self, grid: List[List[int]]) -> int:
-        g = [list(col) for col in zip(*grid)]
-        return sum(row == col for row in grid for col in g)
-```
-
-```java
-class Solution {
-    public int equalPairs(int[][] grid) {
-        int n = grid.length;
-        int[][] g = new int[n][n];
-        for (int j = 0; j < n; ++j) {
-            for (int i = 0; i < n; ++i) {
-                g[i][j] = grid[j][i];
-            }
-        }
-        int ans = 0;
-        for (var row : grid) {
-            for (var col : g) {
-                int ok = 1;
-                for (int i = 0; i < n; ++i) {
-                    if (row[i] != col[i]) {
-                        ok = 0;
-                        break;
-                    }
-                }
-                ans += ok;
-            }
-        }
-        return ans;
-    }
-}
-```
-
-```cpp
-class Solution {
-public:
-    int equalPairs(vector<vector<int>>& grid) {
-        int n = grid.size();
-        vector<vector<int>> g(n, vector<int>(n));
-        for (int j = 0; j < n; ++j) {
-            for (int i = 0; i < n; ++i) {
-                g[i][j] = grid[j][i];
-            }
-        }
-        int ans = 0;
-        for (auto& row : grid) {
-            for (auto& col : g) {
-                ans += row == col;
-            }
-        }
-        return ans;
-    }
-};
-```
-
-```go
-func equalPairs(grid [][]int) (ans int) {
-	n := len(grid)
-	g := make([][]int, n)
-	for i := range g {
-		g[i] = make([]int, n)
-		for j := 0; j < n; j++ {
-			g[i][j] = grid[j][i]
-		}
-	}
-	for _, row := range grid {
-		for _, col := range g {
-			ok := 1
-			for i, v := range row {
-				if v != col[i] {
-					ok = 0
-					break
-				}
-			}
-			ans += ok
-		}
-	}
-	return
-}
-```
-
-```ts
-function equalPairs(grid: number[][]): number {
-    const n = grid.length;
-    const g = Array.from({ length: n }, () => Array.from({ length: n }, () => 0));
-    for (let j = 0; j < n; ++j) {
-        for (let i = 0; i < n; ++i) {
-            g[i][j] = grid[j][i];
-        }
-    }
-    let ans = 0;
-    for (const row of grid) {
-        for (const col of g) {
-            ans += Number(row.toString() === col.toString());
-        }
-    }
-    return ans;
-}
-```
-
-<!-- tabs:end -->
+We directly compare each row and column of the matrix $grid$. If they are equal, then it is a pair of equal row-column pairs, and we increment the answer by one.
 
-### Solution 2
+The time complexity is $O(n^3)$, where $n$ is the number of rows or columns in the matrix $grid$. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 

solution/2300-2399/2352.Equal Row and Column Pairs/Solution.cpp

@@ -2,16 +2,17 @@ class Solution {
 public:
     int equalPairs(vector<vector<int>>& grid) {
         int n = grid.size();
-        vector<vector<int>> g(n, vector<int>(n));
-        for (int j = 0; j < n; ++j) {
-            for (int i = 0; i < n; ++i) {
-                g[i][j] = grid[j][i];
-            }
-        }
         int ans = 0;
-        for (auto& row : grid) {
-            for (auto& col : g) {
-                ans += row == col;
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < n; ++j) {
+                int ok = 1;
+                for (int k = 0; k < n; ++k) {
+                    if (grid[i][k] != grid[k][j]) {
+                        ok = 0;
+                        break;
+                    }
+                }
+                ans += ok;
             }
         }
         return ans;

solution/2300-2399/2352.Equal Row and Column Pairs/Solution.go

@@ -1,17 +1,9 @@
 func equalPairs(grid [][]int) (ans int) {
-	n := len(grid)
-	g := make([][]int, n)
-	for i := range g {
-		g[i] = make([]int, n)
-		for j := 0; j < n; j++ {
-			g[i][j] = grid[j][i]
-		}
-	}
-	for _, row := range grid {
-		for _, col := range g {
+	for i := range grid {
+		for j := range grid {
 			ok := 1
-			for i, v := range row {
-				if v != col[i] {
+			for k := range grid {
+				if grid[i][k] != grid[k][j] {
 					ok = 0
 					break
 				}

solution/2300-2399/2352.Equal Row and Column Pairs/Solution.java

@@ -1,18 +1,12 @@
 class Solution {
     public int equalPairs(int[][] grid) {
         int n = grid.length;
-        int[][] g = new int[n][n];
-        for (int j = 0; j < n; ++j) {
-            for (int i = 0; i < n; ++i) {
-                g[i][j] = grid[j][i];
-            }
-        }
         int ans = 0;
-        for (var row : grid) {
-            for (var col : g) {
+        for (int i = 0; i < n; ++i) {
+            for (int j = 0; j < n; ++j) {
                 int ok = 1;
-                for (int i = 0; i < n; ++i) {
-                    if (row[i] != col[i]) {
+                for (int k = 0; k < n; ++k) {
+                    if (grid[i][k] != grid[k][j]) {
                         ok = 0;
                         break;
                     }

solution/2300-2399/2352.Equal Row and Column Pairs/Solution.py

@@ -1,4 +1,8 @@
 class Solution:
     def equalPairs(self, grid: List[List[int]]) -> int:
-        g = [list(col) for col in zip(*grid)]
-        return sum(row == col for row in grid for col in g)
+        n = len(grid)
+        ans = 0
+        for i in range(n):
+            for j in range(n):
+                ans += all(grid[i][k] == grid[k][j] for k in range(n))
+        return ans

solution/2300-2399/2352.Equal Row and Column Pairs/Solution.ts

@@ -1,15 +1,16 @@
 function equalPairs(grid: number[][]): number {
     const n = grid.length;
-    const g = Array.from({ length: n }, () => Array.from({ length: n }, () => 0));
-    for (let j = 0; j < n; ++j) {
-        for (let i = 0; i < n; ++i) {
-            g[i][j] = grid[j][i];
-        }
-    }
     let ans = 0;
-    for (const row of grid) {
-        for (const col of g) {
-            ans += Number(row.toString() === col.toString());
+    for (let i = 0; i < n; ++i) {
+        for (let j = 0; j < n; ++j) {
+            let ok = 1;
+            for (let k = 0; k < n; ++k) {
+                if (grid[i][k] !== grid[k][j]) {
+                    ok = 0;
+                    break;
+                }
+            }
+            ans += ok;
         }
     }
     return ans;