feat: add solutions to lc problem: No.2403

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

@@ -1,28 +1,25 @@
-using ll = long long;
-
 class Solution {
 public:
-    vector<ll> f;
-    vector<int> power;
-    int n;
-
     long long minimumTime(vector<int>& power) {
-        n = power.size();
-        f.assign(1 << n, -1);
-        this->power = power;
-        return dfs(0);
+        int n = power.size();
+        long long f[1 << n];
+        memset(f, -1, sizeof(f));
+        auto dfs = [&](auto&& dfs, int mask) -> long long {
+            if (mask == 0) {
+                return 0;
+            }
+            if (f[mask] != -1) {
+                return f[mask];
+            }
+            f[mask] = LLONG_MAX;
+            int gain = 1 + (n - __builtin_popcount(mask));
+            for (int i = 0; i < n; ++i) {
+                if (mask >> i & 1) {
+                    f[mask] = min(f[mask], dfs(dfs, mask ^ (1 << i)) + (power[i] + gain - 1) / gain);
+                }
+            }
+            return f[mask];
+        };
+        return dfs(dfs, (1 << n) - 1);
     }
-
-    ll dfs(int mask) {
-        if (f[mask] != -1) return f[mask];
-        int cnt = __builtin_popcount(mask);
-        if (cnt == n) return 0;
-        ll ans = LONG_MAX;
-        for (int i = 0; i < n; ++i) {
-            if ((mask >> i) & 1) continue;
-            ans = min(ans, dfs(mask | 1 << i) + (power[i] + cnt) / (cnt + 1));
-        }
-        f[mask] = ans;
-        return ans;
-    }
-};
+};

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

@@ -6,22 +6,20 @@ func minimumTime(power []int) int64 {
 	}
 	var dfs func(mask int) int64
 	dfs = func(mask int) int64 {
+		if mask == 0 {
+			return 0
+		}
 		if f[mask] != -1 {
 			return f[mask]
 		}
-		cnt := bits.OnesCount(uint(mask))
-		if cnt == n {
-			return 0
-		}
-		var ans int64 = math.MaxInt64
-		for i, v := range power {
-			if (mask >> i & 1) == 1 {
-				continue
+		f[mask] = 1e18
+		gain := 1 + (n - bits.OnesCount(uint(mask)))
+		for i, x := range power {
+			if mask>>i&1 == 1 {
+				f[mask] = min(f[mask], dfs(mask^(1<<i))+int64(x+gain-1)/int64(gain))
 			}
-			ans = min(ans, dfs(mask|1<<i)+int64((v+cnt)/(cnt+1)))
 		}
-		f[mask] = ans
-		return ans
+		return f[mask]
 	}
-	return dfs(0)
-}
+	return dfs(1<<n - 1)
+}

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

