Skip to content

Commit d97602b

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.2054
No.2054.Two Best Non-Overlapping Events
1 parent cc028a7 commit d97602b

File tree

6 files changed

+325
-2
lines changed

6 files changed

+325
-2
lines changed

‎solution/2000-2099/2054.Two Best Non-Overlapping Events/README.md

Lines changed: 114 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -55,22 +55,135 @@
5555

5656
<!-- 这里可写通用的实现逻辑 -->
5757

58+
**方法一：排序 + 二分查找**
59+
60+
时间复杂度 $O(nlogn)$，其中 $n$ 表示 $events$ 的长度。
61+
5862
<!-- tabs:start -->
5963

6064
### **Python3**
6165

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

6468
```python
65-
69+
class Solution:
70+
def maxTwoEvents(self, events: List[List[int]]) -> int:
71+
events.sort()
72+
n = len(events)
73+
f = [events[-1][2]] * n
74+
for i in range(n - 2, -1, -1):
75+
f[i] = max(f[i + 1], events[i][2])
76+
ans = 0
77+
for _, e, v in events:
78+
idx = bisect_right(events, e, key=lambda x: x[0])
79+
if idx < n:
80+
v += f[idx]
81+
ans = max(ans, v)
82+
return ans
6683
```
6784

6885
### **Java**
6986

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

7289
```java
90+
class Solution {
91+
public int maxTwoEvents(int[][] events) {
92+
Arrays.sort(events, (a, b) -> a[0] - b[0]);
93+
int n = events.length;
94+
int[] f = new int [n + 1];
95+
for (int i = n - 1; i >= 0; --i) {
96+
f[i] = Math.max(f[i + 1], events[i][2]);
97+
}
98+
int ans = 0;
99+
for (int[] e : events) {
100+
int v = e[2];
101+
int left = 0, right = n;
102+
while (left < right) {
103+
int mid = (left + right) >> 1;
104+
if (events[mid][0] > e[1]) {
105+
right = mid;
106+
} else {
107+
left = mid + 1;
108+
}
109+
}
110+
if (left < n) {
111+
v += f[left];
112+
}
113+
ans = Math.max(ans, v);
114+
}
115+
return ans;
116+
}
117+
}
118+
```
119+
120+
### **C++**
121+
122+
```cpp
123+
class Solution {
124+
public:
125+
int maxTwoEvents(vector<vector<int>>& events) {
126+
sort(events.begin(), events.end());
127+
int n = events.size();
128+
vector<int> f(n + 1);
129+
for (int i = n - 1; ~i; --i) f[i] = max(f[i + 1], events[i][2]);
130+
int ans = 0;
131+
for (auto& e : events)
132+
{
133+
int v = e[2];
134+
int left = 0, right = n;
135+
while (left < right)
136+
{
137+
int mid = (left + right) >> 1;
138+
if (events[mid][0] > e[1]) right = mid;
139+
else left = mid + 1;
140+
}
141+
if (left < n) v += f[left];
142+
ans = max(ans, v);
143+
}
144+
return ans;
145+
}
146+
};
147+
```
73148
149+
### **Go**
150+
151+
```go
152+
func maxTwoEvents(events [][]int) int {
153+
sort.Slice(events, func(i, j int) bool {
154+
return events[i][0] < events[j][0]
155+
})
156+
n := len(events)
157+
f := make([]int, n+1)
158+
for i := n - 1; i >= 0; i-- {
159+
f[i] = max(f[i+1], events[i][2])
160+
}
161+
ans := 0
162+
for _, e := range events {
163+
v := e[2]
164+
left, right := 0, n
165+
for left < right {
166+
mid := (left + right) >> 1
167+
if events[mid][0] > e[1] {
168+
right = mid
169+
} else {
170+
left = mid + 1
171+
}
172+
}
173+
if left < n {
174+
v += f[left]
175+
}
176+
ans = max(ans, v)
177+
}
178+
return ans
179+
}
180+
181+
func max(a, b int) int {
182+
if a > b {
183+
return a
184+
}
185+
return b
186+
}
74187
```
75188

76189
### **...**

‎solution/2000-2099/2054.Two Best Non-Overlapping Events/README_EN.md

Lines changed: 110 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -51,13 +51,122 @@
5151
### **Python3**
5252

5353
```python
54-
54+
class Solution:
55+
def maxTwoEvents(self, events: List[List[int]]) -> int:
56+
events.sort()
57+
n = len(events)
58+
f = [events[-1][2]] * n
59+
for i in range(n - 2, -1, -1):
60+
f[i] = max(f[i + 1], events[i][2])
61+
ans = 0
62+
for _, e, v in events:
63+
idx = bisect_right(events, e, key=lambda x: x[0])
64+
if idx < n:
65+
v += f[idx]
66+
ans = max(ans, v)
67+
return ans
5568
```
5669

5770
### **Java**
5871

