Skip to content

Commit 3a78b47

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.2141 (doocs#1375)
No.2141.Maximum Running Time of N Computers
1 parent b00d73a commit 3a78b47

File tree

7 files changed

+361
-42
lines changed

7 files changed

+361
-42
lines changed

‎solution/2100-2199/2141.Maximum Running Time of N Computers/README.md

+138-24
Original file line numberDiff line numberDiff line change
@@ -56,8 +56,146 @@
5656

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

59+
**方法一：二分查找**
60+
61+
我们注意到，如果我们可以让 $n$ 台电脑同时运行 $t$ 分钟，那么我们也可以让 $n$ 台电脑同时运行 $t' \le t$ 分钟，这存在着单调性。因此，我们可以使用二分查找的方法找到最大的 $t$。
62+
63+
我们定义二分查找的左边界 $l=0$，右边界 $r=\sum_{i=0}^{n-1} batteries[i]$。每次二分查找的过程中，我们使用一个变量 $mid$ 表示当前的中间值，即 $mid = (l + r + 1) >> 1$。我们判断是否存在一种方案，使得 $n$ 台电脑同时运行 $mid$ 分钟。如果存在，那么我们就将 $l$ 更新为 $mid$，否则我们将 $r$ 更新为 $mid - 1$。最后，我们返回 $l$ 即为答案。
64+
65+
问题转化为如何判断是否存在一种方案，使得 $n$ 台电脑同时运行 $mid$ 分钟。如果一个电池可以运行的分钟数大于 $mid$，由于电脑同时运行 $mid$ 分钟，而一个电池同一时间只能供电一台电脑，因此我们只能使用这个电池 $mid$ 分钟。如果一个电池可以运行的分钟数小于等于 $mid$，我们可以使用这个电池的全部电量。因此，我们统计所有电池可以供电的分钟数之和 $s$，如果 $s \ge n \times mid$，那么我们就可以使得 $n$ 台电脑同时运行 $mid$ 分钟。
66+
67+
时间复杂度 $O(n \times \log M)$，其中 $M$ 为所有电池的电量之和，空间复杂度 $O(1)$。
68+
5969
<!-- tabs:start -->
6070

71+
### **Python3**
72+
73+
<!-- 这里可写当前语言的特殊实现逻辑 -->
74+
75+
```python
76+
class Solution:
77+
def maxRunTime(self, n: int, batteries: List[int]) -> int:
78+
l, r = 0, sum(batteries)
79+
while l < r:
80+
mid = (l + r + 1) >> 1
81+
if sum(min(x, mid) for x in batteries) >= n * mid:
82+
l = mid
83+
else:
84+
r = mid - 1
85+
return l
86+
```
87+
88+
### **Java**
89+
90+
<!-- 这里可写当前语言的特殊实现逻辑 -->
91+
92+
```java
93+
class Solution {
94+
public long maxRunTime(int n, int[] batteries) {
95+
long l = 0, r = 0;
96+
for (int x : batteries) {
97+
r += x;
98+
}
99+
while (l < r) {
100+
long mid = (l + r + 1) >> 1;
101+
long s = 0;
102+
for (int x : batteries) {
103+
s += Math.min(mid, x);
104+
}
105+
if (s >= n * mid) {
106+
l = mid;
107+
} else {
108+
r = mid - 1;
109+
}
110+
}
111+
return l;
112+
}
113+
}
114+
```
115+
116+
### **C++**
117+
118+
```cpp
119+
class Solution {
120+
public:
121+
long long maxRunTime(int n, vector<int>& batteries) {
122+
long long l = 0, r = 0;
123+
for (int x : batteries) {
124+
r += x;
125+
}
126+
while (l < r) {
127+
long long mid = (l + r + 1) >> 1;
128+
long long s = 0;
129+
for (int x : batteries) {
130+
s += min(1LL * x, mid);
131+
}
132+
if (s >= n * mid) {
133+
l = mid;
134+
} else {
135+
r = mid - 1;
136+
}
137+
}
138+
return l;
139+
}
140+
};
141+
```
142+
143+
### **Go**
144+
145+
```go
146+
func maxRunTime(n int, batteries []int) int64 {
147+
l, r := 0, 0
148+
for _, x := range batteries {
149+
r += x
150+
}
151+
for l < r {
152+
mid := (l + r + 1) >> 1
153+
s := 0
154+
for _, x := range batteries {
155+
s += min(x, mid)
156+
}
157+
if s >= n*mid {
158+
l = mid
159+
} else {
160+
r = mid - 1
161+
}
162+
}
163+
return int64(l)
164+
}
165+
166+
func min(a, b int) int {
167+
if a < b {
168+
return a
169+
}
170+
return b
171+
}
172+
```
173+
174+
### **TypeScript**
175+
176+
```ts
177+
function maxRunTime(n: number, batteries: number[]): number {
178+
let l = 0n;
179+
let r = 0n;
180+
for (const x of batteries) {
181+
r += BigInt(x);
182+
}
183+
while (l < r) {
184+
const mid = (l + r + 1n) >> 1n;
185+
let s = 0n;
186+
for (const x of batteries) {
187+
s += BigInt(Math.min(x, Number(mid)));
188+
}
189+
if (s >= mid * BigInt(n)) {
190+
l = mid;
191+
} else {
192+
r = mid - 1n;
193+
}
194+
}
195+
return Number(l);
196+
}
197+
```
198+
61199
### **Rust**
62200

63201
```rust
@@ -111,30 +249,6 @@ impl Solution {
111249
}
112250
```
113251

114-
### **Python3**
115-
116-
<!-- 这里可写当前语言的特殊实现逻辑 -->
117-
118-
```python
119-
120-
```
121-
122-
### **Java**
123-
124-
<!-- 这里可写当前语言的特殊实现逻辑 -->
125-
126-
```java
127-
128-
```
129-
130-
### **TypeScript**
131-
132-
<!-- 这里可写当前语言的特殊实现逻辑 -->
133-
134-
```ts
135-
136-
```
137-
138252
### **...**
139253

140254
```

‎solution/2100-2199/2141.Maximum Running Time of N Computers/README_EN.md

+124-18
Original file line numberDiff line numberDiff line change
@@ -51,6 +51,130 @@ We can run the two computers simultaneously for at most 2 minutes, so we return
5151

5252
<!-- tabs:start -->
5353

54+
### **Python3**
55+
56+
```python
57+
class Solution:
58+
def maxRunTime(self, n: int, batteries: List[int]) -> int:
59+
l, r = 0, sum(batteries)
60+
while l < r:
61+
mid = (l + r + 1) >> 1
62+
if sum(min(x, mid) for x in batteries) >= n * mid:
63+
l = mid
64+
else:
65+
r = mid - 1
66+
return l
67+
```
68+
69+
### **Java**
70+
71+
```java
72+
class Solution {
73+
public long maxRunTime(int n, int[] batteries) {
74+
long l = 0, r = 0;
75+
for (int x : batteries) {
76+
r += x;
77+
}
78+
while (l < r) {
79+
long mid = (l + r + 1) >> 1;
80+
long s = 0;
81+
for (int x : batteries) {
82+
s += Math.min(mid, x);
83+
}
84+
if (s >= n * mid) {
85+
l = mid;
86+
} else {
87+
r = mid - 1;
88+
}
89+
}
90+
return l;
91+
}
92+
}
93+
```
94+
95+
### **C++**
96+
97+
```cpp
98+
class Solution {
99+
public:
100+
long long maxRunTime(int n, vector<int>& batteries) {
101+
long long l = 0, r = 0;
102+
for (int x : batteries) {
103+
r += x;
104+
}
105+
while (l < r) {
106+
long long mid = (l + r + 1) >> 1;
107+
long long s = 0;
108+
for (int x : batteries) {
109+
s += min(1LL * x, mid);
110+
}
111+
if (s >= n * mid) {
112+
l = mid;
113+
} else {
114+
r = mid - 1;
115+
}
116+
}
117+
return l;
118+
}
119+
};
120+
```
121+
122+
### **Go**
123+
124+
```go
125+
func maxRunTime(n int, batteries []int) int64 {
126+
l, r := 0, 0
127+
for _, x := range batteries {
128+
r += x
129+
}
130+
for l < r {
131+
mid := (l + r + 1) >> 1
132+
s := 0
133+
for _, x := range batteries {
134+
s += min(x, mid)
135+
}
136+
if s >= n*mid {
137+
l = mid
138+
} else {
139+
r = mid - 1
140+
}
141+
}
142+
return int64(l)
143+
}
144+
145+
func min(a, b int) int {
146+
if a < b {
147+
return a
148+
}
149+
return b
150+
}
151+
```
152+
153+
### **TypeScript**
154+
155+
```ts
156+
function maxRunTime(n: number, batteries: number[]): number {
157+
let l = 0n;
158+
let r = 0n;
159+
for (const x of batteries) {
160+
r += BigInt(x);
161+
}
162+
while (l < r) {
163+
const mid = (l + r + 1n) >> 1n;
164+
let s = 0n;
165+
for (const x of batteries) {
166+
s += BigInt(Math.min(x, Number(mid)));
167+
}
168+
if (s >= mid * BigInt(n)) {
169+
l = mid;
170+
} else {
171+
r = mid - 1n;
172+
}
173+
}
174+
return Number(l);
175+
}
176+
```
177+
54178
### **Rust**
55179

56180
```rust
@@ -104,24 +228,6 @@ impl Solution {
104228
}
105229
```
106230

107-
### **Python3**
108-
109-
```python
110-
111-
```
112-
113-
### **Java**
114-
115-
```java
116-
117-
```
118-
119-
### **TypeScript**
120-
121-
```ts
122-
123-
```
124-
125231
### **...**
126232

127233
```

‎solution/2100-2199/2141.Maximum Running Time of N Computers/Solution.cpp

+22
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
class Solution {
2+
public:
3+
long long maxRunTime(int n, vector<int>& batteries) {
4+
long long l = 0, r = 0;
5+
for (int x : batteries) {
6+
r += x;
7+
}
8+
while (l < r) {
9+
long long mid = (l + r + 1) >> 1;
10+
long long s = 0;
11+
for (int x : batteries) {
12+
s += min(1LL * x, mid);
13+
}
14+
if (s >= n * mid) {
15+
l = mid;
16+
} else {
17+
r = mid - 1;
18+
}
19+
}
20+
return l;
21+
}
22+
};

‎solution/2100-2199/2141.Maximum Running Time of N Computers/Solution.go

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
func maxRunTime(n int, batteries []int) int64 {
2+
l, r := 0, 0
3+
for _, x := range batteries {
4+
r += x
5+
}
6+
for l < r {
7+
mid := (l + r + 1) >> 1
8+
s := 0
9+
for _, x := range batteries {
10+
s += min(x, mid)
11+
}
12+
if s >= n*mid {
13+
l = mid
14+
} else {
15+
r = mid - 1
16+
}
17+
}
18+
return int64(l)
19+
}
20+
21+
func min(a, b int) int {
22+
if a < b {
23+
return a
24+
}
25+
return b
26+
}

0 commit comments

Comments
 (0)