Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit f998bd8

Browse files
feat: add solutions to lc problems: No.3668,3669 (#4681)
1 parent 4211da8 commit f998bd8

File tree

14 files changed

+749
-14
lines changed

14 files changed

+749
-14
lines changed

‎solution/3600-3699/3668.Restore Finishing Order/README.md‎

Lines changed: 60 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -67,32 +67,88 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3668.Re
6767

6868
<!-- solution:start -->
6969

70-
### 方法一
70+
### 方法一:自定义排序
71+
72+
我们先根据 $\textit{order}$ 数组构建一个映射,记录每个 ID 的完成顺序。然后对 $\textit{friends}$ 数组进行排序,排序的依据就是这些 ID 在 $\textit{order}$ 中的完成顺序。
73+
74+
时间复杂度 $O(n \times \log n),ドル空间复杂度 $O(n)$。其中 $n$ 是数组 $\textit{order}$ 的长度。
7175

7276
<!-- tabs:start -->
7377

7478
#### Python3
7579

7680
```python
77-
81+
class Solution:
82+
def recoverOrder(self, order: List[int], friends: List[int]) -> List[int]:
83+
d = {x: i for i, x in enumerate(order)}
84+
return sorted(friends, key=lambda x: d[x])
7885
```
7986

8087
#### Java
8188

8289
```java
83-
90+
class Solution {
91+
public int[] recoverOrder(int[] order, int[] friends) {
92+
int n = order.length;
93+
int[] d = new int[n + 1];
94+
for (int i = 0; i < n; ++i) {
95+
d[order[i]] = i;
96+
}
97+
return Arrays.stream(friends)
98+
.boxed()
99+
.sorted((a, b) -> d[a] - d[b])
100+
.mapToInt(Integer::intValue)
101+
.toArray();
102+
}
103+
}
84104
```
85105

86106
#### C++
87107

88108
```cpp
89-
109+
class Solution {
110+
public:
111+
vector<int> recoverOrder(vector<int>& order, vector<int>& friends) {
112+
int n = order.size();
113+
vector<int> d(n + 1);
114+
for (int i = 0; i < n; ++i) {
115+
d[order[i]] = i;
116+
}
117+
sort(friends.begin(), friends.end(), [&](int a, int b) {
118+
return d[a] < d[b];
119+
});
120+
return friends;
121+
}
122+
};
90123
```
91124
92125
#### Go
93126
94127
```go
128+
func recoverOrder(order []int, friends []int) []int {
129+
n := len(order)
130+
d := make([]int, n+1)
131+
for i, x := range order {
132+
d[x] = i
133+
}
134+
sort.Slice(friends, func(i, j int) bool {
135+
return d[friends[i]] < d[friends[j]]
136+
})
137+
return friends
138+
}
139+
```
95140

141+
#### TypeScript
142+
143+
```ts
144+
function recoverOrder(order: number[], friends: number[]): number[] {
145+
const n = order.length;
146+
const d: number[] = Array(n + 1).fill(0);
147+
for (let i = 0; i < n; ++i) {
148+
d[order[i]] = i;
149+
}
150+
return friends.sort((a, b) => d[a] - d[b]);
151+
}
96152
```
97153

98154
<!-- tabs:end -->

‎solution/3600-3699/3668.Restore Finishing Order/README_EN.md‎

Lines changed: 60 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -65,32 +65,88 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3668.Re
6565

6666
<!-- solution:start -->
6767

68-
### Solution 1
68+
### Solution 1: Custom Sorting
69+
70+
First, we build a mapping from the order array to record the finishing position of each ID. Then, we sort the friends array based on the finishing order of these IDs in the order array.
71+
72+
The time complexity is $O(n \times \log n),ドル and the space complexity is $O(n),ドル where $n$ is the length of the order array.
6973

7074
<!-- tabs:start -->
7175

7276
#### Python3
7377

7478
```python
75-
79+
class Solution:
80+
def recoverOrder(self, order: List[int], friends: List[int]) -> List[int]:
81+
d = {x: i for i, x in enumerate(order)}
82+
return sorted(friends, key=lambda x: d[x])
7683
```
7784

7885
#### Java
7986

8087
```java
81-
88+
class Solution {
89+
public int[] recoverOrder(int[] order, int[] friends) {
90+
int n = order.length;
91+
int[] d = new int[n + 1];
92+
for (int i = 0; i < n; ++i) {
93+
d[order[i]] = i;
94+
}
95+
return Arrays.stream(friends)
96+
.boxed()
97+
.sorted((a, b) -> d[a] - d[b])
98+
.mapToInt(Integer::intValue)
99+
.toArray();
100+
}
101+
}
82102
```
83103

84104
#### C++
85105

86106
```cpp
87-
107+
class Solution {
108+
public:
109+
vector<int> recoverOrder(vector<int>& order, vector<int>& friends) {
110+
int n = order.size();
111+
vector<int> d(n + 1);
112+
for (int i = 0; i < n; ++i) {
113+
d[order[i]] = i;
114+
}
115+
sort(friends.begin(), friends.end(), [&](int a, int b) {
116+
return d[a] < d[b];
117+
});
118+
return friends;
119+
}
120+
};
88121
```
89122
90123
#### Go
91124
92125
```go
126+
func recoverOrder(order []int, friends []int) []int {
127+
n := len(order)
128+
d := make([]int, n+1)
129+
for i, x := range order {
130+
d[x] = i
131+
}
132+
sort.Slice(friends, func(i, j int) bool {
133+
return d[friends[i]] < d[friends[j]]
134+
})
135+
return friends
136+
}
137+
```
93138

139+
#### TypeScript
140+
141+
```ts
142+
function recoverOrder(order: number[], friends: number[]): number[] {
143+
const n = order.length;
144+
const d: number[] = Array(n + 1).fill(0);
145+
for (let i = 0; i < n; ++i) {
146+
d[order[i]] = i;
147+
}
148+
return friends.sort((a, b) => d[a] - d[b]);
149+
}
94150
```
95151

96152
<!-- tabs:end -->
Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
class Solution {
2+
public:
3+
vector<int> recoverOrder(vector<int>& order, vector<int>& friends) {
4+
int n = order.size();
5+
vector<int> d(n + 1);
6+
for (int i = 0; i < n; ++i) {
7+
d[order[i]] = i;
8+
}
9+
sort(friends.begin(), friends.end(), [&](int a, int b) {
10+
return d[a] < d[b];
11+
});
12+
return friends;
13+
}
14+
};
Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
func recoverOrder(order []int, friends []int) []int {
2+
n := len(order)
3+
d := make([]int, n+1)
4+
for i, x := range order {
5+
d[x] = i
6+
}
7+
sort.Slice(friends, func(i, j int) bool {
8+
return d[friends[i]] < d[friends[j]]
9+
})
10+
return friends
11+
}
Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
class Solution {
2+
public int[] recoverOrder(int[] order, int[] friends) {
3+
int n = order.length;
4+
int[] d = new int[n + 1];
5+
for (int i = 0; i < n; ++i) {
6+
d[order[i]] = i;
7+
}
8+
return Arrays.stream(friends)
9+
.boxed()
10+
.sorted((a, b) -> d[a] - d[b])
11+
.mapToInt(Integer::intValue)
12+
.toArray();
13+
}
14+
}
Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,4 @@
1+
class Solution:
2+
def recoverOrder(self, order: List[int], friends: List[int]) -> List[int]:
3+
d = {x: i for i, x in enumerate(order)}
4+
return sorted(friends, key=lambda x: d[x])
Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
function recoverOrder(order: number[], friends: number[]): number[] {
2+
const n = order.length;
3+
const d: number[] = Array(n + 1).fill(0);
4+
for (let i = 0; i < n; ++i) {
5+
d[order[i]] = i;
6+
}
7+
return friends.sort((a, b) => d[a] - d[b]);
8+
}

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /