From 43858d3e805b55e34449bcdd3c3c6b14ee85a01f Mon Sep 17 00:00:00 2001 From: yanglbme Date: Thu, 12 Dec 2024 08:37:45 +0800 Subject: [PATCH] feat: add solutions to lc problem: No.3376 No.3376.Minimum Time to Break Locks I --- .../README.md | 136 +++++++++++++++++- .../README_EN.md | 136 +++++++++++++++++- .../Solution.cpp | 27 ++++ .../Solution.go | 25 ++++ .../Solution.java | 32 +++++ .../Solution.py | 15 ++ .../Solution.ts | 30 ++++ 7 files changed, 395 insertions(+), 6 deletions(-) create mode 100644 solution/3300-3399/3376.Minimum Time to Break Locks I/Solution.cpp create mode 100644 solution/3300-3399/3376.Minimum Time to Break Locks I/Solution.go create mode 100644 solution/3300-3399/3376.Minimum Time to Break Locks I/Solution.java create mode 100644 solution/3300-3399/3376.Minimum Time to Break Locks I/Solution.py create mode 100644 solution/3300-3399/3376.Minimum Time to Break Locks I/Solution.ts diff --git a/solution/3300-3399/3376.Minimum Time to Break Locks I/README.md b/solution/3300-3399/3376.Minimum Time to Break Locks I/README.md index 01b8b2a873838..34becf51d59a1 100644 --- a/solution/3300-3399/3376.Minimum Time to Break Locks I/README.md +++ b/solution/3300-3399/3376.Minimum Time to Break Locks I/README.md @@ -187,25 +187,155 @@ tags: #### Python3 ```python - +class Solution: + def findMinimumTime(self, strength: List[int], K: int) -> int: + @cache + def dfs(i: int) -> int: + if i == (1 << len(strength)) - 1: + return 0 + cnt = i.bit_count() + x = 1 + cnt * K + ans = inf + for j, s in enumerate(strength): + if i >> j & 1 ^ 1: + ans = min(ans, dfs(i | 1 << j) + (s + x - 1) // x) + return ans + + return dfs(0) ``` #### Java ```java - +class Solution { + private List strength; + private Integer[] f; + private int k; + private int n; + + public int findMinimumTime(List strength, int K) { + n = strength.size(); + f = new Integer[1 << n]; + k = K; + this.strength = strength; + return dfs(0); + } + + private int dfs(int i) { + if (i == (1 << n) - 1) { + return 0; + } + if (f[i] != null) { + return f[i]; + } + int cnt = Integer.bitCount(i); + int x = 1 + cnt * k; + f[i] = 1 << 30; + for (int j = 0; j < n; ++j) { + if ((i >> j & 1) == 0) { + f[i] = Math.min(f[i], dfs(i | 1 << j) + (strength.get(j) + x - 1) / x); + } + } + return f[i]; + } +} ``` #### C++ ```cpp - +class Solution { +public: + int findMinimumTime(vector& strength, int K) { + int n = strength.size(); + int f[1 << n]; + memset(f, -1, sizeof(f)); + int k = K; + auto dfs = [&](auto&& dfs, int i) -> int { + if (i == (1 << n) - 1) { + return 0; + } + if (f[i] != -1) { + return f[i]; + } + int cnt = __builtin_popcount(i); + int x = 1 + k * cnt; + f[i] = INT_MAX; + for (int j = 0; j < n; ++j) { + if (i >> j & 1 ^ 1) { + f[i] = min(f[i], dfs(dfs, i | 1 << j) + (strength[j] + x - 1) / x); + } + } + return f[i]; + }; + return dfs(dfs, 0); + } +}; ``` #### Go ```go +func findMinimumTime(strength []int, K int) int { + n := len(strength) + f := make([]int, 1<>j&1 == 0 { + f[i] = min(f[i], dfs(i|1< { + if (i === (1 << n) - 1) { + return 0; + } + if (f[i] !== -1) { + return f[i]; + } + f[i] = Infinity; + const x = 1 + K * bitCount(i); + for (let j = 0; j < n; ++j) { + if (((i >> j) & 1) == 0) { + f[i] = Math.min(f[i], dfs(i | (1 << j)) + Math.ceil(strength[j] / x)); + } + } + return f[i]; + }; + return dfs(0); +} + +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; +} ``` diff --git a/solution/3300-3399/3376.Minimum Time to Break Locks I/README_EN.md b/solution/3300-3399/3376.Minimum Time to Break Locks I/README_EN.md index 40b0897fafd8c..6f00900f768a0 100644 --- a/solution/3300-3399/3376.Minimum Time to Break Locks I/README_EN.md +++ b/solution/3300-3399/3376.Minimum Time to Break Locks I/README_EN.md @@ -185,25 +185,155 @@ tags: #### Python3 ```python - +class Solution: + def findMinimumTime(self, strength: List[int], K: int) -> int: + @cache + def dfs(i: int) -> int: + if i == (1 << len(strength)) - 1: + return 0 + cnt = i.bit_count() + x = 1 + cnt * K + ans = inf + for j, s in enumerate(strength): + if i >> j & 1 ^ 1: + ans = min(ans, dfs(i | 1 << j) + (s + x - 1) // x) + return ans + + return dfs(0) ``` #### Java ```java - +class Solution { + private List strength; + private Integer[] f; + private int k; + private int n; + + public int findMinimumTime(List strength, int K) { + n = strength.size(); + f = new Integer[1 << n]; + k = K; + this.strength = strength; + return dfs(0); + } + + private int dfs(int i) { + if (i == (1 << n) - 1) { + return 0; + } + if (f[i] != null) { + return f[i]; + } + int cnt = Integer.bitCount(i); + int x = 1 + cnt * k; + f[i] = 1 << 30; + for (int j = 0; j < n; ++j) { + if ((i >> j & 1) == 0) { + f[i] = Math.min(f[i], dfs(i | 1 << j) + (strength.get(j) + x - 1) / x); + } + } + return f[i]; + } +} ``` #### C++ ```cpp - +class Solution { +public: + int findMinimumTime(vector& strength, int K) { + int n = strength.size(); + int f[1 << n]; + memset(f, -1, sizeof(f)); + int k = K; + auto dfs = [&](auto&& dfs, int i) -> int { + if (i == (1 << n) - 1) { + return 0; + } + if (f[i] != -1) { + return f[i]; + } + int cnt = __builtin_popcount(i); + int x = 1 + k * cnt; + f[i] = INT_MAX; + for (int j = 0; j < n; ++j) { + if (i >> j & 1 ^ 1) { + f[i] = min(f[i], dfs(dfs, i | 1 << j) + (strength[j] + x - 1) / x); + } + } + return f[i]; + }; + return dfs(dfs, 0); + } +}; ``` #### Go ```go +func findMinimumTime(strength []int, K int) int { + n := len(strength) + f := make([]int, 1<>j&1 == 0 { + f[i] = min(f[i], dfs(i|1< { + if (i === (1 << n) - 1) { + return 0; + } + if (f[i] !== -1) { + return f[i]; + } + f[i] = Infinity; + const x = 1 + K * bitCount(i); + for (let j = 0; j < n; ++j) { + if (((i >> j) & 1) == 0) { + f[i] = Math.min(f[i], dfs(i | (1 << j)) + Math.ceil(strength[j] / x)); + } + } + return f[i]; + }; + return dfs(0); +} + +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; +} ``` diff --git a/solution/3300-3399/3376.Minimum Time to Break Locks I/Solution.cpp b/solution/3300-3399/3376.Minimum Time to Break Locks I/Solution.cpp new file mode 100644 index 0000000000000..94db045d7aac4 --- /dev/null +++ b/solution/3300-3399/3376.Minimum Time to Break Locks I/Solution.cpp @@ -0,0 +1,27 @@ +class Solution { +public: + int findMinimumTime(vector& strength, int K) { + int n = strength.size(); + int f[1 << n]; + memset(f, -1, sizeof(f)); + int k = K; + auto dfs = [&](auto&& dfs, int i) -> int { + if (i == (1 << n) - 1) { + return 0; + } + if (f[i] != -1) { + return f[i]; + } + int cnt = __builtin_popcount(i); + int x = 1 + k * cnt; + f[i] = INT_MAX; + for (int j = 0; j < n; ++j) { + if (i >> j & 1 ^ 1) { + f[i] = min(f[i], dfs(dfs, i | 1 << j) + (strength[j] + x - 1) / x); + } + } + return f[i]; + }; + return dfs(dfs, 0); + } +}; diff --git a/solution/3300-3399/3376.Minimum Time to Break Locks I/Solution.go b/solution/3300-3399/3376.Minimum Time to Break Locks I/Solution.go new file mode 100644 index 0000000000000..42484e58ecb4e --- /dev/null +++ b/solution/3300-3399/3376.Minimum Time to Break Locks I/Solution.go @@ -0,0 +1,25 @@ +func findMinimumTime(strength []int, K int) int { + n := len(strength) + f := make([]int, 1<>j&1 == 0 { + f[i] = min(f[i], dfs(i|1< strength; + private Integer[] f; + private int k; + private int n; + + public int findMinimumTime(List strength, int K) { + n = strength.size(); + f = new Integer[1 << n]; + k = K; + this.strength = strength; + return dfs(0); + } + + private int dfs(int i) { + if (i == (1 << n) - 1) { + return 0; + } + if (f[i] != null) { + return f[i]; + } + int cnt = Integer.bitCount(i); + int x = 1 + cnt * k; + f[i] = 1 << 30; + for (int j = 0; j < n; ++j) { + if ((i >> j & 1) == 0) { + f[i] = Math.min(f[i], dfs(i | 1 << j) + (strength.get(j) + x - 1) / x); + } + } + return f[i]; + } +} diff --git a/solution/3300-3399/3376.Minimum Time to Break Locks I/Solution.py b/solution/3300-3399/3376.Minimum Time to Break Locks I/Solution.py new file mode 100644 index 0000000000000..fe2c449fb6b22 --- /dev/null +++ b/solution/3300-3399/3376.Minimum Time to Break Locks I/Solution.py @@ -0,0 +1,15 @@ +class Solution: + def findMinimumTime(self, strength: List[int], K: int) -> int: + @cache + def dfs(i: int) -> int: + if i == (1 << len(strength)) - 1: + return 0 + cnt = i.bit_count() + x = 1 + cnt * K + ans = inf + for j, s in enumerate(strength): + if i >> j & 1 ^ 1: + ans = min(ans, dfs(i | 1 << j) + (s + x - 1) // x) + return ans + + return dfs(0) diff --git a/solution/3300-3399/3376.Minimum Time to Break Locks I/Solution.ts b/solution/3300-3399/3376.Minimum Time to Break Locks I/Solution.ts new file mode 100644 index 0000000000000..0720c2880eb30 --- /dev/null +++ b/solution/3300-3399/3376.Minimum Time to Break Locks I/Solution.ts @@ -0,0 +1,30 @@ +function findMinimumTime(strength: number[], K: number): number { + const n = strength.length; + const f: number[] = Array(1 << n).fill(-1); + const dfs = (i: number): number => { + if (i === (1 << n) - 1) { + return 0; + } + if (f[i] !== -1) { + return f[i]; + } + f[i] = Infinity; + const x = 1 + K * bitCount(i); + for (let j = 0; j < n; ++j) { + if (((i >> j) & 1) == 0) { + f[i] = Math.min(f[i], dfs(i | (1 << j)) + Math.ceil(strength[j] / x)); + } + } + return f[i]; + }; + return dfs(0); +} + +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; +}