Skip to content

Commit 444c465

Browse files
authored
feat: add solutions to lc problem: No.1845 (doocs#3586)
No.1845.Seat Reservation Manager
1 parent 882870c commit 444c465

File tree

5 files changed

+106
-40
lines changed

5 files changed

+106
-40
lines changed

solution/1800-1899/1845.Seat Reservation Manager/README.md

+38-15
Original file line numberDiff line numberDiff line change
@@ -71,15 +71,13 @@ seatManager.unreserve(5); // 将座位 5 变为可以预约,现在可预约的
7171

7272
### 方法一:优先队列(小根堆)
7373

74-
我们可以使用优先队列(小根堆)来维护可预约座位的最小编号
74+
我们定义一个优先队列(小根堆)$\textit{q}$,用于存储所有可预约的座位编号。初始时,我们将 $1$ 到 $n$ 的所有座位编号加入到 $\textit{q}$ 中
7575

76-
初始化时,将所有座位的编号放入优先队列中
76+
调用 `reserve` 方法时,我们从 $\textit{q}$ 中弹出堆顶元素,即可预约的座位编号的最小值
7777

78-
当调用 `reserve` 方法时,从优先队列中取出最小编号的座位,即为可预约座位的最小编号
78+
调用 `unreserve` 方法时,我们将座位编号加入到 $\textit{q}$ 中
7979

80-
当调用 `unreserve` 方法时,将座位编号放入优先队列中。
81-
82-
时间复杂度 $O(n \times \log n)$,空间复杂度 $O(n)$。其中 $n$ 为座位的数量。
80+
时间复杂度方面,初始化的时间复杂度为 $O(n)$ 或 $O(n \times \log n)$,`reserve``unreserve` 方法的时间复杂度均为 $O(\log n)$。空间复杂度为 $O(n)$。
8381

8482
<!-- tabs:start -->
8583

@@ -89,7 +87,6 @@ seatManager.unreserve(5); // 将座位 5 变为可以预约,现在可预约的
8987
class SeatManager:
9088
def __init__(self, n: int):
9189
self.q = list(range(1, n + 1))
92-
heapify(self.q)
9390

9491
def reserve(self) -> int:
9592
return heappop(self.q)
@@ -208,27 +205,53 @@ func (h *hp) Pop() any {
208205
*/
209206
```
210207

208+
#### TypeScript
209+
210+
```ts
211+
class SeatManager {
212+
private q: typeof MinPriorityQueue;
213+
constructor(n: number) {
214+
this.q = new MinPriorityQueue();
215+
for (let i = 1; i <= n; i++) {
216+
this.q.enqueue(i);
217+
}
218+
}
219+
220+
reserve(): number {
221+
return this.q.dequeue().element;
222+
}
223+
224+
unreserve(seatNumber: number): void {
225+
this.q.enqueue(seatNumber);
226+
}
227+
}
228+
229+
/**
230+
* Your SeatManager object will be instantiated and called as such:
231+
* var obj = new SeatManager(n)
232+
* var param_1 = obj.reserve()
233+
* obj.unreserve(seatNumber)
234+
*/
235+
```
236+
211237
#### C#
212238

213239
```cs
214240
public class SeatManager {
215-
private SortedSet<int> availableSeats;
241+
private PriorityQueue<int, int> q = new PriorityQueue<int, int>();
216242

217243
public SeatManager(int n) {
218-
availableSeats = new SortedSet<int>();
219-
for (int i = 1; i <= n; i++) {
220-
availableSeats.Add(i);
244+
for (int i = 1; i <= n; ++i) {
245+
q.Enqueue(i, i);
221246
}
222247
}
223248

224249
public int Reserve() {
225-
int reservedSeat = availableSeats.Min;
226-
availableSeats.Remove(reservedSeat);
227-
return reservedSeat;
250+
return q.Dequeue();
228251
}
229252

230253
public void Unreserve(int seatNumber) {
231-
availableSeats.Add(seatNumber);
254+
q.Enqueue(seatNumber, seatNumber);
232255
}
233256
}
234257

solution/1800-1899/1845.Seat Reservation Manager/README_EN.md

+39-16
Original file line numberDiff line numberDiff line change
@@ -68,17 +68,15 @@ seatManager.unreserve(5); // Unreserve seat 5, so now the available seats are [5
6868

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

71-
### Solution 1: Priority Queue (Min Heap)
71+
### Solution 1: Priority Queue (Min-Heap)
7272

73-
We can use a priority queue (min heap) to maintain the smallest number of reservable seats.
73+
We define a priority queue (min-heap) $\textit{q}$ to store all the available seat numbers. Initially, we add all seat numbers from $1$ to $n$ into $\textit{q}$.
7474

75-
Initially, put all seat numbers into the priority queue.
75+
When calling the `reserve` method, we pop the top element from $\textit{q}$, which is the smallest available seat number.
7676

77-
When the `reserve` method is called, take out the smallest number from the priority queue, which is the smallest number of reservable seats.
77+
When calling the `unreserve` method, we add the seat number back into $\textit{q}$.
7878

79-
When the `unreserve` method is called, put the seat number back into the priority queue.
80-
81-
The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$. Where $n$ is the number of seats.
79+
In terms of time complexity, the initialization time complexity is $O(n)$ or $O(n \times \log n)$, and the time complexity of the `reserve` and `unreserve` methods is both $O(\log n)$. The space complexity is $O(n)$.
8280

8381
<!-- tabs:start -->
8482

@@ -88,7 +86,6 @@ The time complexity is $O(n \times \log n)$, and the space complexity is $O(n)$.
8886
class SeatManager:
8987
def __init__(self, n: int):
9088
self.q = list(range(1, n + 1))
91-
heapify(self.q)
9289

9390
def reserve(self) -> int:
9491
return heappop(self.q)
@@ -207,27 +204,53 @@ func (h *hp) Pop() any {
207204
*/
208205
```
209206

207+
#### TypeScript
208+
209+
```ts
210+
class SeatManager {
211+
private q: typeof MinPriorityQueue;
212+
constructor(n: number) {
213+
this.q = new MinPriorityQueue();
214+
for (let i = 1; i <= n; i++) {
215+
this.q.enqueue(i);
216+
}
217+
}
218+
219+
reserve(): number {
220+
return this.q.dequeue().element;
221+
}
222+
223+
unreserve(seatNumber: number): void {
224+
this.q.enqueue(seatNumber);
225+
}
226+
}
227+
228+
/**
229+
* Your SeatManager object will be instantiated and called as such:
230+
* var obj = new SeatManager(n)
231+
* var param_1 = obj.reserve()
232+
* obj.unreserve(seatNumber)
233+
*/
234+
```
235+
210236
#### C#
211237

212238
```cs
213239
public class SeatManager {
214-
private SortedSet<int> availableSeats;
240+
private PriorityQueue<int, int> q = new PriorityQueue<int, int>();
215241

216242
public SeatManager(int n) {
217-
availableSeats = new SortedSet<int>();
218-
for (int i = 1; i <= n; i++) {
219-
availableSeats.Add(i);
243+
for (int i = 1; i <= n; ++i) {
244+
q.Enqueue(i, i);
220245
}
221246
}
222247

223248
public int Reserve() {
224-
int reservedSeat = availableSeats.Min;
225-
availableSeats.Remove(reservedSeat);
226-
return reservedSeat;
249+
return q.Dequeue();
227250
}
228251

229252
public void Unreserve(int seatNumber) {
230-
availableSeats.Add(seatNumber);
253+
q.Enqueue(seatNumber, seatNumber);
231254
}
232255
}
233256

solution/1800-1899/1845.Seat Reservation Manager/Solution.cs

+5-8
Original file line numberDiff line numberDiff line change
@@ -1,21 +1,18 @@
11
public class SeatManager {
2-
private SortedSet<int> availableSeats;
2+
private PriorityQueue<int, int> q = new PriorityQueue<int, int>();
33

44
public SeatManager(int n) {
5-
availableSeats = new SortedSet<int>();
6-
for (int i = 1; i <= n; i++) {
7-
availableSeats.Add(i);
5+
for (int i = 1; i <= n; ++i) {
6+
q.Enqueue(i, i);
87
}
98
}
109

1110
public int Reserve() {
12-
int reservedSeat = availableSeats.Min;
13-
availableSeats.Remove(reservedSeat);
14-
return reservedSeat;
11+
return q.Dequeue();
1512
}
1613

1714
public void Unreserve(int seatNumber) {
18-
availableSeats.Add(seatNumber);
15+
q.Enqueue(seatNumber, seatNumber);
1916
}
2017
}
2118

solution/1800-1899/1845.Seat Reservation Manager/Solution.py

-1
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,6 @@
11
class SeatManager:
22
def __init__(self, n: int):
33
self.q = list(range(1, n + 1))
4-
heapify(self.q)
54

65
def reserve(self) -> int:
76
return heappop(self.q)
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
class SeatManager {
2+
private q: typeof MinPriorityQueue;
3+
constructor(n: number) {
4+
this.q = new MinPriorityQueue();
5+
for (let i = 1; i <= n; i++) {
6+
this.q.enqueue(i);
7+
}
8+
}
9+
10+
reserve(): number {
11+
return this.q.dequeue().element;
12+
}
13+
14+
unreserve(seatNumber: number): void {
15+
this.q.enqueue(seatNumber);
16+
}
17+
}
18+
19+
/**
20+
* Your SeatManager object will be instantiated and called as such:
21+
* var obj = new SeatManager(n)
22+
* var param_1 = obj.reserve()
23+
* obj.unreserve(seatNumber)
24+
*/

0 commit comments

Comments
 (0)