Skip to content

Commit 141ff97

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1494
No.1494.Parallel Courses II
1 parent 494102d commit 141ff97

File tree

6 files changed

+483
-2
lines changed

6 files changed

+483
-2
lines changed

‎solution/1400-1499/1494.Parallel Courses II/README.md

Lines changed: 172 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -60,22 +60,193 @@
6060

6161
<!-- 这里可写通用的实现逻辑 -->
6262

63+
**方法一：状态压缩 + BFS + 枚举子集**
64+
65+
我们用数组 $d[i]$ 表示课程 $i$ 的先修课程的集合。由于数据规模 $n\lt 15$，我们可以用一个整数的二进制位来表示集合，其中第 $j$ 位为 $1$ 表示课程 $j$ 是课程 $i$ 的先修课程。
66+
67+
我们用一个状态变量 $cur$ 表示当前已经上过的课程的集合，初始时 $cur=0$。如果 $cur=2^{n+1}-2$，表示所有课程都上过了，返回当前学期即可。
68+
69+
如果课程 $i$ 的先修课程 $d[i]$ 的集合是 $cur$ 的子集，说明课程 $i$ 可以上。这样我们可以找到当前 $cur$ 状态的下一个状态 $nxt$，表示后续学期可以上的课程集合。
70+
71+
如果 $nxt$ 的二进制表示中 $1$ 的个数小于等于 $k$，说明后续学期可以上的课程数不超过 $k$，我们就可以将 $nxt$ 加入队列中。否则，说明后续学期可以上的课程数超过 $k$，那么我们就应该从后续可以上的课程中选择 $k$ 门课程，这样才能保证后续学期可以上的课程数不超过 $k$。我们可以枚举 $nxt$ 的所有子集，将子集加入队列中。
72+
73+
时间复杂度 $O(2^n\times n)$，空间复杂度 $O(2^n\times)$。
74+
6375
<!-- tabs:start -->
6476

6577
### **Python3**
6678

6779
<!-- 这里可写当前语言的特殊实现逻辑 -->
6880

6981
```python
70-
82+
class Solution:
83+
def minNumberOfSemesters(self, n: int, relations: List[List[int]], k: int) -> int:
84+
d = [0] * (n + 1)
85+
for x, y in relations:
86+
d[y] |= 1 << x
87+
q = deque([(0, 0)])
88+
vis = {0}
89+
while q:
90+
cur, t = q.popleft()
91+
if cur == (1 << (n + 1)) - 2:
92+
return t
93+
nxt = 0
94+
for i in range(1, n + 1):
95+
if (cur & d[i]) == d[i]:
96+
nxt |= 1 << i
97+
nxt ^= cur
98+
if nxt.bit_count() <= k:
99+
if (nxt | cur) not in vis:
100+
vis.add(nxt | cur)
101+
q.append((nxt | cur, t + 1))
102+
else:
103+
x = nxt
104+
while nxt:
105+
if nxt.bit_count() == k and (nxt | cur) not in vis:
106+
vis.add(nxt | cur)
107+
q.append((nxt | cur, t + 1))
108+
nxt = (nxt - 1) & x
71109
```
72110

73111
### **Java**
74112

75113
<!-- 这里可写当前语言的特殊实现逻辑 -->
76114

