Skip to content

Commit ca918eb

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.2403
No.2403.Minimum Time to Kill All Monsters
1 parent 2eba9aa commit ca918eb

File tree

3 files changed

+225
-2
lines changed

3 files changed

+225
-2
lines changed

‎solution/2300-2399/2386.Find the K-Sum of an Array/README.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -61,7 +61,7 @@
6161

6262
由于数组是从小到大排序，可以证明，这种方式能够不重不漏地按序遍历完所有的子序列和。
6363

64-
时间复杂度 $O(nlogn+klogk)$。其中 $n$ 是数组 $nums$ 的长度。
64+
时间复杂度 $O(nlogn+klogk)$。其中 $n$ 是数组 `nums` 的长度。
6565

6666
<!-- tabs:start -->
6767

‎solution/2400-2499/2403.Minimum Time to Kill All Monsters/README.md

Lines changed: 113 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -73,7 +73,7 @@ It can be proven that 6 is the minimum number of days needed.
7373

7474
<!-- 这里可写通用的实现逻辑 -->
7575

76-
**方法一：状态压缩 + 动态规划**
76+
**方法一：状态压缩 + 记忆化搜索/动态规划**
7777

7878
由于打怪才能增加每天法力的收益 `gain`，不同的打怪顺序对结果有影响，需要枚举。注意到题目的数据范围较小，考虑使用状态压缩动态规划求解。
7979