5972
```java
73+
class Solution {
74+
public int maxTwoEvents(int[][] events) {
75+
Arrays.sort(events, (a, b) -> a[0] - b[0]);
76+
int n = events.length;
77+
int[] f = new int [n + 1];
78+
for (int i = n - 1; i >= 0; --i) {
79+
f[i] = Math.max(f[i + 1], events[i][2]);
80+
}
81+
int ans = 0;
82+
for (int[] e : events) {
83+
int v = e[2];
84+
int left = 0, right = n;
85+
while (left < right) {
86+
int mid = (left + right) >> 1;
87+
if (events[mid][0] > e[1]) {
88+
right = mid;
89+
} else {
90+
left = mid + 1;
91+
}
92+
}
93+
if (left < n) {
94+
v += f[left];
95+
}
96+
ans = Math.max(ans, v);
97+
}
98+
return ans;
99+
}
100+
}
101+
```
102+
103+
### **C++**
104+
105+
```cpp
106+
class Solution {
107+
public:
108+
int maxTwoEvents(vector<vector<int>>& events) {
109+
sort(events.begin(), events.end());
110+
int n = events.size();
111+
vector<int> f(n + 1);
112+
for (int i = n - 1; ~i; --i) f[i] = max(f[i + 1], events[i][2]);
113+
int ans = 0;
114+
for (auto& e : events)
115+
{
116+
int v = e[2];
117+
int left = 0, right = n;
118+
while (left < right)
119+
{
120+
int mid = (left + right) >> 1;
121+
if (events[mid][0] > e[1]) right = mid;
122+
else left = mid + 1;
123+
}
124+
if (left < n) v += f[left];
125+
ans = max(ans, v);
126+
}
127+
return ans;
128+
}
129+
};
130+
```
60131
132+
### **Go**
133+
134+
```go
135+
func maxTwoEvents(events [][]int) int {
136+
sort.Slice(events, func(i, j int) bool {
137+
return events[i][0] < events[j][0]
138+
})
139+
n := len(events)
140+
f := make([]int, n+1)
141+
for i := n - 1; i >= 0; i-- {
142+
f[i] = max(f[i+1], events[i][2])
143+
}
144+
ans := 0
145+
for _, e := range events {
146+
v := e[2]
147+
left, right := 0, n
148+
for left < right {
149+
mid := (left + right) >> 1
150+
if events[mid][0] > e[1] {
151+
right = mid
152+
} else {
153+
left = mid + 1
154+
}
155+
}
156+
if left < n {
157+
v += f[left]
158+
}
159+
ans = max(ans, v)
160+
}
161+
return ans
162+
}
163+
164+
func max(a, b int) int {
165+
if a > b {
166+
return a
167+
}
168+
return b
169+
}
61170
```
62171

63172
### **...**

‎solution/2000-2099/2054.Two Best Non-Overlapping Events/Solution.cpp

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
class Solution {
2+
public:
3+
int maxTwoEvents(vector<vector<int>>& events) {
4+
sort(events.begin(), events.end());
5+
int n = events.size();
6+
vector<int> f(n + 1);
7+
for (int i = n - 1; ~i; --i) f[i] = max(f[i + 1], events[i][2]);
8+
int ans = 0;
9+
for (auto& e : events)
10+
{
11+
int v = e[2];
12+
int left = 0, right = n;
13+
while (left < right)
14+
{
15+
int mid = (left + right) >> 1;
16+
if (events[mid][0] > e[1]) right = mid;
17+
else left = mid + 1;
18+
}
19+
if (left < n) v += f[left];
20+
ans = max(ans, v);
21+
}
22+
return ans;
23+
}
24+
};

‎solution/2000-2099/2054.Two Best Non-Overlapping Events/Solution.go

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
func maxTwoEvents(events [][]int) int {
2+
sort.Slice(events, func(i, j int) bool {
3+
return events[i][0] < events[j][0]
4+
})
5+
n := len(events)
6+
f := make([]int, n+1)
7+
for i := n - 1; i >= 0; i-- {
8+
f[i] = max(f[i+1], events[i][2])
9+
}
10+
ans := 0
11+
for _, e := range events {
12+
v := e[2]
13+
left, right := 0, n
14+
for left < right {
15+
mid := (left + right) >> 1
16+
if events[mid][0] > e[1] {
17+
right = mid
18+
} else {
19+
left = mid + 1
20+
}
21+
}
22+
if left < n {
23+
v += f[left]
24+
}
25+
ans = max(ans, v)
26+
}
27+
return ans
28+
}
29+
30+
func max(a, b int) int {
31+
if a > b {
32+
return a
33+
}
34+
return b
35+
}

‎solution/2000-2099/2054.Two Best Non-Overlapping Events/Solution.java

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
class Solution {
2+
public int maxTwoEvents(int[][] events) {
3+
Arrays.sort(events, (a, b) -> a[0] - b[0]);
4+
int n = events.length;
5+
int[] f = new int [n + 1];
6+
for (int i = n - 1; i >= 0; --i) {
7+
f[i] = Math.max(f[i + 1], events[i][2]);
8+
}
9+
int ans = 0;
10+
for (int[] e : events) {
11+
int v = e[2];
12+
int left = 0, right = n;
13+
while (left < right) {
14+
int mid = (left + right) >> 1;
15+
if (events[mid][0] > e[1]) {
16+
right = mid;
17+
} else {
18+
left = mid + 1;
19+
}
20+
}
21+
if (left < n) {
22+
v += f[left];
23+
}
24+
ans = Math.max(ans, v);
25+
}
26+
return ans;
27+
}
28+
}

‎solution/2000-2099/2054.Two Best Non-Overlapping Events/Solution.py

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
class Solution:
2+
def maxTwoEvents(self, events: List[List[int]]) -> int:
3+
events.sort()
4+
n = len(events)
5+
f = [events[-1][2]] * n
6+
for i in range(n - 2, -1, -1):
7+
f[i] = max(f[i + 1], events[i][2])
8+
ans = 0
9+
for _, e, v in events:
10+
idx = bisect_right(events, e, key=lambda x: x[0])
11+
if idx < n:
12+
v += f[idx]
13+
ans = max(ans, v)
14+
return ans

0 commit comments

Comments
 (0)