Skip to content

Commit 2eba9aa

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

File tree

7 files changed

+461
-4
lines changed

7 files changed

+461
-4
lines changed

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

Lines changed: 162 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -73,28 +73,188 @@ It can be proven that 6 is the minimum number of days needed.
7373

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

76+
**方法一：状态压缩 + 动态规划**
77+
78+
由于打怪才能增加每天法力的收益 `gain`，不同的打怪顺序对结果有影响，需要枚举。注意到题目的数据范围较小，考虑使用状态压缩动态规划求解。
79+
80+
我们定义状态 `mask` 表示当前已经打怪的情况，其二进制中的 `1` 表示已经被打倒的怪物，`0` 表示未被打倒的怪物。
81+
82+
时间复杂度 $O(n\times 2^n)$，空间复杂度 $O(2^n)$。其中 $n$ 是怪物数量。
83+
7684
<!-- tabs:start -->
7785

7886
### **Python3**
7987

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

8290
```python
83-
91+
class Solution:
92+
def minimumTime(self, power: List[int]) -> int:
93+
@cache
94+
def dfs(mask):
95+
cnt = mask.bit_count()
96+
if cnt == len(power):
97+
return 0
98+
ans = inf
99+
for i, v in enumerate(power):
100+
if mask & (1 << i):
101+
continue
102+
ans = min(ans, dfs(mask | 1 << i) + (v + cnt) // (cnt + 1))
103+
return ans
104+
105+
return dfs(0)
84106
```
85107

86108
### **Java**
87109

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

90112
```java
113+
class Solution {
114+
private int n;
115+
private long[] f;
116+
private int[] power;
117+
118+
public long minimumTime(int[] power) {
119+
n = power.length;
120+
f = new long[1 << n];
121+
Arrays.fill(f, -1);
122+
this.power = power;
123+
return dfs(0);
124+
}
125+
126+
private long dfs(int mask) {
127+
if (f[mask] != -1) {
128+
return f[mask];
129+
}
130+
int cnt = Integer.bitCount(mask);
131+
if (cnt == n) {
132+
return 0;
133+
}
134+
long ans = Long.MAX_VALUE;
135+
for (int i = 0; i < n; ++i) {
136+
if (((mask >> i) & 1) == 1) {
137+
continue;
138+
}
139+
ans = Math.min(ans, dfs(mask | 1 << i) + (power[i] + cnt) / (cnt + 1));
140+
}
141+
f[mask] = ans;
142+
return ans;
143+
}
144+
}
145+
```
146+
147+
### **C++**
148+
149+
```cpp
150+
using ll = long long;
151+
152+
class Solution {
153+
public:
154+
vector<ll> f;
155+
vector<int> power;
156+
int n;
157+
158+
long long minimumTime(vector<int>& power) {
159+
n = power.size();
160+
f.assign(1 << n, -1);
161+
this->power = power;
162+
return dfs(0);
163+
}
164+
165+
ll dfs(int mask) {
166+
if (f[mask] != -1) return f[mask];
167+
int cnt = __builtin_popcount(mask);
168+
if (cnt == n) return 0;
169+
ll ans = LONG_MAX;
170+
for (int i = 0; i < n; ++i) {
171+
if ((mask >> i) & 1) continue;
172+
ans = min(ans, dfs(mask | 1 << i) + (power[i] + cnt) / (cnt + 1));
173+
}
174+
f[mask] = ans;
175+
return ans;
176+
}
177+
};
178+
```
91179
180+
### **Go**
181+
182+
```go
183+
func minimumTime(power []int) int64 {
184+
n := len(power)
185+
f := make([]int64, 1<<n)
186+
for i := range f {
187+
f[i] = -1
188+
}
189+
var dfs func(mask int) int64
190+
dfs = func(mask int) int64 {
191+
if f[mask] != -1 {
192+
return f[mask]
193+
}
194+
cnt := bits.OnesCount(uint(mask))
195+
if cnt == n {
196+
return 0
197+
}
198+
var ans int64 = math.MaxInt64
199+
for i, v := range power {
200+
if (mask >> i & 1) == 1 {
201+
continue
202+
}
203+
ans = min(ans, dfs(mask|1<<i)+int64((v+cnt)/(cnt+1)))
204+
}
205+
f[mask] = ans
206+
return ans
207+
}
208+
return dfs(0)
209+
}
210+
211+
func min(a, b int64) int64 {
212+
if a < b {
213+
return a
214+
}
215+
return b
216+
}
92217
```
93218

94219
### **TypeScript**
95220

96221
```ts
97-
222+
function minimumTime(power: number[]): number {
223+
const n = power.length;
224+
const f = new Array(1 << n).fill(-1);
225+
function dfs(mask) {
226+
if (f[mask] != -1) {
227+
return f[mask];
228+
}
229+
const cnt = bitCount(mask);
230+
if (cnt == n) {
231+
return 0;
232+
}
233+
let ans = Infinity;
234+
for (let i = 0; i < n; ++i) {
235+
if ((mask >> i) & 1) {
236+
continue;
237+
}
238+
ans = Math.min(
239+
ans,
240+
dfs(mask | (1 << i)) + Math.ceil(power[i] / (cnt + 1)),
241+
);
242+
}
243+
f[mask] = ans;
244+
return ans;
245+
}
246+
return dfs(0);
247+
}
248+
249+
function bitCount(x) {
250+
let cnt = 0;
251+
for (let i = 0; i < 32; ++i) {
252+
if ((x >> i) & 1) {
253+
++cnt;
254+
}
255+
}
256+
return cnt;
257+
}
98258
```
99259

100260
### **...**

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

Lines changed: 154 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -74,19 +74,171 @@ It can be proven that 6 is the minimum number of days needed.
7474
### **Python3**
7575

