5757
5858### 方法一:排序
5959
60- 分别对数组 $arr$ 和 $target$ 排序,然后比较两数组对应位置的元素是否相等。相等则满足条件 。
60+ 如果两个数组排序后相等,那么它们可以通过翻转子数组变成相等的数组 。
6161
62- 时间复杂度 $O(nlogn),ドル空间复杂度 $O(logn)$。其中 $n$ 是数组 $arr$ 的长度,快排的平均递归深度为 $O(logn)$。
62+ 因此,我们只需要对两个数组进行排序,然后判断排序后的数组是否相等即可。
63+ 64+ 时间复杂度 $O(n \times \log n),ドル空间复杂度 $O(\log n)$。其中 $n$ 是数组 $arr$ 的长度。
6365
6466<!-- tabs:start -->
6567
6668``` python
6769class Solution :
6870 def canBeEqual (self target : List[int ], arr : List[int ]) -> bool :
69- target.sort()
70- arr.sort()
71- return target == arr
71+ return sorted (target) == sorted (arr)
7272```
7373
7474``` java
@@ -96,26 +96,15 @@ public:
9696func canBeEqual(target []int, arr []int) bool {
9797 sort.Ints(target)
9898 sort.Ints(arr)
99- for i, v := range target {
100- if v != arr[i] {
101- return false
102- }
103- }
104- return true
99+ return reflect.DeepEqual(target, arr)
105100}
106101```
107102
108103``` ts
109104function canBeEqual(target : number [], arr : number []): boolean {
110105 target .sort ((a , b ) => a - b );
111106 arr .sort ((a , b ) => a - b );
112- const = arr .length ;
113- for (let i = 0 ; i < n ; i ++ ) {
114- if (target [i ] !== arr [i ]) {
115- return false ;
116- }
117- }
118- return true ;
107+ return target .join () === arr .join ();
119108}
120109```
121110
@@ -145,14 +134,15 @@ class Solution {
145134```
146135
147136``` c
137+ int compare (const void* a, const void* b) {
138+ return (* (int* ) a - * (int* ) b);
139+ }
140+ 148141bool canBeEqual(int* target, int targetSize, int* arr, int arrSize) {
149- int count[ 1001] = {0};
150- for (int i = 0; i < targetSize; i++) {
151- count[ target[ i]] ++;
152- count[ arr[ i]] --;
153- }
154- for (int i = 0; i < 1001; i++) {
155- if (count[ i] != 0) {
142+ qsort(target, targetSize, sizeof(int), compare);
143+ qsort(arr, arrSize, sizeof(int), compare);
144+ for (int i = 0; i < targetSize; ++i) {
145+ if (target[ i] != arr[ i] ) {
156146 return false;
157147 }
158148 }
@@ -162,11 +152,13 @@ bool canBeEqual(int* target, int targetSize, int* arr, int arrSize) {
162152
163153<!-- tabs:end -->
164154
165- ### 方法二:数组/哈希表
155+ ### 方法二:计数
156+
157+ 我们注意到,题目中给出的数组元素的范围是 1ドル \sim 1000,ドル因此我们可以使用两个长度为 1001ドル$ 的数组 `cnt1` 和 `cnt2` 分别记录数组 `target` 和 `arr` 中每个元素出现的次数。最后判断两个数组是否相等即可。
166158
167- 由于两数组的数据范围都是 1ドル \leq x \leq 1000,ドル因此我们可以使用数组或哈希表来记录每个数字出现的次数 。
159+ 我们也可以只用一个数组 `cnt`,遍历数组 `target` 和 `arr`,对于 `target[i]`,我们将 `cnt[target[i]]` 加一,对于 `arr[i]`,我们将 `cnt[arr[i]]` 减一。最后判断数组 `cnt` 中的所有元素是否都为 0ドル$ 。
168160
169- 时间复杂度 $O(n),ドル空间复杂度 $O(C )$。其中 $n$ 是数组 $arr$ 的长度,而 $C$ 是数组 $arr$ 元素的值域大小 。
161+ 时间复杂度 $O(n + M ),ドル空间复杂度 $O(M )$。其中 $n$ 是数组 $arr$ 的长度,而 $M$ 是数组元素的范围,本题中 $M = 1001$ 。
170162
171163<!-- tabs:start -->
172164
@@ -198,8 +190,12 @@ public:
198190 bool canBeEqual(vector<int >& target, vector<int >& arr) {
199191 vector<int > cnt1(1001);
200192 vector<int > cnt2(1001);
201- for (int& v : target) ++cnt1[ v] ;
202- for (int& v : arr) ++cnt2[ v] ;
193+ for (int& v : target) {
194+ ++cnt1[ v] ;
195+ }
196+ for (int& v : arr) {
197+ ++cnt2[ v] ;
198+ }
203199 return cnt1 == cnt2;
204200 }
205201};
@@ -215,103 +211,36 @@ func canBeEqual(target []int, arr []int) bool {
215211 for _, v := range arr {
216212 cnt2[v]++
217213 }
218- for i, v := range cnt1 {
219- if v != cnt2[i] {
220- return false
221- }
222- }
223- return true
214+ return reflect.DeepEqual(cnt1, cnt2)
224215}
225216```
226217
227218``` ts
228219function canBeEqual(target : number [], arr : number []): boolean {
229220 const = target .length ;
230- const count = new Array (1001 ).fill (0 );
221+ const cnt = Array (1001 ).fill (0 );
231222 for (let i = 0 ; i < n ; i ++ ) {
232- count [target [i ]]++ ;
233- count [arr [i ]]-- ;
223+ cnt [target [i ]]++ ;
224+ cnt [arr [i ]]-- ;
234225 }
235- return count .every (v => v === 0 );
226+ return cnt .every (v => ! v );
236227}
237228```
238229
239230``` rust
240231impl Solution {
241232 pub fn can_be_equal (mut target : Vec <i32 >, mut arr : Vec <i32 >) -> bool {
242233 let n = target . len ();
243- let mut count = [0 ; 1001 ];
234+ let mut cnt = [0 ; 1001 ];
244235 for i in 0 .. n {
245- count [target [i ] as usize ] += 1 ;
246- count [arr [i ] as usize ] -= 1 ;
247- }
248- count . iter (). all (| v | * v == 0 )
249- }
250- }
251- ```
252- 253- <!-- tabs: end -->
254- 255- ### 方法三
256- 257- <!-- tabs: start -->
258- 259- ``` python
260- class Solution :
261- def canBeEqual (self target : List[int ], arr : List[int ]) -> bool :
262- cnt = [0 ] * 1001
263- for a, b in zip (target, arr):
264- cnt[a] += 1
265- cnt[b] -= 1
266- return all (v == 0 for v in cnt)
267- ```
268- 269- ``` java
270- class Solution {
271- public boolean canBeEqual (int [] target , int [] arr ) {
272- int [] cnt = new int [1001 ];
273- for (int v : target) {
274- ++ cnt[v];
275- }
276- for (int v : arr) {
277- if (-- cnt[v] < 0 ) {
278- return false ;
279- }
236+ cnt [target [i ] as usize ] += 1 ;
237+ cnt [arr [i ] as usize ] -= 1 ;
280238 }
281- return true ;
239+ cnt . iter () . all ( | v | * v == 0 )
282240 }
283241}
284242```
285243
286- ``` cpp
287- class Solution {
288- public:
289- bool canBeEqual(vector<int >& target, vector<int >& arr) {
290- vector<int > cnt(1001);
291- for (int& v : target) ++cnt[ v] ;
292- for (int& v : arr)
293- if (--cnt[ v] < 0) return false;
294- return true;
295- }
296- };
297- ```
298-
299- ```go
300- func canBeEqual(target []int, arr []int) bool {
301- cnt := make([]int, 1001)
302- for _, v := range target {
303- cnt[v]++
304- }
305- for _, v := range arr {
306- cnt[v]--
307- if cnt[v] < 0 {
308- return false
309- }
310- }
311- return true
312- }
313- ```
314- 315244<!-- tabs: end -->
316245
317246<!-- end -->
0 commit comments