Skip to content

Commit d4b3ea3

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.3439 (#4546)
No.3439.Reschedule Meetings for Maximum Free Time I
1 parent e63bbb4 commit d4b3ea3

File tree

14 files changed

+877
-6
lines changed

14 files changed

+877
-6
lines changed

‎solution/3400-3499/3439.Reschedule Meetings for Maximum Free Time I/README.md

Lines changed: 314 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -93,32 +93,343 @@ tags:
9393

9494
<!-- solution:start -->
9595

96-
### 方法一
96+
### 方法一：滑动窗口
97+
98+
题目相当于把相邻的空闲时间段合并成一个更长的空闲时间段。一共有 $n + 1$ 个空闲时间段，分别是：
99+
100+
- 第一个空闲时间段是从活动开始到第一个会议开始的时间段；
101+
- 中间的 $n - 1$ 个空闲时间段是相邻两个会议之间的时间段；
102+
- 最后一个空闲时间段是最后一个会议结束到活动结束的时间段。
103+
104+
题目最多可以重新安排 $k$ 个会议，等价于最多可以合并 $k + 1$ 个空闲时间段。我们需要找到这 $k + 1$ 个空闲时间段的最大长度。
105+
106+
我们可以将这些空闲时间段的长度存储在一个数组中 $\textit{nums}$ 中。然后，我们一个长度为 $k + 1$ 的滑动窗口，遍历这个数组，计算每个窗口的和，找到最大的和，即为所求的最大空闲时间。
107+
108+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是会议的数量。
97109

98110
<!-- tabs:start -->
99111

100112
#### Python3
101113

102114
```python
103-
115+
class Solution:
116+
def maxFreeTime(
117+
self, eventTime: int, k: int, startTime: List[int], endTime: List[int]
118+
) -> int:
119+
nums = [startTime[0]]
120+
for i in range(1, len(endTime)):
121+
nums.append(startTime[i] - endTime[i - 1])
122+
nums.append(eventTime - endTime[-1])
123+
ans = s = 0
124+
for i, x in enumerate(nums):
125+
s += x
126+
if i >= k:
127+
ans = max(ans, s)
128+
s -= nums[i - k]
129+
return ans
104130
```
105131

106132
#### Java
107133

108134
```java
109-
135+
class Solution {
136+
public int maxFreeTime(int eventTime, int k, int[] startTime, int[] endTime) {
137+
int n = endTime.length;
138+
int[] nums = new int[n + 1];
139+
nums[0] = startTime[0];
140+
for (int i = 1; i < n; ++i) {
141+
nums[i] = startTime[i] - endTime[i - 1];
142+
}
143+
nums[n] = eventTime - endTime[n - 1];
144+
int ans = 0, s = 0;
145+
for (int i = 0; i <= n; ++i) {
146+
s += nums[i];
147+
if (i >= k) {
148+
ans = Math.max(ans, s);
149+
s -= nums[i - k];
150+
}
151+
}
152+
return ans;
153+
}
154+
}
110155
```
111156

112157
#### C++
113158

114159
```cpp
160+
class Solution {
161+
public:
162+
int maxFreeTime(int eventTime, int k, vector<int>& startTime, vector<int>& endTime) {
163+
int n = endTime.size();
164+
vector<int> nums(n + 1);
165+
nums[0] = startTime[0];
166+
for (int i = 1; i < n; ++i) {
167+
nums[i] = startTime[i] - endTime[i - 1];
168+
}
169+
nums[n] = eventTime - endTime[n - 1];
170+
171+
int ans = 0, s = 0;
172+
for (int i = 0; i <= n; ++i) {
173+
s += nums[i];
174+
if (i >= k) {
175+
ans = max(ans, s);
176+
s -= nums[i - k];
177+
}
178+
}
179+
return ans;
180+
}
181+
};
182+
```
183+
184+
#### Go
185+
186+
```go
187+
func maxFreeTime(eventTime int, k int, startTime []int, endTime []int) int {
188+
n := len(endTime)
189+
nums := make([]int, n+1)
190+
nums[0] = startTime[0]
191+
for i := 1; i < n; i++ {
192+
nums[i] = startTime[i] - endTime[i-1]
193+
}
194+
nums[n] = eventTime - endTime[n-1]
195+
196+
ans, s := 0, 0
197+
for i := 0; i <= n; i++ {
198+
s += nums[i]
199+
if i >= k {
200+
ans = max(ans, s)
201+
s -= nums[i-k]
202+
}
203+
}
204+
return ans
205+
}
206+
```
207+
208+
#### TypeScript
209+
210+
```ts
211+
function maxFreeTime(eventTime: number, k: number, startTime: number[], endTime: number[]): number {
212+
const n = endTime.length;
213+
const nums: number[] = new Array(n + 1);
214+
nums[0] = startTime[0];
215+
for (let i = 1; i < n; i++) {
216+
nums[i] = startTime[i] - endTime[i - 1];
217+
}
218+
nums[n] = eventTime - endTime[n - 1];
219+
220+
let [ans, s] = [0, 0];
221+
for (let i = 0; i <= n; i++) {
222+
s += nums[i];
223+
if (i >= k) {
224+
ans = Math.max(ans, s);
225+
s -= nums[i - k];
226+
}
227+
}
228+
return ans;
229+
}
230+
```
231+
232+
#### Rust
233+
234+
```rust
235+
impl Solution {
236+
pub fn max_free_time(event_time: i32, k: i32, start_time: Vec<i32>, end_time: Vec<i32>) -> i32 {
237+
let n = end_time.len();
238+
let mut nums = vec![0; n + 1];
239+
nums[0] = start_time[0];
240+
for i in 1..n {
241+
nums[i] = start_time[i] - end_time[i - 1];
242+
}
243+
nums[n] = event_time - end_time[n - 1];
244+
245+
let mut ans = 0;
246+
let mut s = 0;
247+
for i in 0..=n {
248+
s += nums[i];
249+
if i as i32 >= k {
250+
ans = ans.max(s);
251+
s -= nums[i - k as usize];
252+
}
253+
}
254+
ans
255+
}
256+
}
257+
```
258+
259+
<!-- tabs:end -->
260+
261+
<!-- solution:end -->
262+
263+
<!-- solution:start -->
264+
265+
### 方法二：滑动窗口（空间优化）
266+
267+
在方法一中，我们使用了一个数组来存储空闲时间段的长度。实际上，我们不需要存储整个数组，可以用一个函数 $f(i)$ 来表示第 $i$ 个空闲时间段的长度。这样可以节省空间。
268+
269+
时间复杂度 $O(n)$，其中 $n$ 是会议的数量。空间复杂度 $O(1)$。
270+
271+
<!-- tabs:start -->
272+
273+
#### Python3
274+
275+
```python
276+
class Solution:
277+
def maxFreeTime(
278+
self, eventTime: int, k: int, startTime: List[int], endTime: List[int]
279+
) -> int:
280+
def f(i: int) -> int:
281+
if i == 0:
282+
return startTime[0]
283+
if i == len(endTime):
284+
return eventTime - endTime[-1]
285+
return startTime[i] - endTime[i - 1]
286+
287+
ans = s = 0
288+
for i in range(len(endTime) + 1):
289+
s += f(i)
290+
if i >= k:
291+
ans = max(ans, s)
292+
s -= f(i - k)
293+
return ans
294+
```
115295

296+
#### Java
297+
298+
```java
299+
class Solution {
300+
public int maxFreeTime(int eventTime, int k, int[] startTime, int[] endTime) {
301+
int n = endTime.length;
302+
IntUnaryOperator f = i -> {
303+
if (i == 0) {
304+
return startTime[0];
305+
}
306+
if (i == n) {
307+
return eventTime - endTime[n - 1];
308+
}
309+
return startTime[i] - endTime[i - 1];
310+
};
311+
int ans = 0, s = 0;
312+
for (int i = 0; i <= n; i++) {
313+
s += f.applyAsInt(i);
314+
if (i >= k) {
315+
ans = Math.max(ans, s);
316+
s -= f.applyAsInt(i - k);
317+
}
318+
}
319+
return ans;
320+
}
321+
}
322+
```
323+
324+
#### C++
325+
326+
```cpp
327+
class Solution {
328+
public:
329+
int maxFreeTime(int eventTime, int k, vector<int>& startTime, vector<int>& endTime) {
330+
int n = endTime.size();
331+
auto f = [&](int i) -> int {
332+
if (i == 0) {
333+
return startTime[0];
334+
}
335+
if (i == n) {
336+
return eventTime - endTime[n - 1];
337+
}
338+
return startTime[i] - endTime[i - 1];
339+
};
340+
int ans = 0, s = 0;
341+
for (int i = 0; i <= n; ++i) {
342+
s += f(i);
343+
if (i >= k) {
344+
ans = max(ans, s);
345+
s -= f(i - k);
346+
}
347+
}
348+
return ans;
349+
}
350+
};
116351
```
117352
118353
#### Go
119354
120355
```go
356+
func maxFreeTime(eventTime int, k int, startTime []int, endTime []int) int {
357+
n := len(endTime)
358+
f := func(i int) int {
359+
if i == 0 {
360+
return startTime[0]
361+
}
362+
if i == n {
363+
return eventTime - endTime[n-1]
364+
}
365+
return startTime[i] - endTime[i-1]
366+
}
367+
ans, s := 0, 0
368+
for i := 0; i <= n; i++ {
369+
s += f(i)
370+
if i >= k {
371+
ans = max(ans, s)
372+
s -= f(i - k)
373+
}
374+
}
375+
return ans
376+
}
377+
```
378+
379+
#### TypeScript
380+
381+
```ts
382+
function maxFreeTime(eventTime: number, k: number, startTime: number[], endTime: number[]): number {
383+
const n = endTime.length;
384+
const f = (i: number): number => {
385+
if (i === 0) {
386+
return startTime[0];
387+
}
388+
if (i === n) {
389+
return eventTime - endTime[n - 1];
390+
}
391+
return startTime[i] - endTime[i - 1];
392+
};
393+
let ans = 0;
394+
let s = 0;
395+
for (let i = 0; i <= n; i++) {
396+
s += f(i);
397+
if (i >= k) {
398+
ans = Math.max(ans, s);
399+
s -= f(i - k);
400+
}
401+
}
402+
return ans;
403+
}
404+
```
121405

406+
#### Rust
407+
408+
```rust
409+
impl Solution {
410+
pub fn max_free_time(event_time: i32, k: i32, start_time: Vec<i32>, end_time: Vec<i32>) -> i32 {
411+
let n = end_time.len();
412+
let f = |i: usize| -> i32 {
413+
if i == 0 {
414+
start_time[0]
415+
} else if i == n {
416+
event_time - end_time[n - 1]
417+
} else {
418+
start_time[i] - end_time[i - 1]
419+
}
420+
};
421+
let mut ans = 0;
422+
let mut s = 0;
423+
for i in 0..=n {
424+
s += f(i);
425+
if i >= k as usize {
426+
ans = ans.max(s);
427+
s -= f(i - k as usize);
428+
}
429+
}
430+
ans
431+
}
432+
}
122433
```
123434

124435
<!-- tabs:end -->

0 commit comments

Comments
 (0)