7676
```python
77-
77+
class Solution:
78+
def minimumTime(self, power: List[int]) -> int:
79+
@cache
80+
def dfs(mask):
81+
cnt = mask.bit_count()
82+
if cnt == len(power):
83+
return 0
84+
ans = inf
85+
for i, v in enumerate(power):
86+
if mask & (1 << i):
87+
continue
88+
ans = min(ans, dfs(mask | 1 << i) + (v + cnt) // (cnt + 1))
89+
return ans
90+
91+
return dfs(0)
7892
```
7993

8094
### **Java**
8195

8296
```java
97+
class Solution {
98+
private int n;
99+
private long[] f;
100+
private int[] power;
101+
102+
public long minimumTime(int[] power) {
103+
n = power.length;
104+
f = new long[1 << n];
105+
Arrays.fill(f, -1);
106+
this.power = power;
107+
return dfs(0);
108+
}
109+
110+
private long dfs(int mask) {
111+
if (f[mask] != -1) {
112+
return f[mask];
113+
}
114+
int cnt = Integer.bitCount(mask);
115+
if (cnt == n) {
116+
return 0;
117+
}
118+
long ans = Long.MAX_VALUE;
119+
for (int i = 0; i < n; ++i) {
120+
if (((mask >> i) & 1) == 1) {
121+
continue;
122+
}
123+
ans = Math.min(ans, dfs(mask | 1 << i) + (power[i] + cnt) / (cnt + 1));
124+
}
125+
f[mask] = ans;
126+
return ans;
127+
}
128+
}
129+
```
83130

131+
### **C++**
132+
133+
```cpp
134+
using ll = long long;
135+
136+
class Solution {
137+
public:
138+
vector<ll> f;
139+
vector<int> power;
140+
int n;
141+
142+
long long minimumTime(vector<int>& power) {
143+
n = power.size();
144+
f.assign(1 << n, -1);
145+
this->power = power;
146+
return dfs(0);
147+
}
148+
149+
ll dfs(int mask) {
150+
if (f[mask] != -1) return f[mask];
151+
int cnt = __builtin_popcount(mask);
152+
if (cnt == n) return 0;
153+
ll ans = LONG_MAX;
154+
for (int i = 0; i < n; ++i) {
155+
if ((mask >> i) & 1) continue;
156+
ans = min(ans, dfs(mask | 1 << i) + (power[i] + cnt) / (cnt + 1));
157+
}
158+
f[mask] = ans;
159+
return ans;
160+
}
161+
};
162+
```
163+
164+
### **Go**
165+
166+
```go
167+
func minimumTime(power []int) int64 {
168+
n := len(power)
169+
f := make([]int64, 1<<n)
170+
for i := range f {
171+
f[i] = -1
172+
}
173+
var dfs func(mask int) int64
174+
dfs = func(mask int) int64 {
175+
if f[mask] != -1 {
176+
return f[mask]
177+
}
178+
cnt := bits.OnesCount(uint(mask))
179+
if cnt == n {
180+
return 0
181+
}
182+
var ans int64 = math.MaxInt64
183+
for i, v := range power {
184+
if (mask >> i & 1) == 1 {
185+
continue
186+
}
187+
ans = min(ans, dfs(mask|1<<i)+int64((v+cnt)/(cnt+1)))
188+
}
189+
f[mask] = ans
190+
return ans
191+
}
192+
return dfs(0)
193+
}
194+
195+
func min(a, b int64) int64 {
196+
if a < b {
197+
return a
198+
}
199+
return b
200+
}
84201
```
85202

86203
### **TypeScript**
87204

88205
```ts
89-
206+
function minimumTime(power: number[]): number {
207+
const n = power.length;
208+
const f = new Array(1 << n).fill(-1);
209+
function dfs(mask) {
210+
if (f[mask] != -1) {
211+
return f[mask];
212+
}
213+
const cnt = bitCount(mask);
214+
if (cnt == n) {
215+
return 0;
216+
}
217+
let ans = Infinity;
218+
for (let i = 0; i < n; ++i) {
219+
if ((mask >> i) & 1) {
220+
continue;
221+
}
222+
ans = Math.min(
223+
ans,
224+
dfs(mask | (1 << i)) + Math.ceil(power[i] / (cnt + 1)),
225+
);
226+
}
227+
f[mask] = ans;
228+
return ans;
229+
}
230+
return dfs(0);
231+
}
232+
233+
function bitCount(x) {
234+
let cnt = 0;
235+
for (let i = 0; i < 32; ++i) {
236+
if ((x >> i) & 1) {
237+
++cnt;
238+
}
239+
}
240+
return cnt;
241+
}
90242
```
91243

92244
### **...**

‎solution/2400-2499/2403.Minimum Time to Kill All Monsters/Solution.cpp

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
using ll = long long;
2+
3+
class Solution {
4+
public:
5+
vector<ll> f;
6+
vector<int> power;
7+
int n;
8+
9+
long long minimumTime(vector<int>& power) {
10+
n = power.size();
11+
f.assign(1 << n, -1);
12+
this->power = power;
13+
return dfs(0);
14+
}
15+
16+
ll dfs(int mask) {
17+
if (f[mask] != -1) return f[mask];
18+
int cnt = __builtin_popcount(mask);
19+
if (cnt == n) return 0;
20+
ll ans = LONG_MAX;
21+
for (int i = 0; i < n; ++i) {
22+
if ((mask >> i) & 1) continue;
23+
ans = min(ans, dfs(mask | 1 << i) + (power[i] + cnt) / (cnt + 1));
24+
}
25+
f[mask] = ans;
26+
return ans;
27+
}
28+
};

0 commit comments

Comments
 (0)