77115
```java
116+
class Solution {
117+
public int minNumberOfSemesters(int n, int[][] relations, int k) {
118+
int[] d = new int[n + 1];
119+
for (var e : relations) {
120+
d[e[1]] |= 1 << e[0];
121+
}
122+
Deque<int[]> q = new ArrayDeque<>();
123+
q.offer(new int[] {0, 0});
124+
Set<Integer> vis = new HashSet<>();
125+
vis.add(0);
126+
while (!q.isEmpty()) {
127+
var p = q.pollFirst();
128+
int cur = p[0], t = p[1];
129+
if (cur == (1 << (n + 1)) - 2) {
130+
return t;
131+
}
132+
int nxt = 0;
133+
for (int i = 1; i <= n; ++i) {
134+
if ((cur & d[i]) == d[i]) {
135+
nxt |= 1 << i;
136+
}
137+
}
138+
nxt ^= cur;
139+
if (Integer.bitCount(nxt) <= k) {
140+
if (vis.add(nxt | cur)) {
141+
q.offer(new int[] {nxt | cur, t + 1});
142+
}
143+
} else {
144+
int x = nxt;
145+
while (nxt > 0) {
146+
if (Integer.bitCount(nxt) == k && vis.add(nxt | cur)) {
147+
q.offer(new int[] {nxt | cur, t + 1});
148+
}
149+
nxt = (nxt - 1) & x;
150+
}
151+
}
152+
}
153+
return 0;
154+
}
155+
}
156+
```
157+
158+
### **C++**
159+
160+
```cpp
161+
using pii = pair<int, int>;
162+
163+
class Solution {
164+
public:
165+
int minNumberOfSemesters(int n, vector<vector<int>>& relations, int k) {
166+
vector<int> d(n + 1);
167+
for (auto& e : relations) {
168+
d[e[1]] |= 1 << e[0];
169+
}
170+
queue<pii> q;
171+
q.push({0, 0});
172+
unordered_set<int> vis{{0}};
173+
while (!q.empty()) {
174+
auto [cur, t] = q.front();
175+
q.pop();
176+
if (cur == (1 << (n + 1)) - 2) {
177+
return t;
178+
}
179+
int nxt = 0;
180+
for (int i = 1; i <= n; ++i) {
181+
if ((cur & d[i]) == d[i]) {
182+
nxt |= 1 << i;
183+
}
184+
}
185+
nxt ^= cur;
186+
if (__builtin_popcount(nxt) <= k) {
187+
if (!vis.count(nxt | cur)) {
188+
vis.insert(nxt | cur);
189+
q.push({nxt | cur, t + 1});
190+
}
191+
} else {
192+
int x = nxt;
193+
while (nxt) {
194+
if (__builtin_popcount(nxt) == k && !vis.count(nxt | cur)) {
195+
vis.insert(nxt | cur);
196+
q.push({nxt | cur, t + 1});
197+
}
198+
nxt = (nxt - 1) & x;
199+
}
200+
}
201+
}
202+
return 0;
203+
}
204+
};
205+
```
78206
207+
### **Go**
208+
209+
```go
210+
func minNumberOfSemesters(n int, relations [][]int, k int) int {
211+
d := make([]int, n+1)
212+
for _, e := range relations {
213+
d[e[1]] |= 1 << e[0]
214+
}
215+
type pair struct{ v, t int }
216+
q := []pair{pair{0, 0}}
217+
vis := map[int]bool{0: true}
218+
for len(q) > 0 {
219+
p := q[0]
220+
q = q[1:]
221+
cur, t := p.v, p.t
222+
if cur == (1<<(n+1))-2 {
223+
return t
224+
}
225+
nxt := 0
226+
for i := 1; i <= n; i++ {
227+
if (cur & d[i]) == d[i] {
228+
nxt |= 1 << i
229+
}
230+
}
231+
nxt ^= cur
232+
if bits.OnesCount(uint(nxt)) <= k {
233+
if !vis[nxt|cur] {
234+
vis[nxt|cur] = true
235+
q = append(q, pair{nxt | cur, t + 1})
236+
}
237+
} else {
238+
x := nxt
239+
for nxt > 0 {
240+
if bits.OnesCount(uint(nxt)) == k && !vis[nxt|cur] {
241+
vis[nxt|cur] = true
242+
q = append(q, pair{nxt | cur, t + 1})
243+
}
244+
nxt = (nxt - 1) & x
245+
}
246+
}
247+
}
248+
return 0
249+
}
79250
```
80251

81252
### **...**

‎solution/1400-1499/1494.Parallel Courses II/README_EN.md

Lines changed: 160 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -55,13 +55,172 @@ In the fourth semester, you can take course 5.
5555
### **Python3**
5656

5757
```python
58-
58+
class Solution:
59+
def minNumberOfSemesters(self, n: int, relations: List[List[int]], k: int) -> int:
60+
d = [0] * (n + 1)
61+
for x, y in relations:
62+
d[y] |= 1 << x
63+
q = deque([(0, 0)])
64+
vis = {0}
65+
while q:
66+
cur, t = q.popleft()
67+
if cur == (1 << (n + 1)) - 2:
68+
return t
69+
nxt = 0
70+
for i in range(1, n + 1):
71+
if (cur & d[i]) == d[i]:
72+
nxt |= 1 << i
73+
nxt ^= cur
74+
if nxt.bit_count() <= k:
75+
if (nxt | cur) not in vis:
76+
vis.add(nxt | cur)
77+
q.append((nxt | cur, t + 1))
78+
else:
79+
x = nxt
80+
while nxt:
81+
if nxt.bit_count() == k and (nxt | cur) not in vis:
82+
vis.add(nxt | cur)
83+
q.append((nxt | cur, t + 1))
84+
nxt = (nxt - 1) & x
5985
```
6086

6187
### **Java**
6288

