feat: add solutions to lc problem: No.1723

No.1723.Find Minimum Time to Finish All Jobs

Author: yanglbme

solution/1000-1099/1090.Largest Values From Labels/README.md

@@ -60,6 +60,8 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：贪心**
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -69,17 +71,15 @@
 ```python
 class Solution:
     def largestValsFromLabels(self, values: List[int], labels: List[int], numWanted: int, useLimit: int) -> int:
-        n = len(values)
-        idx = list(range(n))
-        idx.sort(key=lambda i: -values[i])
+        arr = list(zip(values, labels))
+        arr.sort(reverse=True)
+        cnt = Counter()
         ans = num = 0
-        counter = Counter()
-        for i in idx:
-            v, l = values[i], labels[i]
-            if counter[l] < useLimit:
-                counter[l] += 1
-                ans += v
+        for v, l in arr:
+            if cnt[l] < useLimit:
+                cnt[l] += 1
                 num += 1
+                ans += v
             if num == numWanted:
                 break
         return ans

solution/1000-1099/1090.Largest Values From Labels/README_EN.md

@@ -61,17 +61,15 @@
 ```python
 class Solution:
     def largestValsFromLabels(self, values: List[int], labels: List[int], numWanted: int, useLimit: int) -> int:
-        n = len(values)
-        idx = list(range(n))
-        idx.sort(key=lambda i: -values[i])
+        arr = list(zip(values, labels))
+        arr.sort(reverse=True)
+        cnt = Counter()
         ans = num = 0
-        counter = Counter()
-        for i in idx:
-            v, l = values[i], labels[i]
-            if counter[l] < useLimit:
-                counter[l] += 1
-                ans += v
+        for v, l in arr:
+            if cnt[l] < useLimit:
+                cnt[l] += 1
                 num += 1
+                ans += v
             if num == numWanted:
                 break
         return ans

solution/1000-1099/1090.Largest Values From Labels/Solution.py

@@ -2,17 +2,15 @@ class Solution:
     def largestValsFromLabels(
         self, values: List[int], labels: List[int], numWanted: int, useLimit: int
     ) -> int:
-        n = len(values)
-        idx = list(range(n))
-        idx.sort(key=lambda i: -values[i])
+        arr = list(zip(values, labels))
+        arr.sort(reverse=True)
+        cnt = Counter()
         ans = num = 0
-        counter = Counter()
-        for i in idx:
-            v, l = values[i], labels[i]
-            if counter[l] < useLimit:
-                counter[l] += 1
-                ans += v
+        for v, l in arr:
+            if cnt[l] < useLimit:
+                cnt[l] += 1
                 num += 1
+                ans += v
             if num == numWanted:
                 break
         return ans

solution/1700-1799/1723.Find Minimum Time to Finish All Jobs/README.md

@@ -45,22 +45,173 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：DFS + 剪枝**
+
+本题与 [2305. 公平分发饼干](/solution/2300-2399/2305.Fair%20Distribution%20of%20Cookies/README.md) 基本一致，不同的地方仅在于 $k$ 值的大小。
+
+剪枝优化：优化分配花费时间较大的工作，因此可以先对 $jobs$ 按照降序排列。
+
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def minimumTimeRequired(self, jobs: List[int], k: int) -> int:
+        def dfs(i):
+            nonlocal ans
+            if i == len(jobs):
+                ans = min(ans, max(cnt))
+                return
+            for j in range(k):
+                if cnt[j] + jobs[i] >= ans:
+                    continue
+                cnt[j] += jobs[i]
+                dfs(i + 1)
+                cnt[j] -= jobs[i]
+                if cnt[j] == 0:
+                    break
+
+        cnt = [0] * k
+        jobs.sort(reverse=True)
+        ans = inf
+        dfs(0)
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private int[] cnt;
+    private int ans;
+    private int[] jobs;
+    private int k;
+
+    public int minimumTimeRequired(int[] jobs, int k) {
+        this.k = k;
+        Arrays.sort(jobs);
+        for (int i = 0, j = jobs.length - 1; i < j; ++i, --j) {
+            int t = jobs[i];
+            jobs[i] = jobs[j];
+            jobs[j] = t;
+        }
+        this.jobs = jobs;
+        cnt = new int[k];
+        ans = 0x3f3f3f3f;
+        dfs(0);
+        return ans;
+    }
+
+    private void dfs(int i) {
+        if (i == jobs.length) {
+            int mx = 0;
+            for (int v : cnt) {
+                mx = Math.max(mx, v);
+            }
+            ans = Math.min(ans, mx);
+            return;
+        }
+        for (int j = 0; j < k; ++j) {
+            if (cnt[j] + jobs[i] >= ans) {
+                continue;
+            }
+            cnt[j] += jobs[i];
+            dfs(i + 1);
+            cnt[j] -= jobs[i];
+            if (cnt[j] == 0) {
+                break;
+            }
+        }
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int ans;
+
+    int minimumTimeRequired(vector<int>& jobs, int k) {
+        vector<int> cnt(k);
+        ans = 0x3f3f3f3f;
+        sort(jobs.begin(), jobs.end(), greater<int>());
+        dfs(0, k, jobs, cnt);
+        return ans;
+    }
+
+    void dfs(int i, int k, vector<int>& jobs, vector<int>& cnt) {
+        if (i == jobs.size()) {
+            ans = min(ans, *max_element(cnt.begin(), cnt.end()));
+            return;
+        }
+        for (int j = 0; j < k; ++j)
+        {
+            if (cnt[j] + jobs[i] >= ans) continue;
+            cnt[j] += jobs[i];
+            dfs(i + 1, k, jobs, cnt);
+            cnt[j] -= jobs[i];
+            if (cnt[j] == 0) break;
+        }
+    }
+};
+```
 
+### **Go**
+
+```go
+func minimumTimeRequired(jobs []int, k int) int {
+	cnt := make([]int, k)
+	ans := 0x3f3f3f3f
+	sort.Slice(jobs, func(i, j int) bool {
+		return jobs[i] > jobs[j]
+	})
+	var dfs func(int)
+	dfs = func(i int) {
+		if i == len(jobs) {
+			mx := 0
+			for _, v := range cnt {
+				mx = max(mx, v)
+			}
+			ans = min(ans, mx)
+			return
+		}
+		for j := 0; j < k; j++ {
+			if cnt[j]+jobs[i] >= ans {
+				continue
+			}
+			cnt[j] += jobs[i]
+			dfs(i + 1)
+			cnt[j] -= jobs[i]
+			if cnt[j] == 0 {
+				break
+			}
+		}
+	}
+	dfs(0)
+	return ans
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**