Skip to content

Commit bcf70ff

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.2459
No.2459.Sort Array by Moving Items to Empty Space
1 parent d573c84 commit bcf70ff

File tree

6 files changed

+382
-2
lines changed

6 files changed

+382
-2
lines changed

‎solution/2400-2499/2459.Sort Array by Moving Items to Empty Space/README.md

Lines changed: 137 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -67,22 +67,158 @@ It can be proven that 2 is the minimum number of operations needed.
6767

6868
<!-- 这里可写通用的实现逻辑 -->
6969

70+
**方法一：置换环**
71+
72+
一个长度为 $m$ 的置换环，如果 $0$ 在环中，那么交换次数为 $m-1$，否则交换次数为 $m+1$。
73+
74+
我们找到所有置换环，先按照交换次数为 $m+1$ 计算总的次数，然后判断 $0$ 是否错位，若是，说明 $0$ 在置换环中，那么总的次数减 $2$。
75+
76+
这里 $0$ 可以在 $0$ 位置，也可以在 $n-1$ 位置，我们取这两种情况的最小值。
77+
78+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组长度。
79+
7080
<!-- tabs:start -->
7181

7282
### **Python3**
7383

7484
<!-- 这里可写当前语言的特殊实现逻辑 -->
7585

7686
```python
77-
87+
class Solution:
88+
def sortArray(self, nums: List[int]) -> int:
89+
def f(nums, k):
90+
vis = [False] * n
91+
cnt = 0
92+
for i, v in enumerate(nums):
93+
if i == v or vis[i]:
94+
continue
95+
cnt += 1
96+
j = i
97+
while not vis[j]:
98+
vis[j] = True
99+
cnt += 1
100+
j = nums[j]
101+
return cnt - 2 * (nums[k] != k)
102+
103+
n = len(nums)
104+
a = f(nums, 0)
105+
b = f([(v - 1 + n) % n for v in nums], n - 1)
106+
return min(a, b)
78107
```
79108

80109
### **Java**
81110

82111
<!-- 这里可写当前语言的特殊实现逻辑 -->
83112

84113
```java
114+
class Solution {
115+
public int sortArray(int[] nums) {
116+
int n = nums.length;
117+
int[] arr = new int[n];
118+
for (int i = 0; i < n; ++i) {
119+
arr[i] = (nums[i] - 1 + n) % n;
120+
}
121+
int a = f(nums, 0);
122+
int b = f(arr, n - 1);
123+
return Math.min(a, b);
124+
}
125+
126+
private int f(int[] nums, int k) {
127+
boolean[] vis = new boolean[nums.length];
128+
int cnt = 0;
129+
for (int i = 0; i < nums.length; ++i) {
130+
if (i == nums[i] || vis[i]) {
131+
continue;
132+
}
133+
++cnt;
134+
int j = nums[i];
135+
while (!vis[j]) {
136+
vis[j] = true;
137+
++cnt;
138+
j = nums[j];
139+
}
140+
}
141+
if (nums[k] != k) {
142+
cnt -= 2;
143+
}
144+
return cnt;
145+
}
146+
}
147+
```
148+
149+
### **C++**
150+
151+
```cpp
152+
class Solution {
153+
public:
154+
int sortArray(vector<int>& nums) {
155+
int n = nums.size();
156+
auto f = [&](vector<int>& nums, int k) {
157+
vector<bool> vis(n);
158+
int cnt = 0;
159+
for (int i = 0; i < n; ++i) {
160+
if (i == nums[i] || vis[i]) continue;
161+
int j = i;
162+
++cnt;
163+
while (!vis[j]) {
164+
vis[j] = true;
165+
++cnt;
166+
j = nums[j];
167+
}
168+
}
169+
if (nums[k] != k) cnt -= 2;
170+
return cnt;
171+
};
172+
173+
int a = f(nums, 0);
174+
vector<int> arr = nums;
175+
for (int& v : arr) v = (v - 1 + n) % n;
176+
int b = f(arr, n - 1);
177+
return min(a, b);
178+
}
179+
};
180+
```
85181

182+
### **Go**
183+
184+
```go
185+
func sortArray(nums []int) int {
186+
n := len(nums)
187+
f := func(nums []int, k int) int {
188+
vis := make([]bool, n)
189+
cnt := 0
190+
for i, v := range nums {
191+
if i == v || vis[i] {
192+
continue
193+
}
194+
cnt++
195+
j := i
196+
for !vis[j] {
197+
vis[j] = true
198+
cnt++
199+
j = nums[j]
200+
}
201+
}
202+
if nums[k] != k {
203+
cnt -= 2
204+
}
205+
return cnt
206+
}
207+
a := f(nums, 0)
208+
arr := make([]int, n)
209+
for i, v := range nums {
210+
arr[i] = (v - 1 + n) % n
211+
}
212+
b := f(arr, n-1)
213+
return min(a, b)
214+
}
215+
216+
func min(a, b int) int {
217+
if a < b {
218+
return a
219+
}
220+
return b
221+
}
86222
```
87223

88224
### **TypeScript**

‎solution/2400-2499/2459.Sort Array by Moving Items to Empty Space/README_EN.md

Lines changed: 127 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -68,13 +68,139 @@ It can be proven that 2 is the minimum number of operations needed.
6868
### **Python3**
6969

