feat: add solutions to lc problem: No.1986 (doocs#1351)

No.1986.Minimum Number of Work Sessions to Finish the Tasks

Author: yanglbme

solution/1900-1999/1986.Minimum Number of Work Sessions to Finish the Tasks/README.md

@@ -62,22 +62,171 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：状态压缩动态规划 + 枚举子集**
+
+我们注意到 $n$ 不超过 $14$，因此，我们可以考虑使用状态压缩动态规划的方法求解本题。
+
+我们用一个长度为 $n$ 的二进制数 $i$ 来表示当前的任务状态，其中 $i$ 的第 $j$ 位为 $1$，当且仅当第 $j$ 个任务被完成。我们用 $f[i]$ 表示完成状态为 $i$ 的所有任务所需要的最少工作时间段数。
+
+我们可以枚举 $i$ 的所有子集 $j$，其中 $j$ 的二进制表示中的每一位都是 $i$ 的二进制表示中对应位的子集，即 $j \subseteq i$。如果 $j$ 对应的任务可以在一个工作时间段内完成，那么我们可以用 $f[i \oplus j] + 1$ 来更新 $f[i]$，其中 $i \oplus j$ 表示 $i$ 和 $j$ 的按位异或。
+
+最终的答案即为 $f[2^n - 1]$。
+
+时间复杂度 $O(n \times 3^n)$，空间复杂度 $O(2^n)$。其中 $n$ 为任务的数量。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def minSessions(self, tasks: List[int], sessionTime: int) -> int:
+        n = len(tasks)
+        ok = [False] * (1 << n)
+        for i in range(1, 1 << n):
+            t = sum(tasks[j] for j in range(n) if i >> j & 1)
+            ok[i] = t <= sessionTime
+        f = [inf] * (1 << n)
+        f[0] = 0
+        for i in range(1, 1 << n):
+            j = i
+            while j:
+                if ok[j]:
+                    f[i] = min(f[i], f[i ^ j] + 1)
+                j = (j - 1) & i
+        return f[-1]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int minSessions(int[] tasks, int sessionTime) {
+        int n = tasks.length;
+        boolean[] ok = new boolean[1 << n];
+        for (int i = 1; i < 1 << n; ++i) {
+            int t = 0;
+            for (int j = 0; j < n; ++j) {
+                if ((i >> j & 1) == 1) {
+                    t += tasks[j];
+                }
+            }
+            ok[i] = t <= sessionTime;
+        }
+        int[] f = new int[1 << n];
+        Arrays.fill(f, 1 << 30);
+        f[0] = 0;
+        for (int i = 1; i < 1 << n; ++i) {
+            for (int j = i; j > 0; j = (j - 1) & i) {
+                if (ok[j]) {
+                    f[i] = Math.min(f[i], f[i ^ j] + 1);
+                }
+            }
+        }
+        return f[(1 << n) - 1];
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int minSessions(vector<int>& tasks, int sessionTime) {
+        int n = tasks.size();
+        bool ok[1 << n];
+        memset(ok, false, sizeof(ok));
+        for (int i = 1; i < 1 << n; ++i) {
+            int t = 0;
+            for (int j = 0; j < n; ++j) {
+                if (i >> j & 1) {
+                    t += tasks[j];
+                }
+            }
+            ok[i] = t <= sessionTime;
+        }
+        int f[1 << n];
+        memset(f, 0x3f, sizeof(f));
+        f[0] = 0;
+        for (int i = 1; i < 1 << n; ++i) {
+            for (int j = i; j; j = (j - 1) & i) {
+                if (ok[j]) {
+                    f[i] = min(f[i], f[i ^ j] + 1);
+                }
+            }
+        }
+        return f[(1 << n) - 1];
+    }
+};
+```
+
+### **Go**
+
+```go
+func minSessions(tasks []int, sessionTime int) int {
+	n := len(tasks)
+	ok := make([]bool, 1<<n)
+	f := make([]int, 1<<n)
+	for i := 1; i < 1<<n; i++ {
+		t := 0
+		f[i] = 1 << 30
+		for j, x := range tasks {
+			if i>>j&1 == 1 {
+				t += x
+			}
+		}
+		ok[i] = t <= sessionTime
+	}
+	for i := 1; i < 1<<n; i++ {
+		for j := i; j > 0; j = (j - 1) & i {
+			if ok[j] {
+				f[i] = min(f[i], f[i^j]+1)
+			}
+		}
+	}
+	return f[1<<n-1]
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+```
 
+### **TypeScript**
+
+```ts
+function minSessions(tasks: number[], sessionTime: number): number {
+    const n = tasks.length;
+    const ok: boolean[] = new Array(1 << n).fill(false);
+    for (let i = 1; i < 1 << n; ++i) {
+        let t = 0;
+        for (let j = 0; j < n; ++j) {
+            if (((i >> j) & 1) === 1) {
+                t += tasks[j];
+            }
+        }
+        ok[i] = t <= sessionTime;
+    }
+
+    const f: number[] = new Array(1 << n).fill(1 << 30);
+    f[0] = 0;
+    for (let i = 1; i < 1 << n; ++i) {
+        for (let j = i; j > 0; j = (j - 1) & i) {
+            if (ok[j]) {
+                f[i] = Math.min(f[i], f[i ^ j] + 1);
+            }
+        }
+    }
+    return f[(1 << n) - 1];
+}
 ```
 
 ### **...**

solution/1900-1999/1986.Minimum Number of Work Sessions to Finish the Tasks/README_EN.md

@@ -64,13 +64,150 @@
 ### **Python3**
 
 ```python
-
+class Solution:
+    def minSessions(self, tasks: List[int], sessionTime: int) -> int:
+        n = len(tasks)
+        ok = [False] * (1 << n)
+        for i in range(1, 1 << n):
+            t = sum(tasks[j] for j in range(n) if i >> j & 1)
+            ok[i] = t <= sessionTime
+        f = [inf] * (1 << n)
+        f[0] = 0
+        for i in range(1, 1 << n):
+            j = i
+            while j:
+                if ok[j]:
+                    f[i] = min(f[i], f[i ^ j] + 1)
+                j = (j - 1) & i
+        return f[-1]
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public int minSessions(int[] tasks, int sessionTime) {
+        int n = tasks.length;
+        boolean[] ok = new boolean[1 << n];
+        for (int i = 1; i < 1 << n; ++i) {
+            int t = 0;
+            for (int j = 0; j < n; ++j) {
+                if ((i >> j & 1) == 1) {
+                    t += tasks[j];
+                }
+            }
+            ok[i] = t <= sessionTime;
+        }
+        int[] f = new int[1 << n];
+        Arrays.fill(f, 1 << 30);
+        f[0] = 0;
+        for (int i = 1; i < 1 << n; ++i) {
+            for (int j = i; j > 0; j = (j - 1) & i) {
+                if (ok[j]) {
+                    f[i] = Math.min(f[i], f[i ^ j] + 1);
+                }
+            }
+        }
+        return f[(1 << n) - 1];
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int minSessions(vector<int>& tasks, int sessionTime) {
+        int n = tasks.size();
+        bool ok[1 << n];
+        memset(ok, false, sizeof(ok));
+        for (int i = 1; i < 1 << n; ++i) {
+            int t = 0;
+            for (int j = 0; j < n; ++j) {
+                if (i >> j & 1) {
+                    t += tasks[j];
+                }
+            }
+            ok[i] = t <= sessionTime;
+        }
+        int f[1 << n];
+        memset(f, 0x3f, sizeof(f));
+        f[0] = 0;
+        for (int i = 1; i < 1 << n; ++i) {
+            for (int j = i; j; j = (j - 1) & i) {
+                if (ok[j]) {
+                    f[i] = min(f[i], f[i ^ j] + 1);
+                }
+            }
+        }
+        return f[(1 << n) - 1];
+    }
+};
+```
+
+### **Go**
+
+```go
+func minSessions(tasks []int, sessionTime int) int {
+	n := len(tasks)
+	ok := make([]bool, 1<<n)
+	f := make([]int, 1<<n)
+	for i := 1; i < 1<<n; i++ {
+		t := 0
+		f[i] = 1 << 30
+		for j, x := range tasks {
+			if i>>j&1 == 1 {
+				t += x
+			}
+		}
+		ok[i] = t <= sessionTime
+	}
+	for i := 1; i < 1<<n; i++ {
+		for j := i; j > 0; j = (j - 1) & i {
+			if ok[j] {
+				f[i] = min(f[i], f[i^j]+1)
+			}
+		}
+	}
+	return f[1<<n-1]
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+```
 
+### **TypeScript**
+
+```ts
+function minSessions(tasks: number[], sessionTime: number): number {
+    const n = tasks.length;
+    const ok: boolean[] = new Array(1 << n).fill(false);
+    for (let i = 1; i < 1 << n; ++i) {
+        let t = 0;
+        for (let j = 0; j < n; ++j) {
+            if (((i >> j) & 1) === 1) {
+                t += tasks[j];
+            }
+        }
+        ok[i] = t <= sessionTime;
+    }
+
+    const f: number[] = new Array(1 << n).fill(1 << 30);
+    f[0] = 0;
+    for (let i = 1; i < 1 << n; ++i) {
+        for (let j = i; j > 0; j = (j - 1) & i) {
+            if (ok[j]) {
+                f[i] = Math.min(f[i], f[i ^ j] + 1);
+            }
+        }
+    }
+    return f[(1 << n) - 1];
+}
 ```
 
 ### **...**

solution/1900-1999/1986.Minimum Number of Work Sessions to Finish the Tasks/Solution.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    int minSessions(vector<int>& tasks, int sessionTime) {
+        int n = tasks.size();
+        bool ok[1 << n];
+        memset(ok, false, sizeof(ok));
+        for (int i = 1; i < 1 << n; ++i) {
+            int t = 0;
+            for (int j = 0; j < n; ++j) {
+                if (i >> j & 1) {
+                    t += tasks[j];
+                }
+            }
+            ok[i] = t <= sessionTime;
+        }
+        int f[1 << n];
+        memset(f, 0x3f, sizeof(f));
+        f[0] = 0;
+        for (int i = 1; i < 1 << n; ++i) {
+            for (int j = i; j; j = (j - 1) & i) {
+                if (ok[j]) {
+                    f[i] = min(f[i], f[i ^ j] + 1);
+                }
+            }
+        }
+        return f[(1 << n) - 1];
+    }
+};

solution/1900-1999/1986.Minimum Number of Work Sessions to Finish the Tasks/Solution.go

@@ -0,0 +1,30 @@
+func minSessions(tasks []int, sessionTime int) int {
+	n := len(tasks)
+	ok := make([]bool, 1<<n)
+	f := make([]int, 1<<n)
+	for i := 1; i < 1<<n; i++ {
+		t := 0
+		f[i] = 1 << 30
+		for j, x := range tasks {
+			if i>>j&1 == 1 {
+				t += x
+			}
+		}
+		ok[i] = t <= sessionTime
+	}
+	for i := 1; i < 1<<n; i++ {
+		for j := i; j > 0; j = (j - 1) & i {
+			if ok[j] {
+				f[i] = min(f[i], f[i^j]+1)
+			}
+		}
+	}
+	return f[1<<n-1]
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}