6389
```java
90+
class Solution {
91+
public int minNumberOfSemesters(int n, int[][] relations, int k) {
92+
int[] d = new int[n + 1];
93+
for (var e : relations) {
94+
d[e[1]] |= 1 << e[0];
95+
}
96+
Deque<int[]> q = new ArrayDeque<>();
97+
q.offer(new int[] {0, 0});
98+
Set<Integer> vis = new HashSet<>();
99+
vis.add(0);
100+
while (!q.isEmpty()) {
101+
var p = q.pollFirst();
102+
int cur = p[0], t = p[1];
103+
if (cur == (1 << (n + 1)) - 2) {
104+
return t;
105+
}
106+
int nxt = 0;
107+
for (int i = 1; i <= n; ++i) {
108+
if ((cur & d[i]) == d[i]) {
109+
nxt |= 1 << i;
110+
}
111+
}
112+
nxt ^= cur;
113+
if (Integer.bitCount(nxt) <= k) {
114+
if (vis.add(nxt | cur)) {
115+
q.offer(new int[] {nxt | cur, t + 1});
116+
}
117+
} else {
118+
int x = nxt;
119+
while (nxt > 0) {
120+
if (Integer.bitCount(nxt) == k && vis.add(nxt | cur)) {
121+
q.offer(new int[] {nxt | cur, t + 1});
122+
}
123+
nxt = (nxt - 1) & x;
124+
}
125+
}
126+
}
127+
return 0;
128+
}
129+
}
130+
```
131+
132+
### **C++**
133+
134+
```cpp
135+
using pii = pair<int, int>;
136+
137+
class Solution {
138+
public:
139+
int minNumberOfSemesters(int n, vector<vector<int>>& relations, int k) {
140+
vector<int> d(n + 1);
141+
for (auto& e : relations) {
142+
d[e[1]] |= 1 << e[0];
143+
}
144+
queue<pii> q;
145+
q.push({0, 0});
146+
unordered_set<int> vis{{0}};
147+
while (!q.empty()) {
148+
auto [cur, t] = q.front();
149+
q.pop();
150+
if (cur == (1 << (n + 1)) - 2) {
151+
return t;
152+
}
153+
int nxt = 0;
154+
for (int i = 1; i <= n; ++i) {
155+
if ((cur & d[i]) == d[i]) {
156+
nxt |= 1 << i;
157+
}
158+
}
159+
nxt ^= cur;
160+
if (__builtin_popcount(nxt) <= k) {
161+
if (!vis.count(nxt | cur)) {
162+
vis.insert(nxt | cur);
163+
q.push({nxt | cur, t + 1});
164+
}
165+
} else {
166+
int x = nxt;
167+
while (nxt) {
168+
if (__builtin_popcount(nxt) == k && !vis.count(nxt | cur)) {
169+
vis.insert(nxt | cur);
170+
q.push({nxt | cur, t + 1});
171+
}
172+
nxt = (nxt - 1) & x;
173+
}
174+
}
175+
}
176+
return 0;
177+
}
178+
};
179+
```
64180
181+
### **Go**
182+
183+
```go
184+
func minNumberOfSemesters(n int, relations [][]int, k int) int {
185+
d := make([]int, n+1)
186+
for _, e := range relations {
187+
d[e[1]] |= 1 << e[0]
188+
}
189+
type pair struct{ v, t int }
190+
q := []pair{pair{0, 0}}
191+
vis := map[int]bool{0: true}
192+
for len(q) > 0 {
193+
p := q[0]
194+
q = q[1:]
195+
cur, t := p.v, p.t
196+
if cur == (1<<(n+1))-2 {
197+
return t
198+
}
199+
nxt := 0
200+
for i := 1; i <= n; i++ {
201+
if (cur & d[i]) == d[i] {
202+
nxt |= 1 << i
203+
}
204+
}
205+
nxt ^= cur
206+
if bits.OnesCount(uint(nxt)) <= k {
207+
if !vis[nxt|cur] {
208+
vis[nxt|cur] = true
209+
q = append(q, pair{nxt | cur, t + 1})
210+
}
211+
} else {
212+
x := nxt
213+
for nxt > 0 {
214+
if bits.OnesCount(uint(nxt)) == k && !vis[nxt|cur] {
215+
vis[nxt|cur] = true
216+
q = append(q, pair{nxt | cur, t + 1})
217+
}
218+
nxt = (nxt - 1) & x
219+
}
220+
}
221+
}
222+
return 0
223+
}
65224
```
66225

67226
### **...**

0 commit comments

Comments
 (0)