@@ -105,6 +105,20 @@ class Solution:
105105
return dfs(0)
106106
```
107107

108+
```python
109+
class Solution:
110+
def minimumTime(self, power: List[int]) -> int:
111+
n = len(power)
112+
dp = [inf] * (1 << n)
113+
dp[0] = 0
114+
for mask in range(1, 1 << n):
115+
cnt = mask.bit_count()
116+
for i, v in enumerate(power):
117+
if (mask >> i) & 1:
118+
dp[mask] = min(dp[mask], dp[mask ^ (1 << i)] + (v + cnt - 1) // cnt)
119+
return dp[-1]
120+
```
121+
108122
### **Java**
109123

110124
<!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -144,6 +158,26 @@ class Solution {
144158
}
145159
```
146160

161+
```java
162+
class Solution {
163+
public long minimumTime(int[] power) {
164+
int n = power.length;
165+
long[] dp = new long[1 << n];
166+
Arrays.fill(dp, Long.MAX_VALUE);
167+
dp[0] = 0;
168+
for (int mask = 1; mask < 1 << n; ++mask) {
169+
int cnt = Integer.bitCount(mask);
170+
for (int i = 0; i < n; ++i) {
171+
if (((mask >> i) & 1) == 1) {
172+
dp[mask] = Math.min(dp[mask], dp[mask ^ (1 << i)] + (power[i] + cnt - 1) / cnt);
173+
}
174+
}
175+
}
176+
return dp[(1 << n) - 1];
177+
}
178+
}
179+
```
180+
147181
### **C++**
148182

149183
```cpp
@@ -177,6 +211,26 @@ public:
177211
};
178212
```
179213
214+
```cpp
215+
class Solution {
216+
public:
217+
long long minimumTime(vector<int>& power) {
218+
int n = power.size();
219+
vector<long long> dp(1 << n, LONG_MAX);
220+
dp[0] = 0;
221+
for (int mask = 1; mask < 1 << n; ++mask) {
222+
int cnt = __builtin_popcount(mask);
223+
for (int i = 0; i < n; ++i) {
224+
if ((mask >> i) & 1) {
225+
dp[mask] = min(dp[mask], dp[mask ^ (1 << i)] + (power[i] + cnt - 1) / cnt);
226+
}
227+
}
228+
}
229+
return dp[(1 << n) - 1];
230+
}
231+
};
232+
```
233+
180234
### **Go**
181235

182236
```go
@@ -216,6 +270,34 @@ func min(a, b int64) int64 {
216270
}
217271
```
218272

273+
```go
274+
func minimumTime(power []int) int64 {
275+
n := len(power)
276+
dp := make([]int64, 1<<n)
277+
for i := range dp {
278+
dp[i] = math.MaxInt64
279+
}
280+
dp[0] = 0
281+
for mask := 1; mask < 1<<n; mask++ {
282+
cnt := bits.OnesCount(uint(mask))
283+
for i, v := range power {
284+
if ((mask >> i) & 1) == 1 {
285+
dp[mask] = min(dp[mask], dp[mask^(1<<i)]+int64((v+cnt-1)/cnt))
286+
}
287+
}
288+
}
289+
return dp[len(dp)-1]
290+
}
291+
292+
func min(a, b int64) int64 {
293+
if a < b {
294+
return a
295+
}
296+
return b
297+
}
298+
```
299+
300+
219301
### **TypeScript**
220302

221303
```ts
@@ -257,6 +339,36 @@ function bitCount(x) {
257339
}
258340
```
259341

342+
```ts
343+
function minimumTime(power: number[]): number {
344+
const n = power.length;
345+
const dp = new Array(1 << n).fill(Infinity);
346+
dp[0] = 0;
347+
for (let mask = 1; mask < 1 << n; ++mask) {
348+
const cnt = bitCount(mask);
349+
for (let i = 0; i < n; ++i) {
350+
if ((mask >> i) & 1) {
351+
dp[mask] = Math.min(
352+
dp[mask],
353+
dp[mask ^ (1 << i)] + Math.ceil(power[i] / cnt),
354+
);
355+
}
356+
}
357+
}
358+
return dp[dp.length - 1];
359+
}
360+
361+
function bitCount(x) {
362+
let cnt = 0;
363+
for (let i = 0; i < 32; ++i) {
364+
if ((x >> i) & 1) {
365+
++cnt;
366+
}
367+
}
368+
return cnt;
369+
}
370+
```
371+
260372
### **...**
261373

262374
```

‎solution/2400-2499/2403.Minimum Time to Kill All Monsters/README_EN.md

Lines changed: 111 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -91,6 +91,20 @@ class Solution:
9191
return dfs(0)
9292
```
9393

94+
```python
95+
class Solution:
96+
def minimumTime(self, power: List[int]) -> int:
97+
n = len(power)
98+
dp = [inf] * (1 << n)
99+
dp[0] = 0
100+
for mask in range(1, 1 << n):
101+
cnt = mask.bit_count()
102+
for i, v in enumerate(power):
103+
if (mask >> i) & 1:
104+
dp[mask] = min(dp[mask], dp[mask ^ (1 << i)] + (v + cnt - 1) // cnt)
105+
return dp[-1]
106+
```
107+
94108
### **Java**
95109

96110
```java
@@ -128,6 +142,26 @@ class Solution {
128142
}
129143
```
130144

145+
```java
146+
class Solution {
147+
public long minimumTime(int[] power) {
148+
int n = power.length;
149+
long[] dp = new long[1 << n];
150+
Arrays.fill(dp, Long.MAX_VALUE);
151+
dp[0] = 0;
152+
for (int mask = 1; mask < 1 << n; ++mask) {
153+
int cnt = Integer.bitCount(mask);
154+
for (int i = 0; i < n; ++i) {
155+
if (((mask >> i) & 1) == 1) {
156+
dp[mask] = Math.min(dp[mask], dp[mask ^ (1 << i)] + (power[i] + cnt - 1) / cnt);
157+
}
158+
}
159+
}
160+
return dp[(1 << n) - 1];
161+
}
162+
}
163+
```
164+
131165
### **C++**
132166

133167
```cpp
@@ -161,6 +195,26 @@ public:
161195
};
162196
```
163197
198+
```cpp
199+
class Solution {
200+
public:
201+
long long minimumTime(vector<int>& power) {
202+
int n = power.size();
203+
vector<long long> dp(1 << n, LONG_MAX);
204+
dp[0] = 0;
205+
for (int mask = 1; mask < 1 << n; ++mask) {
206+
int cnt = __builtin_popcount(mask);
207+
for (int i = 0; i < n; ++i) {
208+
if ((mask >> i) & 1) {
209+
dp[mask] = min(dp[mask], dp[mask ^ (1 << i)] + (power[i] + cnt - 1) / cnt);
210+
}
211+
}
212+
}
213+
return dp[(1 << n) - 1];
214+
}
215+
};
216+
```
217+
164218
### **Go**
165219

166220
```go
@@ -200,6 +254,33 @@ func min(a, b int64) int64 {
200254
}
201255
```
202256

257+
```go
258+
func minimumTime(power []int) int64 {
259+
n := len(power)
260+
dp := make([]int64, 1<<n)
261+
for i := range dp {
262+
dp[i] = math.MaxInt64
263+
}
264+
dp[0] = 0
265+
for mask := 1; mask < 1<<n; mask++ {
266+
cnt := bits.OnesCount(uint(mask))
267+
for i, v := range power {
268+
if ((mask >> i) & 1) == 1 {
269+
dp[mask] = min(dp[mask], dp[mask^(1<<i)]+int64((v+cnt-1)/cnt))
270+
}
271+
}
272+
}
273+
return dp[len(dp)-1]
274+
}
275+
276+
func min(a, b int64) int64 {
277+
if a < b {
278+
return a
279+
}
280+
return b
281+
}
282+
```
283+
203284
### **TypeScript**
204285

205286
```ts
@@ -241,6 +322,36 @@ function bitCount(x) {
241322
}
242323
```
243324

325+
```ts
326+
function minimumTime(power: number[]): number {
327+
const n = power.length;
328+
const dp = new Array(1 << n).fill(Infinity);
329+
dp[0] = 0;
330+
for (let mask = 1; mask < 1 << n; ++mask) {
331+
const cnt = bitCount(mask);
332+
for (let i = 0; i < n; ++i) {
333+
if ((mask >> i) & 1) {
334+
dp[mask] = Math.min(
335+
dp[mask],
336+
dp[mask ^ (1 << i)] + Math.ceil(power[i] / cnt),
337+
);
338+
}
339+
}
340+
}
341+
return dp[dp.length - 1];
342+
}
343+
344+
function bitCount(x) {
345+
let cnt = 0;
346+
for (let i = 0; i < 32; ++i) {
347+
if ((x >> i) & 1) {
348+
++cnt;
349+
}
350+
}
351+
return cnt;
352+
}
353+
```
354+
244355
### **...**
245356

246357
```

0 commit comments

Comments
 (0)