7070
```python
71-
71+
class Solution:
72+
def sortArray(self, nums: List[int]) -> int:
73+
def f(nums, k):
74+
vis = [False] * n
75+
cnt = 0
76+
for i, v in enumerate(nums):
77+
if i == v or vis[i]:
78+
continue
79+
cnt += 1
80+
j = i
81+
while not vis[j]:
82+
vis[j] = True
83+
cnt += 1
84+
j = nums[j]
85+
return cnt - 2 * (nums[k] != k)
86+
87+
n = len(nums)
88+
a = f(nums, 0)
89+
b = f([(v - 1 + n) % n for v in nums], n - 1)
90+
return min(a, b)
7291
```
7392

7493
### **Java**
7594

7695
```java
96+
class Solution {
97+
public int sortArray(int[] nums) {
98+
int n = nums.length;
99+
int[] arr = new int[n];
100+
for (int i = 0; i < n; ++i) {
101+
arr[i] = (nums[i] - 1 + n) % n;
102+
}
103+
int a = f(nums, 0);
104+
int b = f(arr, n - 1);
105+
return Math.min(a, b);
106+
}
107+
108+
private int f(int[] nums, int k) {
109+
boolean[] vis = new boolean[nums.length];
110+
int cnt = 0;
111+
for (int i = 0; i < nums.length; ++i) {
112+
if (i == nums[i] || vis[i]) {
113+
continue;
114+
}
115+
++cnt;
116+
int j = nums[i];
117+
while (!vis[j]) {
118+
vis[j] = true;
119+
++cnt;
120+
j = nums[j];
121+
}
122+
}
123+
if (nums[k] != k) {
124+
cnt -= 2;
125+
}
126+
return cnt;
127+
}
128+
}
129+
```
130+
131+
### **C++**
132+
133+
```cpp
134+
class Solution {
135+
public:
136+
int sortArray(vector<int>& nums) {
137+
int n = nums.size();
138+
auto f = [&](vector<int>& nums, int k) {
139+
vector<bool> vis(n);
140+
int cnt = 0;
141+
for (int i = 0; i < n; ++i) {
142+
if (i == nums[i] || vis[i]) continue;
143+
int j = i;
144+
++cnt;
145+
while (!vis[j]) {
146+
vis[j] = true;
147+
++cnt;
148+
j = nums[j];
149+
}
150+
}
151+
if (nums[k] != k) cnt -= 2;
152+
return cnt;
153+
};
154+
155+
int a = f(nums, 0);
156+
vector<int> arr = nums;
157+
for (int& v : arr) v = (v - 1 + n) % n;
158+
int b = f(arr, n - 1);
159+
return min(a, b);
160+
}
161+
};
162+
```
77163
164+
### **Go**
165+
166+
```go
167+
func sortArray(nums []int) int {
168+
n := len(nums)
169+
f := func(nums []int, k int) int {
170+
vis := make([]bool, n)
171+
cnt := 0
172+
for i, v := range nums {
173+
if i == v || vis[i] {
174+
continue
175+
}
176+
cnt++
177+
j := i
178+
for !vis[j] {
179+
vis[j] = true
180+
cnt++
181+
j = nums[j]
182+
}
183+
}
184+
if nums[k] != k {
185+
cnt -= 2
186+
}
187+
return cnt
188+
}
189+
a := f(nums, 0)
190+
arr := make([]int, n)
191+
for i, v := range nums {
192+
arr[i] = (v - 1 + n) % n
193+
}
194+
b := f(arr, n-1)
195+
return min(a, b)
196+
}
197+
198+
func min(a, b int) int {
199+
if a < b {
200+
return a
201+
}
202+
return b
203+
}
78204
```
79205

80206
### **TypeScript**

‎solution/2400-2499/2459.Sort Array by Moving Items to Empty Space/Solution.cpp

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
class Solution {
2+
public:
3+
int sortArray(vector<int>& nums) {
4+
int n = nums.size();
5+
auto f = [&](vector<int>& nums, int k) {
6+
vector<bool> vis(n);
7+
int cnt = 0;
8+
for (int i = 0; i < n; ++i) {
9+
if (i == nums[i] || vis[i]) continue;
10+
int j = i;
11+
++cnt;
12+
while (!vis[j]) {
13+
vis[j] = true;
14+
++cnt;
15+
j = nums[j];
16+
}
17+
}
18+
if (nums[k] != k) cnt -= 2;
19+
return cnt;
20+
};
21+
22+
int a = f(nums, 0);
23+
vector<int> arr = nums;
24+
for (int& v : arr) v = (v - 1 + n) % n;
25+
int b = f(arr, n - 1);
26+
return min(a, b);
27+
}
28+
};

‎solution/2400-2499/2459.Sort Array by Moving Items to Empty Space/Solution.go

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
func sortArray(nums []int) int {
2+
n := len(nums)
3+
f := func(nums []int, k int) int {
4+
vis := make([]bool, n)
5+
cnt := 0
6+
for i, v := range nums {
7+
if i == v || vis[i] {
8+
continue
9+
}
10+
cnt++
11+
j := i
12+
for !vis[j] {
13+
vis[j] = true
14+
cnt++
15+
j = nums[j]
16+
}
17+
}
18+
if nums[k] != k {
19+
cnt -= 2
20+
}
21+
return cnt
22+
}
23+
a := f(nums, 0)
24+
arr := make([]int, n)
25+
for i, v := range nums {
26+
arr[i] = (v - 1 + n) % n
27+
}
28+
b := f(arr, n-1)
29+
return min(a, b)
30+
}
31+
32+
func min(a, b int) int {
33+
if a < b {
34+
return a
35+
}
36+
return b
37+
}

0 commit comments

Comments
 (0)