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 f46ff73

Browse files
feat: add solutions to lc problem: No.2403 (doocs#3521)
No.2403.Minimum Time to Kill All Monsters
1 parent f5a275d commit f46ff73

File tree

12 files changed

+381
-384
lines changed

12 files changed

+381
-384
lines changed

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

Lines changed: 131 additions & 127 deletions
Large diffs are not rendered by default.

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

Lines changed: 133 additions & 129 deletions
Large diffs are not rendered by default.
Lines changed: 21 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -1,28 +1,25 @@
1-
using ll = long long;
2-
31
class Solution {
42
public:
5-
vector<ll> f;
6-
vector<int> power;
7-
int n;
8-
93
long long minimumTime(vector<int>& power) {
10-
n = power.size();
11-
f.assign(1 << n, -1);
12-
this->power = power;
13-
return dfs(0);
4+
int n = power.size();
5+
long long f[1 << n];
6+
memset(f, -1, sizeof(f));
7+
auto dfs = [&](auto&& dfs, int mask) -> long long {
8+
if (mask == 0) {
9+
return 0;
10+
}
11+
if (f[mask] != -1) {
12+
return f[mask];
13+
}
14+
f[mask] = LLONG_MAX;
15+
int gain = 1 + (n - __builtin_popcount(mask));
16+
for (int i = 0; i < n; ++i) {
17+
if (mask >> i & 1) {
18+
f[mask] = min(f[mask], dfs(dfs, mask ^ (1 << i)) + (power[i] + gain - 1) / gain);
19+
}
20+
}
21+
return f[mask];
22+
};
23+
return dfs(dfs, (1 << n) - 1);
1424
}
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-
};
25+
};

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

