Skip to content

Commit 8420b81

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.3011 (doocs#2246)
No.3011.Find if Array Can Be Sorted
1 parent 29d3201 commit 8420b81

File tree

7 files changed

+347
-8
lines changed

7 files changed

+347
-8
lines changed

‎solution/3000-3099/3011.Find if Array Can Be Sorted/README.md

Lines changed: 118 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -56,24 +56,138 @@
5656

5757
## 解法
5858

59-
### 方法一
59+
### 方法一：双指针
60+
61+
我们可以使用双指针，将数组 $nums$ 分成若干个子数组，每个子数组中的元素的二进制表示中 $1$ 的个数相同。对于每个子数组，我们只需要关注它的最大值和最小值，如果最小值比上一个子数组的最大值小，那么就无法通过交换使得数组有序。
62+
63+
时间复杂度 $O(n)$，其中 $n$ 是数组 $nums$ 的长度。空间复杂度 $O(1)$。
6064

6165
<!-- tabs:start -->
6266

6367
```python
64-
68+
class Solution:
69+
def canSortArray(self, nums: List[int]) -> bool:
70+
pre_mx = -inf
71+
i, n = 0, len(nums)
72+
while i < n:
73+
j = i + 1
74+
cnt = nums[i].bit_count()
75+
mi = mx = nums[i]
76+
while j < n and nums[j].bit_count() == cnt:
77+
mi = min(mi, nums[j])
78+
mx = max(mx, nums[j])
79+
j += 1
80+
if pre_mx > mi:
81+
return False
82+
pre_mx = mx
83+
i = j
84+
return True
6585
```
6686

6787
```java
68-
88+
class Solution {
89+
public boolean canSortArray(int[] nums) {
90+
int preMx = -300;
91+
int i = 0, n = nums.length;
92+
while (i < n) {
93+
int j = i + 1;
94+
int cnt = Integer.bitCount(nums[i]);
95+
int mi = nums[i], mx = nums[i];
96+
while (j < n && Integer.bitCount(nums[j]) == cnt) {
97+
mi = Math.min(mi, nums[j]);
98+
mx = Math.max(mx, nums[j]);
99+
j++;
100+
}
101+
if (preMx > mi) {
102+
return false;
103+
}
104+
preMx = mx;
105+
i = j;
106+
}
107+
return true;
108+
}
109+
}
69110
```
70111

71112
```cpp
72-
113+
class Solution {
114+
public:
115+
bool canSortArray(vector<int>& nums) {
116+
int preMx = -300;
117+
int i = 0, n = nums.size();
118+
while (i < n) {
119+
int j = i + 1;
120+
int cnt = __builtin_popcount(nums[i]);
121+
int mi = nums[i], mx = nums[i];
122+
while (j < n && __builtin_popcount(nums[j]) == cnt) {
123+
mi = min(mi, nums[j]);
124+
mx = max(mx, nums[j]);
125+
j++;
126+
}
127+
if (preMx > mi) {
128+
return false;
129+
}
130+
preMx = mx;
131+
i = j;
132+
}
133+
return true;
134+
}
135+
};
73136
```
74137
75138
```go
139+
func canSortArray(nums []int) bool {
140+
preMx := -300
141+
i, n := 0, len(nums)
142+
for i < n {
143+
j := i + 1
144+
cnt := bits.OnesCount(uint(nums[i]))
145+
mi, mx := nums[i], nums[i]
146+
for j < n && bits.OnesCount(uint(nums[j])) == cnt {
147+
mi = min(mi, nums[j])
148+
mx = max(mx, nums[j])
149+
j++
150+
}
151+
if preMx > mi {
152+
return false
153+
}
154+
preMx = mx
155+
i = j
156+
}
157+
return true
158+
}
159+
```
76160

161+
```ts
162+
function canSortArray(nums: number[]): boolean {
163+
let preMx = -300;
164+
const n = nums.length;
165+
for (let i = 0; i < n; ) {
166+
let j = i + 1;
167+
const cnt = bitCount(nums[i]);
168+
let [mi, mx] = [nums[i], nums[i]];
169+
while (j < n && bitCount(nums[j]) === cnt) {
170+
mi = Math.min(mi, nums[j]);
171+
mx = Math.max(mx, nums[j]);
172+
j++;
173+
}
174+
if (preMx > mi) {
175+
return false;
176+
}
177+
preMx = mx;
178+
i = j;
179+
}
180+
return true;
181+
}
182+
183+
function bitCount(i: number): number {
184+
i = i - ((i >>> 1) & 0x55555555);
185+
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
186+
i = (i + (i >>> 4)) & 0x0f0f0f0f;
187+
i = i + (i >>> 8);
188+
i = i + (i >>> 16);
189+
return i & 0x3f;
190+
}
77191
```
78192

79193
<!-- tabs:end -->

‎solution/3000-3099/3011.Find if Array Can Be Sorted/README_EN.md

Lines changed: 118 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -52,24 +52,138 @@ Note that there may be other sequences of operations which also sort the array.
5252

5353
## Solutions
5454

55-
### Solution 1
55+
### Solution 1: Two Pointers
56+
57+
We can use two pointers to divide the array $nums$ into several subarrays, each with the same number of 1s in the binary representation of its elements. For each subarray, we only need to focus on its maximum and minimum values. If the minimum value is smaller than the maximum value of the previous subarray, then it is impossible to make the array sorted by swapping.
58+
59+
The time complexity is $O(n)$, where $n$ is the length of the array $nums$. The space complexity is $O(1)$.
5660

5761
<!-- tabs:start -->
5862

5963
```python
60-
64+
class Solution:
65+
def canSortArray(self, nums: List[int]) -> bool:
66+
pre_mx = -inf
67+
i, n = 0, len(nums)
68+
while i < n:
69+
j = i + 1
70+
cnt = nums[i].bit_count()
71+
mi = mx = nums[i]
72+
while j < n and nums[j].bit_count() == cnt:
73+
mi = min(mi, nums[j])
74+
mx = max(mx, nums[j])
75+
j += 1
76+
if pre_mx > mi:
77+
return False
78+
pre_mx = mx
79+
i = j
80+
return True
6181
```
6282

6383
```java
64-
84+
class Solution {
85+
public boolean canSortArray(int[] nums) {
86+
int preMx = -300;
87+
int i = 0, n = nums.length;
88+
while (i < n) {
89+
int j = i + 1;
90+
int cnt = Integer.bitCount(nums[i]);
91+
int mi = nums[i], mx = nums[i];
92+
while (j < n && Integer.bitCount(nums[j]) == cnt) {
93+
mi = Math.min(mi, nums[j]);
94+
mx = Math.max(mx, nums[j]);
95+
j++;
96+
}
97+
if (preMx > mi) {
98+
return false;
99+
}
100+
preMx = mx;
101+
i = j;
102+
}
103+
return true;
104+
}
105+
}
65106
```
66107

67108
```cpp
68-
109+
class Solution {
110+
public:
111+
bool canSortArray(vector<int>& nums) {
112+
int preMx = -300;
113+
int i = 0, n = nums.size();
114+
while (i < n) {
115+
int j = i + 1;
116+
int cnt = __builtin_popcount(nums[i]);
117+
int mi = nums[i], mx = nums[i];
118+
while (j < n && __builtin_popcount(nums[j]) == cnt) {
119+
mi = min(mi, nums[j]);
120+
mx = max(mx, nums[j]);
121+
j++;
122+
}
123+
if (preMx > mi) {
124+
return false;
125+
}
126+
preMx = mx;
127+
i = j;
128+
}
129+
return true;
130+
}
131+
};
69132
```
70133
71134
```go
135+
func canSortArray(nums []int) bool {
136+
preMx := -300
137+
i, n := 0, len(nums)
138+
for i < n {
139+
j := i + 1
140+
cnt := bits.OnesCount(uint(nums[i]))
141+
mi, mx := nums[i], nums[i]
142+
for j < n && bits.OnesCount(uint(nums[j])) == cnt {
143+
mi = min(mi, nums[j])
144+
mx = max(mx, nums[j])
145+
j++
146+
}
147+
if preMx > mi {
148+
return false
149+
}
150+
preMx = mx
151+
i = j
152+
}
153+
return true
154+
}
155+
```
72156

157+
```ts
158+
function canSortArray(nums: number[]): boolean {
159+
let preMx = -300;
160+
const n = nums.length;
161+
for (let i = 0; i < n; ) {
162+
let j = i + 1;
163+
const cnt = bitCount(nums[i]);
164+
let [mi, mx] = [nums[i], nums[i]];
165+
while (j < n && bitCount(nums[j]) === cnt) {
166+
mi = Math.min(mi, nums[j]);
167+
mx = Math.max(mx, nums[j]);
168+
j++;
169+
}
170+
if (preMx > mi) {
171+
return false;
172+
}
173+
preMx = mx;
174+
i = j;
175+
}
176+
return true;
177+
}
178+
179+
function bitCount(i: number): number {
180+
i = i - ((i >>> 1) & 0x55555555);
181+
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
182+
i = (i + (i >>> 4)) & 0x0f0f0f0f;
183+
i = i + (i >>> 8);
184+
i = i + (i >>> 16);
185+
return i & 0x3f;
186+
}
73187
```
74188

75189
<!-- tabs:end -->

‎solution/3000-3099/3011.Find if Array Can Be Sorted/Solution.cpp

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
class Solution {
2+
public:
3+
bool canSortArray(vector<int>& nums) {
4+
int preMx = -300;
5+
int i = 0, n = nums.size();
6+
while (i < n) {
7+
int j = i + 1;
8+
int cnt = __builtin_popcount(nums[i]);
9+
int mi = nums[i], mx = nums[i];
10+
while (j < n && __builtin_popcount(nums[j]) == cnt) {
11+
mi = min(mi, nums[j]);
12+
mx = max(mx, nums[j]);
13+
j++;
14+
}
15+
if (preMx > mi) {
16+
return false;
17+
}
18+
preMx = mx;
19+
i = j;
20+
}
21+
return true;
22+
}
23+
};

‎solution/3000-3099/3011.Find if Array Can Be Sorted/Solution.go

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
func canSortArray(nums []int) bool {
2+
preMx := -300
3+
i, n := 0, len(nums)
4+
for i < n {
5+
j := i + 1
6+
cnt := bits.OnesCount(uint(nums[i]))
7+
mi, mx := nums[i], nums[i]
8+
for j < n && bits.OnesCount(uint(nums[j])) == cnt {
9+
mi = min(mi, nums[j])
10+
mx = max(mx, nums[j])
11+
j++
12+
}
13+
if preMx > mi {
14+
return false
15+
}
16+
preMx = mx
17+
i = j
18+
}
19+
return true
20+
}

‎solution/3000-3099/3011.Find if Array Can Be Sorted/Solution.java

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
class Solution {
2+
public boolean canSortArray(int[] nums) {
3+
int preMx = -300;
4+
int i = 0, n = nums.length;
5+
while (i < n) {
6+
int j = i + 1;
7+
int cnt = Integer.bitCount(nums[i]);
8+
int mi = nums[i], mx = nums[i];
9+
while (j < n && Integer.bitCount(nums[j]) == cnt) {
10+
mi = Math.min(mi, nums[j]);
11+
mx = Math.max(mx, nums[j]);
12+
j++;
13+
}
14+
if (preMx > mi) {
15+
return false;
16+
}
17+
preMx = mx;
18+
i = j;
19+
}
20+
return true;
21+
}
22+
}

‎solution/3000-3099/3011.Find if Array Can Be Sorted/Solution.py

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
class Solution:
2+
def canSortArray(self, nums: List[int]) -> bool:
3+
pre_mx = -inf
4+
i, n = 0, len(nums)
5+
while i < n:
6+
j = i + 1
7+
cnt = nums[i].bit_count()
8+
mi = mx = nums[i]
9+
while j < n and nums[j].bit_count() == cnt:
10+
mi = min(mi, nums[j])
11+
mx = max(mx, nums[j])
12+
j += 1
13+
if pre_mx > mi:
14+
return False
15+
pre_mx = mx
16+
i = j
17+
return True

0 commit comments

Comments
 (0)