feat: add solutions for lc No.2946~2948 (#5115)

Author: yanglbme

solution/2900-2999/2946.Matrix Similarity After Cyclic Shifts/README.md

@@ -74,7 +74,17 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：模拟
+
+我们遍历矩阵的每个元素，判断其在循环移位后的位置是否与原位置的元素相同。
+
+对于奇数行，我们将元素向右移动 $k$ 个位置，因此元素 $(i, j)$ 在循环移位后的位置为 $(i, (j + k) \bmod n)$，其中 $n$ 是矩阵的列数。
+
+对于偶数行，我们将元素向左移动 $k$ 个位置，因此元素 $(i, j)$ 在循环移位后的位置为 $(i, (j - k + n) \bmod n)$。
+
+如果在遍历过程中发现有任何一个元素在循环移位后的位置与原位置的元素不同，则返回 $\text{false}$。如果遍历完成后所有元素都相同，则返回 $\text{true}$。
+
+时间复杂度 $O(m \times n)$，其中 $m$ 和 $n$ 分别是矩阵的行数和列数。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -179,6 +189,30 @@ function areSimilar(mat: number[][], k: number): boolean {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn are_similar(mat: Vec<Vec<i32>>, k: i32) -> bool {
+        let m = mat.len();
+        let n = mat[0].len();
+        let k = (k as usize) % n;
+
+        for i in 0..m {
+            for j in 0..n {
+                if i % 2 == 1 && mat[i][j] != mat[i][(j + k) % n] {
+                    return false;
+                }
+                if i % 2 == 0 && mat[i][j] != mat[i][(j + n - k) % n] {
+                    return false;
+                }
+            }
+        }
+        true
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2900-2999/2946.Matrix Similarity After Cyclic Shifts/README_EN.md

@@ -94,7 +94,17 @@ tags:
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Simulation
+
+We iterate over each element of the matrix and check whether its position after the cyclic shift is the same as the element at the original position.
+
+For odd-indexed rows, we shift elements to the right by $k$ positions, so element $(i, j)$ moves to position $(i, (j + k) \bmod n)$ after the cyclic shift, where $n$ is the number of columns.
+
+For even-indexed rows, we shift elements to the left by $k$ positions, so element $(i, j)$ moves to position $(i, (j - k + n) \bmod n)$ after the cyclic shift.
+
+If at any point during the traversal we find that an element's position after the cyclic shift differs from the original, we return $\text{false}$. If all elements remain the same after the full traversal, we return $\text{true}$.
+
+The time complexity is $O(m \times n)$, where $m$ and $n$ are the number of rows and columns of the matrix, respectively. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -199,6 +209,30 @@ function areSimilar(mat: number[][], k: number): boolean {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn are_similar(mat: Vec<Vec<i32>>, k: i32) -> bool {
+        let m = mat.len();
+        let n = mat[0].len();
+        let k = (k as usize) % n;
+
+        for i in 0..m {
+            for j in 0..n {
+                if i % 2 == 1 && mat[i][j] != mat[i][(j + k) % n] {
+                    return false;
+                }
+                if i % 2 == 0 && mat[i][j] != mat[i][(j + n - k) % n] {
+                    return false;
+                }
+            }
+        }
+        true
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2900-2999/2946.Matrix Similarity After Cyclic Shifts/Solution.rs

@@ -0,0 +1,19 @@
+impl Solution {
+    pub fn are_similar(mat: Vec<Vec<i32>>, k: i32) -> bool {
+        let m = mat.len();
+        let n = mat[0].len();
+        let k = (k as usize) % n;
+
+        for i in 0..m {
+            for j in 0..n {
+                if i % 2 == 1 && mat[i][j] != mat[i][(j + k) % n] {
+                    return false;
+                }
+                if i % 2 == 0 && mat[i][j] != mat[i][(j + n - k) % n] {
+                    return false;
+                }
+            }
+        }
+        true
+    }
+}

solution/2900-2999/2947.Count Beautiful Substrings I/README.md

@@ -93,7 +93,11 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：枚举
+
+我们在 $[0, n)$ 范围内枚举子字符串的起始位置 $i$，在 $[i, n)$ 范围内枚举子字符串的结束位置 $j$，统计子字符串 $s[i \dots j]$ 中元音字母和辅音字母的数量，判断其是否为美丽字符串，如果是，则将答案加 $1$。
+
+时间复杂度 $O(n^2)$，其中 $n$ 是字符串的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -216,6 +220,37 @@ function beautifulSubstrings(s: string, k: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn beautiful_substrings(s: String, k: i32) -> i32 {
+        let n = s.len();
+        let s = s.as_bytes();
+
+        let mut vs = [0; 26];
+        for &c in b"aeiou" {
+            vs[(c - b'a') as usize] = 1;
+        }
+
+        let mut ans = 0;
+
+        for i in 0..n {
+            let mut vowels = 0;
+            for j in i..n {
+                vowels += vs[(s[j] - b'a') as usize];
+                let consonants = (j - i + 1) as i32 - vowels;
+                if vowels == consonants && (vowels * consonants) % k == 0 {
+                    ans += 1;
+                }
+            }
+        }
+
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2900-2999/2947.Count Beautiful Substrings I/README_EN.md

@@ -51,7 +51,7 @@ tags:
 <strong>Explanation:</strong> There are 2 beautiful substrings in the given string.
 - Substring &quot;b<u>aeyh</u>&quot;, vowels = 2 ([&quot;a&quot;,e&quot;]), consonants = 2 ([&quot;y&quot;,&quot;h&quot;]).
 You can see that string &quot;aeyh&quot; is beautiful as vowels == consonants and vowels * consonants % k == 0.
-- Substring &quot;<u>baey</u>h&quot;, vowels = 2 ([&quot;a&quot;,e&quot;]), consonants = 2 ([&quot;b&quot;,&quot;y&quot;]). 
+- Substring &quot;<u>baey</u>h&quot;, vowels = 2 ([&quot;a&quot;,e&quot;]), consonants = 2 ([&quot;b&quot;,&quot;y&quot;]).
 You can see that string &quot;baey&quot; is beautiful as vowels == consonants and vowels * consonants % k == 0.
 It can be shown that there are only 2 beautiful substrings in the given string.
 </pre>
@@ -62,7 +62,7 @@ It can be shown that there are only 2 beautiful substrings in the given string.
 <strong>Input:</strong> s = &quot;abba&quot;, k = 1
 <strong>Output:</strong> 3
 <strong>Explanation:</strong> There are 3 beautiful substrings in the given string.
-- Substring &quot;<u>ab</u>ba&quot;, vowels = 1 ([&quot;a&quot;]), consonants = 1 ([&quot;b&quot;]). 
+- Substring &quot;<u>ab</u>ba&quot;, vowels = 1 ([&quot;a&quot;]), consonants = 1 ([&quot;b&quot;]).
 - Substring &quot;ab<u>ba</u>&quot;, vowels = 1 ([&quot;a&quot;]), consonants = 1 ([&quot;b&quot;]).
 - Substring &quot;<u>abba</u>&quot;, vowels = 2 ([&quot;a&quot;,&quot;a&quot;]), consonants = 2 ([&quot;b&quot;,&quot;b&quot;]).
 It can be shown that there are only 3 beautiful substrings in the given string.
@@ -91,7 +91,11 @@ It can be shown that there are only 3 beautiful substrings in the given string.
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Enumeration
+
+We enumerate the starting position $i$ of the substring in the range $[0, n)$, and the ending position $j$ in the range $[i, n)$, count the number of vowels and consonants in the substring $s[i \dots j]$, and check whether it is a beautiful substring. If so, we increment the answer by $1$.
+
+The time complexity is $O(n^2)$, where $n$ is the length of the string. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -214,6 +218,37 @@ function beautifulSubstrings(s: string, k: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn beautiful_substrings(s: String, k: i32) -> i32 {
+        let n = s.len();
+        let s = s.as_bytes();
+
+        let mut vs = [0; 26];
+        for &c in b"aeiou" {
+            vs[(c - b'a') as usize] = 1;
+        }
+
+        let mut ans = 0;
+
+        for i in 0..n {
+            let mut vowels = 0;
+            for j in i..n {
+                vowels += vs[(s[j] - b'a') as usize];
+                let consonants = (j - i + 1) as i32 - vowels;
+                if vowels == consonants && (vowels * consonants) % k == 0 {
+                    ans += 1;
+                }
+            }
+        }
+
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2900-2999/2947.Count Beautiful Substrings I/Solution.rs

@@ -0,0 +1,26 @@
+impl Solution {
+    pub fn beautiful_substrings(s: String, k: i32) -> i32 {
+        let n = s.len();
+        let s = s.as_bytes();
+
+        let mut vs = [0; 26];
+        for &c in b"aeiou" {
+            vs[(c - b'a') as usize] = 1;
+        }
+
+        let mut ans = 0;
+
+        for i in 0..n {
+            let mut vowels = 0;
+            for j in i..n {
+                vowels += vs[(s[j] - b'a') as usize];
+                let consonants = (j - i + 1) as i32 - vowels;
+                if vowels == consonants && (vowels * consonants) % k == 0 {
+                    ans += 1;
+                }
+            }
+        }
+
+        ans
+    }
+}

solution/2900-2999/2948.Make Lexicographically Smallest Array by Swapping Elements/README.md

@@ -78,7 +78,15 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：排序
+
+根据题目描述，排序后的数组 $\textit{nums}$ 可以划分成若干个子数组，使得每个子数组中的相邻元素之差不超过 $\textit{limit}$。
+
+那么，可以通过交换得到的字典序最小的数组就是将每个子数组中的元素排序后，依次填入原数组所在位置得到的数组。
+
+我们首先将数组 $\textit{nums}$ 中的元素和它们的下标组成一个二元组数组，并按照元素的值进行排序。然后，我们遍历排序后的二元组数组，找到每个子数组的范围，并将子数组中的元素按照下标进行排序后，填入原数组所在位置得到最终的结果。
+
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$，其中 $n$ 是数组 $\textit{nums}$ 的长度。
 
 <!-- tabs:start -->
 
@@ -209,6 +217,40 @@ function lexicographicallySmallestArray(nums: number[], limit: number): number[]
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn lexicographically_smallest_array(nums: Vec<i32>, limit: i32) -> Vec<i32> {
+        let n = nums.len();
+        let mut idx: Vec<usize> = (0..n).collect();
+
+        idx.sort_by_key(|&i| nums[i]);
+
+        let mut ans = vec![0; n];
+
+        let mut i = 0;
+        while i < n {
+            let mut j = i + 1;
+            while j < n && nums[idx[j]] - nums[idx[j - 1]] <= limit {
+                j += 1;
+            }
+
+            let mut t = idx[i..j].to_vec();
+            t.sort();
+
+            for k in i..j {
+                ans[t[k - i]] = nums[idx[k]];
+            }
+
+            i = j;
+        }
+
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2900-2999/2948.Make Lexicographically Smallest Array by Swapping Elements/README_EN.md

@@ -76,7 +76,15 @@ We cannot obtain a lexicographically smaller array by applying any more operatio
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Sorting
+
+According to the problem description, the sorted array $\textit{nums}$ can be partitioned into several subarrays such that the difference between adjacent elements in each subarray does not exceed $\textit{limit}$.
+
+The lexicographically smallest array obtainable through swapping is thus the one where the elements within each subarray are sorted and placed back into their original positions in order.
+
+We first pair each element in $\textit{nums}$ with its index to form an array of tuples, then sort by element value. We then traverse the sorted tuple array, identify the range of each subarray, sort the elements within each subarray by their original indices, and fill them back into the corresponding positions to obtain the final result.
+
+The time complexity is $O(n \times \log n)$ and the space complexity is $O(n)$, where $n$ is the length of the array $\textit{nums}$.
 
 <!-- tabs:start -->
 
@@ -207,6 +215,40 @@ function lexicographicallySmallestArray(nums: number[], limit: number): number[]
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn lexicographically_smallest_array(nums: Vec<i32>, limit: i32) -> Vec<i32> {
+        let n = nums.len();
+        let mut idx: Vec<usize> = (0..n).collect();
+
+        idx.sort_by_key(|&i| nums[i]);
+
+        let mut ans = vec![0; n];
+
+        let mut i = 0;
+        while i < n {
+            let mut j = i + 1;
+            while j < n && nums[idx[j]] - nums[idx[j - 1]] <= limit {
+                j += 1;
+            }
+
+            let mut t = idx[i..j].to_vec();
+            t.sort();
+
+            for k in i..j {
+                ans[t[k - i]] = nums[idx[k]];
+            }
+
+            i = j;
+        }
+
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->