feat: update solutions to lc problem: No.1460

solution/1400-1499/1460.Make Two Arrays Equal by Reversing Subarrays/README.md

@@ -57,18 +57,18 @@
 
 ### 方法一：排序
 
-分别对数组 $arr$ 和 $target$ 排序，然后比较两数组对应位置的元素是否相等。相等则满足条件。
+如果两个数组排序后相等，那么它们可以通过翻转子数组变成相等的数组。
 
-时间复杂度 $O(nlogn)$，空间复杂度 $O(logn)$。其中 $n$ 是数组 $arr$ 的长度，快排的平均递归深度为 $O(logn)$。
+因此，我们只需要对两个数组进行排序，然后判断排序后的数组是否相等即可。
+
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(\log n)$。其中 $n$ 是数组 $arr$ 的长度。
 
 <!-- tabs:start -->
 
 ```python
 class Solution:
     def canBeEqual(self, target: List[int], arr: List[int]) -> bool:
-        target.sort()
-        arr.sort()
-        return target == arr
+        return sorted(target) == sorted(arr)
 ```
 
 ```java
@@ -96,26 +96,15 @@ public:
 func canBeEqual(target []int, arr []int) bool {
 	sort.Ints(target)
 	sort.Ints(arr)
-	for i, v := range target {
-		if v != arr[i] {
-			return false
-		}
-	}
-	return true
+	return reflect.DeepEqual(target, arr)
 }
 ```
 
 ```ts
 function canBeEqual(target: number[], arr: number[]): boolean {
     target.sort((a, b) => a - b);
     arr.sort((a, b) => a - b);
-    const n = arr.length;
-    for (let i = 0; i < n; i++) {
-        if (target[i] !== arr[i]) {
-            return false;
-        }
-    }
-    return true;
+    return target.join() === arr.join();
 }
 ```
 
@@ -145,14 +134,15 @@ class Solution {
 ```
 
 ```c
+int compare(const void* a, const void* b) {
+    return (*(int*) a - *(int*) b);
+}
+
 bool canBeEqual(int* target, int targetSize, int* arr, int arrSize) {
-    int count[1001] = {0};
-    for (int i = 0; i < targetSize; i++) {
-        count[target[i]]++;
-        count[arr[i]]--;
-    }
-    for (int i = 0; i < 1001; i++) {
-        if (count[i] != 0) {
+    qsort(target, targetSize, sizeof(int), compare);
+    qsort(arr, arrSize, sizeof(int), compare);
+    for (int i = 0; i < targetSize; ++i) {
+        if (target[i] != arr[i]) {
             return false;
         }
     }
@@ -162,11 +152,13 @@ bool canBeEqual(int* target, int targetSize, int* arr, int arrSize) {
 
 <!-- tabs:end -->
 
-### 方法二：数组/哈希表
+### 方法二：计数
+
+我们注意到，题目中给出的数组元素的范围是 $1 \sim 1000$，因此我们可以使用两个长度为 $1001$ 的数组 `cnt1` 和 `cnt2` 分别记录数组 `target` 和 `arr` 中每个元素出现的次数。最后判断两个数组是否相等即可。
 
-由于两数组的数据范围都是 $1 \leq x \leq 1000$，因此我们可以使用数组或哈希表来记录每个数字出现的次数。
+我们也可以只用一个数组 `cnt`，遍历数组 `target` 和 `arr`，对于 `target[i]`，我们将 `cnt[target[i]]` 加一，对于 `arr[i]`，我们将 `cnt[arr[i]]` 减一。最后判断数组 `cnt` 中的所有元素是否都为 $0$。
 
-时间复杂度 $O(n)$，空间复杂度 $O(C)$。其中 $n$ 是数组 $arr$ 的长度，而 $C$ 是数组 $arr$ 元素的值域大小。
+时间复杂度 $O(n + M)$，空间复杂度 $O(M)$。其中 $n$ 是数组 $arr$ 的长度，而 $M$ 是数组元素的范围，本题中 $M = 1001$。
 
 <!-- tabs:start -->
 
@@ -198,8 +190,12 @@ public:
     bool canBeEqual(vector<int>& target, vector<int>& arr) {
         vector<int> cnt1(1001);
         vector<int> cnt2(1001);
-        for (int& v : target) ++cnt1[v];
-        for (int& v : arr) ++cnt2[v];
+        for (int& v : target) {
+            ++cnt1[v];
+        }
+        for (int& v : arr) {
+            ++cnt2[v];
+        }
         return cnt1 == cnt2;
     }
 };
@@ -215,103 +211,36 @@ func canBeEqual(target []int, arr []int) bool {
 	for _, v := range arr {
 		cnt2[v]++
 	}
-	for i, v := range cnt1 {
-		if v != cnt2[i] {
-			return false
-		}
-	}
-	return true
+	return reflect.DeepEqual(cnt1, cnt2)
 }
 ```
 
 ```ts
 function canBeEqual(target: number[], arr: number[]): boolean {
     const n = target.length;
-    const count = new Array(1001).fill(0);
+    const cnt = Array(1001).fill(0);
     for (let i = 0; i < n; i++) {
-        count[target[i]]++;
-        count[arr[i]]--;
+        cnt[target[i]]++;
+        cnt[arr[i]]--;
     }
-    return count.every(v => v === 0);
+    return cnt.every(v => !v);
 }
 ```
 
 ```rust
 impl Solution {
     pub fn can_be_equal(mut target: Vec<i32>, mut arr: Vec<i32>) -> bool {
         let n = target.len();
-        let mut count = [0; 1001];
+        let mut cnt = [0; 1001];
         for i in 0..n {
-            count[target[i] as usize] += 1;
-            count[arr[i] as usize] -= 1;
-        }
-        count.iter().all(|v| *v == 0)
-    }
-}
-```
-
-<!-- tabs:end -->
-
-### 方法三
-
-<!-- tabs:start -->
-
-```python
-class Solution:
-    def canBeEqual(self, target: List[int], arr: List[int]) -> bool:
-        cnt = [0] * 1001
-        for a, b in zip(target, arr):
-            cnt[a] += 1
-            cnt[b] -= 1
-        return all(v == 0 for v in cnt)
-```
-
-```java
-class Solution {
-    public boolean canBeEqual(int[] target, int[] arr) {
-        int[] cnt = new int[1001];
-        for (int v : target) {
-            ++cnt[v];
-        }
-        for (int v : arr) {
-            if (--cnt[v] < 0) {
-                return false;
-            }
+            cnt[target[i] as usize] += 1;
+            cnt[arr[i] as usize] -= 1;
         }
-        return true;
+        cnt.iter().all(|v| *v == 0)
     }
 }
 ```
 
-```cpp
-class Solution {
-public:
-    bool canBeEqual(vector<int>& target, vector<int>& arr) {
-        vector<int> cnt(1001);
-        for (int& v : target) ++cnt[v];
-        for (int& v : arr)
-            if (--cnt[v] < 0) return false;
-        return true;
-    }
-};
-```
-
-```go
-func canBeEqual(target []int, arr []int) bool {
-	cnt := make([]int, 1001)
-	for _, v := range target {
-		cnt[v]++
-	}
-	for _, v := range arr {
-		cnt[v]--
-		if cnt[v] < 0 {
-			return false
-		}
-	}
-	return true
-}
-```
-
 <!-- tabs:end -->
 
 <!-- end -->