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 2ea23e2

Browse files
feat: update solutions to lc problem: No.1921 (doocs#3873)
1 parent 46abcd7 commit 2ea23e2

File tree

7 files changed

+55
-70
lines changed

7 files changed

+55
-70
lines changed

‎solution/1900-1999/1921.Eliminate Maximum Number of Monsters/README.md‎

Lines changed: 16 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -61,7 +61,7 @@ tags:
6161
<strong>输出:</strong>1
6262
<strong>解释:</strong>
6363
第 0 分钟开始时,怪物的距离是 [3,2,4],你消灭了第一个怪物。
64-
第 1 分钟开始时,怪物的距离是 [X,0,2],你输掉了游戏。
64+
第 1 分钟开始时,怪物的距离是 [X,0,2],你输掉了游戏。
6565
你只能消灭 1 个怪物。
6666
</pre>
6767

@@ -83,13 +83,13 @@ tags:
8383

8484
### 方法一:排序 + 贪心
8585

86-
我们用 $times$ 数组记录每个怪物最晚可被消灭的时间。对于第 $i$ 个怪物,最晚可被消灭的时间满足:
86+
我们用 $\textit{times}$ 数组记录每个怪物最晚可被消灭的时间。对于第 $i$ 个怪物,最晚可被消灭的时间满足:
8787

88-
$$times[i] = \lfloor \frac{dist[i]-1}{speed[i]} \rfloor$$
88+
$$\textit{times}[i] = \left\lfloor \frac{\textit{dist}[i]-1}{\textit{speed}[i]} \right\rfloor$$
8989

90-
接下来,我们对 $times$ 数组升序排列。
90+
接下来,我们对 $\textit{times}$ 数组升序排列。
9191

92-
然后遍历 $times$ 数组,对于第 $i$ 个怪物,如果 $times[i] \geq i,ドル说明第 $i$ 个怪物可以被消灭,否则说明第 $i$ 个怪物无法被消灭,直接返回 $i$ 即可。
92+
然后遍历 $\textit{times}$ 数组,对于第 $i$ 个怪物,如果 $\textit{times}[i] \geq i,ドル说明第 $i$ 个怪物可以被消灭,否则说明第 $i$ 个怪物无法被消灭,直接返回 $i$ 即可。
9393

9494
若所有怪物都可以被消灭,则返回 $n$。
9595

@@ -176,7 +176,7 @@ func eliminateMaximum(dist []int, speed []int) int {
176176
```ts
177177
function eliminateMaximum(dist: number[], speed: number[]): number {
178178
const n = dist.length;
179-
const times=new Array(n).fill(0);
179+
const times:number[] = Array(n).fill(0);
180180
for (let i = 0; i < n; ++i) {
181181
times[i] = Math.floor((dist[i] - 1) / speed[i]);
182182
}
@@ -199,17 +199,18 @@ function eliminateMaximum(dist: number[], speed: number[]): number {
199199
* @return {number}
200200
*/
201201
var eliminateMaximum = function (dist, speed) {
202-
let arr = [];
203-
for (let i = 0; i < dist.length; i++) {
204-
arr[i] = dist[i] / speed[i];
202+
const n = dist.length;
203+
const times = Array(n).fill(0);
204+
for (let i = 0; i < n; ++i) {
205+
times[i] = Math.floor((dist[i] - 1) / speed[i]);
205206
}
206-
arr.sort((a, b) => a - b);
207-
let ans = 0;
208-
while (arr[0] > ans) {
209-
arr.shift();
210-
++ans;
207+
times.sort((a, b) => a - b);
208+
for (let i = 0; i < n; ++i) {
209+
if (times[i] < i) {
210+
return i;
211+
}
211212
}
212-
return ans;
213+
return n;
213214
};
214215
```
215216

‎solution/1900-1999/1921.Eliminate Maximum Number of Monsters/README_EN.md‎

Lines changed: 25 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -79,7 +79,19 @@ You can only eliminate 1 monster.
7979

8080
<!-- solution:start -->
8181

82-
### Solution 1
82+
### Solution 1: Sorting + Greedy
83+
84+
We use the $\textit{times}$ array to record the latest time each monster can be eliminated. For the $i$-th monster, the latest time it can be eliminated is:
85+
86+
$$\textit{times}[i] = \left\lfloor \frac{\textit{dist}[i]-1}{\textit{speed}[i]} \right\rfloor$$
87+
88+
Next, we sort the $\textit{times}$ array in ascending order.
89+
90+
Then, we traverse the $\textit{times}$ array. For the $i$-th monster, if $\textit{times}[i] \geq i,ドル it means the $i$-th monster can be eliminated. Otherwise, it means the $i$-th monster cannot be eliminated, and we return $i$ immediately.
91+
92+
If all monsters can be eliminated, we return $n$.
93+
94+
The time complexity is $O(n \times \log n),ドル and the space complexity is $O(n)$. Here, $n$ is the length of the array.
8395

8496
<!-- tabs:start -->
8597

@@ -162,7 +174,7 @@ func eliminateMaximum(dist []int, speed []int) int {
162174
```ts
163175
function eliminateMaximum(dist: number[], speed: number[]): number {
164176
const n = dist.length;
165-
const times=new Array(n).fill(0);
177+
const times:number[] = Array(n).fill(0);
166178
for (let i = 0; i < n; ++i) {
167179
times[i] = Math.floor((dist[i] - 1) / speed[i]);
168180
}
@@ -185,21 +197,22 @@ function eliminateMaximum(dist: number[], speed: number[]): number {
185197
* @return {number}
186198
*/
187199
var eliminateMaximum = function (dist, speed) {
188-
let arr = [];
189-
for (let i = 0; i < dist.length; i++) {
190-
arr[i] = dist[i] / speed[i];
200+
const n = dist.length;
201+
const times = Array(n).fill(0);
202+
for (let i = 0; i < n; ++i) {
203+
times[i] = Math.floor((dist[i] - 1) / speed[i]);
191204
}
192-
arr.sort((a, b) => a - b);
193-
let ans = 0;
194-
while (arr[0] > ans) {
195-
arr.shift();
196-
++ans;
205+
times.sort((a, b) => a - b);
206+
for (let i = 0; i < n; ++i) {
207+
if (times[i] < i) {
208+
return i;
209+
}
197210
}
198-
return ans;
211+
return n;
199212
};
200213
```
201214

202-
#### C#
215+
#### C
203216

204217
```cs
205218
public class Solution {

‎solution/1900-1999/1921.Eliminate Maximum Number of Monsters/Solution.js‎

Lines changed: 10 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -4,15 +4,16 @@
44
* @return {number}
55
*/
66
var eliminateMaximum = function (dist, speed) {
7-
let arr = [];
8-
for (let i = 0; i < dist.length; i++) {
9-
arr[i] = dist[i] / speed[i];
7+
const n = dist.length;
8+
const times = Array(n).fill(0);
9+
for (let i = 0; i < n; ++i) {
10+
times[i] = Math.floor((dist[i] - 1) / speed[i]);
1011
}
11-
arr.sort((a, b) => a - b);
12-
let ans = 0;
13-
while(arr[0]>ans) {
14-
arr.shift();
15-
++ans;
12+
times.sort((a, b) => a - b);
13+
for(let i = 0;i<n;++i){
14+
if(times[i]<i) {
15+
returni;
16+
}
1617
}
17-
return ans;
18+
return n;
1819
};

‎solution/1900-1999/1921.Eliminate Maximum Number of Monsters/Solution.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
function eliminateMaximum(dist: number[], speed: number[]): number {
22
const n = dist.length;
3-
const times=new Array(n).fill(0);
3+
const times: number[]= Array(n).fill(0);
44
for (let i = 0; i < n; ++i) {
55
times[i] = Math.floor((dist[i] - 1) / speed[i]);
66
}

‎solution/1900-1999/1922.Count Good Numbers/README.md‎

Lines changed: 1 addition & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -77,17 +77,7 @@ tags:
7777
class Solution:
7878
def countGoodNumbers(self, n: int) -> int:
7979
mod = 10**9 + 7
80-
81-
def myPow(x, n):
82-
res = 1
83-
while n:
84-
if (n & 1) == 1:
85-
res = res * x % mod
86-
x = x * x % mod
87-
n >>= 1
88-
return res
89-
90-
return myPow(5, (n + 1) >> 1) * myPow(4, n >> 1) % mod
80+
return pow(5, (n + 1) >> 1, mod) * pow(4, n >> 1, mod) % mod
9181
```
9282

9383
#### Java

‎solution/1900-1999/1922.Count Good Numbers/README_EN.md‎

Lines changed: 1 addition & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -75,17 +75,7 @@ tags:
7575
class Solution:
7676
def countGoodNumbers(self, n: int) -> int:
7777
mod = 10**9 + 7
78-
79-
def myPow(x, n):
80-
res = 1
81-
while n:
82-
if (n & 1) == 1:
83-
res = res * x % mod
84-
x = x * x % mod
85-
n >>= 1
86-
return res
87-
88-
return myPow(5, (n + 1) >> 1) * myPow(4, n >> 1) % mod
78+
return pow(5, (n + 1) >> 1, mod) * pow(4, n >> 1, mod) % mod
8979
```
9080

9181
#### Java
Lines changed: 1 addition & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,4 @@
11
class Solution:
22
def countGoodNumbers(self, n: int) -> int:
33
mod = 10**9 + 7
4-
5-
def myPow(x, n):
6-
res = 1
7-
while n:
8-
if (n & 1) == 1:
9-
res = res * x % mod
10-
x = x * x % mod
11-
n >>= 1
12-
return res
13-
14-
return myPow(5, (n + 1) >> 1) * myPow(4, n >> 1) % mod
4+
return pow(5, (n + 1) >> 1, mod) * pow(4, n >> 1, mod) % mod

0 commit comments

Comments
(0)

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