@@ -1,32 +1,29 @@
 class Solution {
     private int n;
-    private long[] f;
     private int[] power;
+    private Long[] f;
 
     public long minimumTime(int[] power) {
         n = power.length;
-        f = new long[1 << n];
-        Arrays.fill(f, -1);
         this.power = power;
-        return dfs(0);
+        f = new Long[1 << n];
+        return dfs((1 << n) - 1);
     }
 
     private long dfs(int mask) {
-        if (f[mask] != -1) {
-            return f[mask];
-        }
-        int cnt = Integer.bitCount(mask);
-        if (cnt == n) {
+        if (mask == 0) {
             return 0;
         }
-        long ans = Long.MAX_VALUE;
+        if (f[mask] != null) {
+            return f[mask];
+        }
+        f[mask] = Long.MAX_VALUE;
+        int gain = 1 + (n - Integer.bitCount(mask));
         for (int i = 0; i < n; ++i) {
-            if (((mask >> i) & 1) == 1) {
-                continue;
+            if ((mask >> i & 1) == 1) {
+                f[mask] = Math.min(f[mask], dfs(mask ^ 1 << i) + (power[i] + gain - 1) / gain);
             }
-            ans = Math.min(ans, dfs(mask | 1 << i) + (power[i] + cnt) / (cnt + 1));
         }
-        f[mask] = ans;
-        return ans;
+        return f[mask];
     }
-}
+}

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

@@ -1,15 +1,15 @@
 class Solution:
     def minimumTime(self, power: List[int]) -> int:
         @cache
-        def dfs(mask):
-            cnt = mask.bit_count()
-            if cnt == len(power):
+        def dfs(mask: int) -> int:
+            if mask == 0:
                 return 0
             ans = inf
-            for i, v in enumerate(power):
-                if mask & (1 << i):
-                    continue
-                ans = min(ans, dfs(mask | 1 << i) + (v + cnt) // (cnt + 1))
+            gain = 1 + (n - mask.bit_count())
+            for i, x in enumerate(power):
+                if mask >> i & 1:
+                    ans = min(ans, dfs(mask ^ (1 << i)) + (x + gain - 1) // gain)
             return ans
 
-        return dfs(0)
+        n = len(power)
+        return dfs((1 << n) - 1)

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

@@ -1,33 +1,30 @@
 function minimumTime(power: number[]): number {
     const n = power.length;
-    const f = new Array(1 << n).fill(-1);
-    function dfs(mask) {
-        if (f[mask] != -1) {
-            return f[mask];
-        }
-        const cnt = bitCount(mask);
-        if (cnt == n) {
+    const f: number[] = Array(1 << n).fill(-1);
+    const dfs = (mask: number): number => {
+        if (mask === 0) {
             return 0;
         }
-        let ans = Infinity;
+        if (f[mask] !== -1) {
+            return f[mask];
+        }
+        f[mask] = Infinity;
+        const gain = 1 + (n - bitCount(mask));
         for (let i = 0; i < n; ++i) {
             if ((mask >> i) & 1) {
-                continue;
+                f[mask] = Math.min(f[mask], dfs(mask ^ (1 << i)) + Math.ceil(power[i] / gain));
             }
-            ans = Math.min(ans, dfs(mask | (1 << i)) + Math.ceil(power[i] / (cnt + 1)));
         }
-        f[mask] = ans;
-        return ans;
-    }
-    return dfs(0);
+        return f[mask];
+    };
+    return dfs((1 << n) - 1);
 }
 
-function bitCount(x) {
-    let cnt = 0;
-    for (let i = 0; i < 32; ++i) {
-        if ((x >> i) & 1) {
-            ++cnt;
-        }
-    }
-    return cnt;
+function bitCount(i: number): number {
+    i = i - ((i >>> 1) & 0x55555555);
+    i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
+    i = (i + (i >>> 4)) & 0x0f0f0f0f;
+    i = i + (i >>> 8);
+    i = i + (i >>> 16);
+    return i & 0x3f;
 }

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

@@ -2,16 +2,17 @@ class Solution {
 public:
     long long minimumTime(vector<int>& power) {
         int n = power.size();
-        vector<long long> dp(1 << n, LONG_MAX);
-        dp[0] = 0;
+        long long f[1 << n];
+        memset(f, 0x3f, sizeof(f));
+        f[0] = 0;
         for (int mask = 1; mask < 1 << n; ++mask) {
-            int cnt = __builtin_popcount(mask);
+            int gain = __builtin_popcount(mask);
             for (int i = 0; i < n; ++i) {
-                if ((mask >> i) & 1) {
-                    dp[mask] = min(dp[mask], dp[mask ^ (1 << i)] + (power[i] + cnt - 1) / cnt);
+                if (mask >> i & 1) {
+                    f[mask] = min(f[mask], f[mask ^ (1 << i)] + (power[i] + gain - 1) / gain);
                 }
             }
         }
-        return dp[(1 << n) - 1];
+        return f[(1 << n) - 1];
     }
-};
+};

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

@@ -1,17 +1,17 @@
 func minimumTime(power []int) int64 {
 	n := len(power)
-	dp := make([]int64, 1<<n)
-	for i := range dp {
-		dp[i] = math.MaxInt64
+	f := make([]int64, 1<<n)
+	for i := range f {
+		f[i] = 1e18
 	}
-	dp[0] = 0
+	f[0] = 0
 	for mask := 1; mask < 1<<n; mask++ {
-		cnt := bits.OnesCount(uint(mask))
-		for i, v := range power {
-			if ((mask >> i) & 1) == 1 {
-				dp[mask] = min(dp[mask], dp[mask^(1<<i)]+int64((v+cnt-1)/cnt))
+		gain := bits.OnesCount(uint(mask))
+		for i, x := range power {
+			if mask>>i&1 == 1 {
+				f[mask] = min(f[mask], f[mask^(1<<i)]+int64(x+gain-1)/int64(gain))
 			}
 		}
 	}
-	return dp[len(dp)-1]
-}
+	return f[1<<n-1]
+}

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

@@ -1,17 +1,17 @@
 class Solution {
     public long minimumTime(int[] power) {
         int n = power.length;
-        long[] dp = new long[1 << n];
-        Arrays.fill(dp, Long.MAX_VALUE);
-        dp[0] = 0;
+        long[] f = new long[1 << n];
+        Arrays.fill(f, Long.MAX_VALUE);
+        f[0] = 0;
         for (int mask = 1; mask < 1 << n; ++mask) {
-            int cnt = Integer.bitCount(mask);
+            int gain = Integer.bitCount(mask);
             for (int i = 0; i < n; ++i) {
-                if (((mask >> i) & 1) == 1) {
-                    dp[mask] = Math.min(dp[mask], dp[mask ^ (1 << i)] + (power[i] + cnt - 1) / cnt);
+                if ((mask >> i & 1) == 1) {
+                    f[mask] = Math.min(f[mask], f[mask ^ 1 << i] + (power[i] + gain - 1) / gain);
                 }
             }
         }
-        return dp[(1 << n) - 1];
+        return f[(1 << n) - 1];
     }
-}
+}

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

@@ -1,11 +1,11 @@
 class Solution:
     def minimumTime(self, power: List[int]) -> int:
         n = len(power)
-        dp = [inf] * (1 << n)
-        dp[0] = 0
+        f = [inf] * (1 << n)
+        f[0] = 0
         for mask in range(1, 1 << n):
-            cnt = mask.bit_count()
-            for i, v in enumerate(power):
-                if (mask >> i) & 1:
-                    dp[mask] = min(dp[mask], dp[mask ^ (1 << i)] + (v + cnt - 1) // cnt)
-        return dp[-1]
+            gain = mask.bit_count()
+            for i, x in enumerate(power):
+                if mask >> i & 1:
+                    f[mask] = min(f[mask], f[mask ^ (1 << i)] + (x + gain - 1) // gain)
+        return f[-1]

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

@@ -1,24 +1,23 @@
 function minimumTime(power: number[]): number {
     const n = power.length;
-    const dp = new Array(1 << n).fill(Infinity);
-    dp[0] = 0;
+    const f: number[] = Array(1 << n).fill(Infinity);
+    f[0] = 0;
     for (let mask = 1; mask < 1 << n; ++mask) {
-        const cnt = bitCount(mask);
+        const gain = bitCount(mask);
         for (let i = 0; i < n; ++i) {
             if ((mask >> i) & 1) {
-                dp[mask] = Math.min(dp[mask], dp[mask ^ (1 << i)] + Math.ceil(power[i] / cnt));
+                f[mask] = Math.min(f[mask], f[mask ^ (1 << i)] + Math.ceil(power[i] / gain));
             }
         }
     }
-    return dp[dp.length - 1];
+    return f.at(-1)!;
 }
 
-function bitCount(x) {
-    let cnt = 0;
-    for (let i = 0; i < 32; ++i) {
-        if ((x >> i) & 1) {
-            ++cnt;
-        }
-    }
-    return cnt;
+function bitCount(i: number): number {
+    i = i - ((i >>> 1) & 0x55555555);
+    i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
+    i = (i + (i >>> 4)) & 0x0f0f0f0f;
+    i = i + (i >>> 8);
+    i = i + (i >>> 16);
+    return i & 0x3f;
 }