Lines changed: 11 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -6,22 +6,20 @@ func minimumTime(power []int) int64 {
66
}
77
var dfs func(mask int) int64
88
dfs = func(mask int) int64 {
9+
if mask == 0 {
10+
return 0
11+
}
912
if f[mask] != -1 {
1013
return f[mask]
1114
}
12-
cnt := bits.OnesCount(uint(mask))
13-
if cnt == n {
14-
return 0
15-
}
16-
var ans int64 = math.MaxInt64
17-
for i, v := range power {
18-
if (mask >> i & 1) == 1 {
19-
continue
15+
f[mask] = 1e18
16+
gain := 1 + (n - bits.OnesCount(uint(mask)))
17+
for i, x := range power {
18+
if mask>>i&1 == 1 {
19+
f[mask] = min(f[mask], dfs(mask^(1<<i))+int64(x+gain-1)/int64(gain))
2020
}
21-
ans = min(ans, dfs(mask|1<<i)+int64((v+cnt)/(cnt+1)))
2221
}
23-
f[mask] = ans
24-
return ans
22+
return f[mask]
2523
}
26-
return dfs(0)
27-
}
24+
return dfs(1<<n-1)
25+
}
Lines changed: 13 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,32 +1,29 @@
11
class Solution {
22
private int n;
3-
private long[] f;
43
private int[] power;
4+
private Long[] f;
55

66
public long minimumTime(int[] power) {
77
n = power.length;
8-
f = new long[1 << n];
9-
Arrays.fill(f, -1);
108
this.power = power;
11-
return dfs(0);
9+
f = new Long[1 << n];
10+
return dfs((1 << n) - 1);
1211
}
1312

1413
private long dfs(int mask) {
15-
if (f[mask] != -1) {
16-
return f[mask];
17-
}
18-
int cnt = Integer.bitCount(mask);
19-
if (cnt == n) {
14+
if (mask == 0) {
2015
return 0;
2116
}
22-
long ans = Long.MAX_VALUE;
17+
if (f[mask] != null) {
18+
return f[mask];
19+
}
20+
f[mask] = Long.MAX_VALUE;
21+
int gain = 1 + (n - Integer.bitCount(mask));
2322
for (int i = 0; i < n; ++i) {
24-
if (((mask >> i) & 1) == 1) {
25-
continue;
23+
if ((mask >> i & 1) == 1) {
24+
f[mask] = Math.min(f[mask], dfs(mask ^ 1 << i) + (power[i] + gain - 1) / gain);
2625
}
27-
ans = Math.min(ans, dfs(mask | 1 << i) + (power[i] + cnt) / (cnt + 1));
2826
}
29-
f[mask] = ans;
30-
return ans;
27+
return f[mask];
3128
}
32-
}
29+
}
Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,15 @@
11
class Solution:
22
def minimumTime(self, power: List[int]) -> int:
33
@cache
4-
def dfs(mask):
5-
cnt = mask.bit_count()
6-
if cnt == len(power):
4+
def dfs(mask: int) -> int:
5+
if mask == 0:
76
return 0
87
ans = inf
9-
fori, vinenumerate(power):
10-
ifmask& (1<<i):
11-
continue
12-
ans = min(ans, dfs(mask |1 << i) + (v + cnt) // (cnt+1))
8+
gain=1+ (n-mask.bit_count())
9+
fori, xinenumerate(power):
10+
ifmask>>i&1:
11+
ans = min(ans, dfs(mask ^ (1 << i)) + (x + gain-1) // gain)
1312
return ans
1413

15-
return dfs(0)
14+
n = len(power)
15+
return dfs((1 << n) - 1)
Lines changed: 19 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -1,33 +1,30 @@
11
function minimumTime(power: number[]): number {
22
const n = power.length;
3-
const f = new Array(1 << n).fill(-1);
4-
function dfs(mask) {
5-
if (f[mask] != -1) {
6-
return f[mask];
7-
}
8-
const cnt = bitCount(mask);
9-
if (cnt == n) {
3+
const f: number[] = Array(1 << n).fill(-1);
4+
const dfs = (mask: number): number => {
5+
if (mask === 0) {
106
return 0;
117
}
12-
let ans = Infinity;
8+
if (f[mask] !== -1) {
9+
return f[mask];
10+
}
11+
f[mask] = Infinity;
12+
const gain = 1 + (n - bitCount(mask));
1313
for (let i = 0; i < n; ++i) {
1414
if ((mask >> i) & 1) {
15-
continue;
15+
f[mask]=Math.min(f[mask],dfs(mask^(1<<i))+Math.ceil(power[i]/gain));
1616
}
17-
ans = Math.min(ans, dfs(mask | (1 << i)) + Math.ceil(power[i] / (cnt + 1)));
1817
}
19-
f[mask] = ans;
20-
return ans;
21-
}
22-
return dfs(0);
18+
return f[mask];
19+
};
20+
return dfs((1 << n) - 1);
2321
}
2422

25-
function bitCount(x) {
26-
let cnt = 0;
27-
for (let i = 0; i < 32; ++i) {
28-
if ((x >> i) & 1) {
29-
++cnt;
30-
}
31-
}
32-
return cnt;
23+
function bitCount(i: number): number {
24+
i = i - ((i >>> 1) & 0x55555555);
25+
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
26+
i = (i + (i >>> 4)) & 0x0f0f0f0f;
27+
i = i + (i >>> 8);
28+
i = i + (i >>> 16);
29+
return i & 0x3f;
3330
}

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

Lines changed: 8 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -2,16 +2,17 @@ class Solution {
22
public:
33
long long minimumTime(vector<int>& power) {
44
int n = power.size();
5-
vector<long long> dp(1 << n, LONG_MAX);
6-
dp[0] = 0;
5+
long long f[1 << n];
6+
memset(f, 0x3f, sizeof(f));
7+
f[0] = 0;
78
for (int mask = 1; mask < 1 << n; ++mask) {
8-
int cnt = __builtin_popcount(mask);
9+
int gain = __builtin_popcount(mask);
910
for (int i = 0; i < n; ++i) {
10-
if ((mask >> i) & 1) {
11-
dp[mask] = min(dp[mask], dp[mask ^ (1 << i)] + (power[i] + cnt - 1) / cnt);
11+
if (mask >> i & 1) {
12+
f[mask] = min(f[mask], f[mask ^ (1 << i)] + (power[i] + gain - 1) / gain);
1213
}
1314
}
1415
}
15-
return dp[(1 << n) - 1];
16+
return f[(1 << n) - 1];
1617
}
17-
};
18+
};
Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,17 @@
11
func minimumTime(power []int) int64 {
22
n := len(power)
3-
dp := make([]int64, 1<<n)
4-
for i := range dp {
5-
dp[i] = math.MaxInt64
3+
f := make([]int64, 1<<n)
4+
for i := range f {
5+
f[i] = 1e18
66
}
7-
dp[0] = 0
7+
f[0] = 0
88
for mask := 1; mask < 1<<n; mask++ {
9-
cnt := bits.OnesCount(uint(mask))
10-
for i, v := range power {
11-
if ((mask>>i) &1) == 1 {
12-
dp[mask] = min(dp[mask], dp[mask^(1<<i)]+int64((v+cnt-1)/cnt))
9+
gain := bits.OnesCount(uint(mask))
10+
for i, x := range power {
11+
if mask>>i&1 == 1 {
12+
f[mask] = min(f[mask], f[mask^(1<<i)]+int64(x+gain-1)/int64(gain))
1313
}
1414
}
1515
}
16-
return dp[len(dp)-1]
17-
}
16+
return f[1<<n-1]
17+
}
Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,17 @@
11
class Solution {
22
public long minimumTime(int[] power) {
33
int n = power.length;
4-
long[] dp = new long[1 << n];
5-
Arrays.fill(dp, Long.MAX_VALUE);
6-
dp[0] = 0;
4+
long[] f = new long[1 << n];
5+
Arrays.fill(f, Long.MAX_VALUE);
6+
f[0] = 0;
77
for (int mask = 1; mask < 1 << n; ++mask) {
8-
int cnt = Integer.bitCount(mask);
8+
int gain = Integer.bitCount(mask);
99
for (int i = 0; i < n; ++i) {
10-
if (((mask >> i) & 1) == 1) {
11-
dp[mask] = Math.min(dp[mask], dp[mask ^ (1 << i)] + (power[i] + cnt - 1) / cnt);
10+
if ((mask >> i & 1) == 1) {
11+
f[mask] = Math.min(f[mask], f[mask ^ 1 << i] + (power[i] + gain - 1) / gain);
1212
}
1313
}
1414
}
15-
return dp[(1 << n) - 1];
15+
return f[(1 << n) - 1];
1616
}
17-
}
17+
}

0 commit comments

Comments
(0)

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