Skip to content

Commit b3e1475

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problems: No.0207,0210
No.0207.Course Schedule No.0210.Course Schedule II
1 parent f0d1c11 commit b3e1475

File tree

12 files changed

+878
-80
lines changed

12 files changed

+878
-80
lines changed

‎solution/0200-0299/0207.Course Schedule/README.md

Lines changed: 168 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -44,27 +44,193 @@
4444
<li><code>prerequisites[i]</code> 中的所有课程对 <strong>互不相同</strong></li>
4545
</ul>
4646

47-
4847
## 解法
4948

5049
<!-- 这里可写通用的实现逻辑 -->
5150

51+
拓扑排序，BFS 实现。
52+
5253
<!-- tabs:start -->
5354

5455
### **Python3**
5556

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

5859
```python
59-
60+
class Solution:
61+
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
62+
edges = collections.defaultdict(list)
63+
indegree = [0] * numCourses
64+
for i, j in prerequisites:
65+
edges[j].append(i)
66+
indegree[i] += 1
67+
q = collections.deque()
68+
for i in range(numCourses):
69+
if indegree[i] == 0:
70+
q.append(i)
71+
cnt = 0
72+
while q:
73+
i = q.popleft()
74+
cnt += 1
75+
for j in edges[i]:
76+
indegree[j] -= 1
77+
if indegree[j] == 0:
78+
q.append(j)
79+
return cnt == numCourses
6080
```
6181

6282
### **Java**
6383

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

6686
```java
87+
class Solution {
88+
public boolean canFinish(int numCourses, int[][] prerequisites) {
89+
List<Integer>[] edges = new List[numCourses];
90+
for (int i = 0; i < numCourses; ++i) {
91+
edges[i] = new ArrayList<>();
92+
}
93+
int[] indegree = new int[numCourses];
94+
for (int[] p : prerequisites) {
95+
edges[p[1]].add(p[0]);
96+
++indegree[p[0]];
97+
}
98+
Queue<Integer> q = new LinkedList<>();
99+
for (int i = 0; i < numCourses; ++i) {
100+
if (indegree[i] == 0) {
101+
q.offer(i);
102+
}
103+
}
104+
int cnt = 0;
105+
while (!q.isEmpty()) {
106+
int i = q.poll();
107+
++cnt;
108+
for (int j : edges[i]) {
109+
--indegree[j];
110+
if (indegree[j] == 0) {
111+
q.offer(j);
112+
}
113+
}
114+
}
115+
return cnt == numCourses;
116+
}
117+
}
118+
```
119+
120+
### **C++**
121+
122+
```cpp
123+
class Solution {
124+
public:
125+
bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
126+
vector<vector<int>> edges(numCourses);
127+
vector<int> indegree(numCourses);
128+
for (auto p : prerequisites)
129+
{
130+
edges[p[1]].push_back(p[0]);
131+
++indegree[p[0]];
132+
}
133+
queue<int> q;
134+
for (int i = 0; i < numCourses; ++i)
135+
{
136+
if (indegree[i] == 0) q.push(i);
137+
}
138+
int cnt = 0;
139+
while (!q.empty())
140+
{
141+
int i = q.front();
142+
q.pop();
143+
++cnt;
144+
for (int j : edges[i])
145+
{
146+
--indegree[j];
147+
if (indegree[j] == 0) q.push(j);
148+
}
149+
}
150+
return cnt == numCourses;
151+
}
152+
};
153+
```
154+
155+
### **Go**
156+
157+
```go
158+
func canFinish(numCourses int, prerequisites [][]int) bool {
159+
edges := make([][]int, numCourses)
160+
indegree := make([]int, numCourses)
161+
for _, p := range prerequisites {
162+
edges[p[1]] = append(edges[p[1]], p[0])
163+
indegree[p[0]]++
164+
}
165+
var q []int
166+
for i := 0; i < numCourses; i++ {
167+
if indegree[i] == 0 {
168+
q = append(q, i)
169+
}
170+
}
171+
cnt := 0
172+
for len(q) > 0 {
173+
i := q[0]
174+
q = q[1:]
175+
cnt++
176+
for _, j := range edges[i] {
177+
indegree[j]--
178+
if indegree[j] == 0 {
179+
q = append(q, j)
180+
}
181+
}
182+
}
183+
return cnt == numCourses
184+
}
185+
```
67186

187+
### **C#**
188+
189+
```cs
190+
using System.Collections.Generic;
191+
192+
public class Solution {
193+
public bool CanFinish(int numCourses, int[][] prerequisites) {
194+
var indegree = new int[numCourses];
195+
var edgeCount = prerequisites.Length;
196+
var edge = new List<int>[numCourses];
197+
for (var i = 0; i < edgeCount; ++i)
198+
{
199+
var child = prerequisites[i][0];
200+
var parent = prerequisites[i][1];
201+
if (edge[parent] == null)
202+
{
203+
edge[parent] = new List<int>();
204+
}
205+
edge[parent].Add(child);
206+
++indegree[child];
207+
}
208+
209+
var queue = new Queue<int>();
210+
for (var i = 0; i < numCourses; ++i)
211+
{
212+
if (indegree[i] == 0) queue.Enqueue(i);
213+
}
214+
215+
var count = 0;
216+
while (queue.Count > 0)
217+
{
218+
var node = queue.Dequeue();
219+
++count;
220+
if (edge[node] != null)
221+
{
222+
foreach (var next in edge[node])
223+
{
224+
if (--indegree[next] == 0)
225+
{
226+
queue.Enqueue(next);
227+
}
228+
}
229+
}
230+
}
231+
return count == numCourses;
232+
}
233+
}
68234
```
69235

70236
### **...**

‎solution/0200-0299/0207.Course Schedule/README_EN.md

Lines changed: 166 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -42,21 +42,185 @@ To take course 1 you should have finished course 0, and to take course 0 you sho
4242
<li>All the pairs prerequisites[i] are <strong>unique</strong>.</li>
4343
</ul>
4444

45-
4645
## Solutions
4746

4847
<!-- tabs:start -->
4948

5049
### **Python3**
5150

5251
```python
53-
52+
class Solution:
53+
def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
54+
edges = collections.defaultdict(list)
55+
indegree = [0] * numCourses
56+
for i, j in prerequisites:
57+
edges[j].append(i)
58+
indegree[i] += 1
59+
q = collections.deque()
60+
for i in range(numCourses):
61+
if indegree[i] == 0:
62+
q.append(i)
63+
cnt = 0
64+
while q:
65+
i = q.popleft()
66+
cnt += 1
67+
for j in edges[i]:
68+
indegree[j] -= 1
69+
if indegree[j] == 0:
70+
q.append(j)
71+
return cnt == numCourses
5472
```
5573

5674
### **Java**
5775

5876
```java
77+
class Solution {
78+
public boolean canFinish(int numCourses, int[][] prerequisites) {
79+
List<Integer>[] edges = new List[numCourses];
80+
for (int i = 0; i < numCourses; ++i) {
81+
edges[i] = new ArrayList<>();
82+
}
83+
int[] indegree = new int[numCourses];
84+
for (int[] p : prerequisites) {
85+
edges[p[1]].add(p[0]);
86+
++indegree[p[0]];
87+
}
88+
Queue<Integer> q = new LinkedList<>();
89+
for (int i = 0; i < numCourses; ++i) {
90+
if (indegree[i] == 0) {
91+
q.offer(i);
92+
}
93+
}
94+
int cnt = 0;
95+
while (!q.isEmpty()) {
96+
int i = q.poll();
97+
++cnt;
98+
for (int j : edges[i]) {
99+
--indegree[j];
100+
if (indegree[j] == 0) {
101+
q.offer(j);
102+
}
103+
}
104+
}
105+
return cnt == numCourses;
106+
}
107+
}
108+
```
109+
110+
### **C++**
111+
112+
```cpp
113+
class Solution {
114+
public:
115+
bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
116+
vector<vector<int>> edges(numCourses);
117+
vector<int> indegree(numCourses);
118+
for (auto p : prerequisites)
119+
{
120+
edges[p[1]].push_back(p[0]);
121+
++indegree[p[0]];
122+
}
123+
queue<int> q;
124+
for (int i = 0; i < numCourses; ++i)
125+
{
126+
if (indegree[i] == 0) q.push(i);
127+
}
128+
int cnt = 0;
129+
while (!q.empty())
130+
{
131+
int i = q.front();
132+
q.pop();
133+
++cnt;
134+
for (int j : edges[i])
135+
{
136+
--indegree[j];
137+
if (indegree[j] == 0) q.push(j);
138+
}
139+
}
140+
return cnt == numCourses;
141+
}
142+
};
143+
```
144+
145+
### **Go**
146+
147+
```go
148+
func canFinish(numCourses int, prerequisites [][]int) bool {
149+
edges := make([][]int, numCourses)
150+
indegree := make([]int, numCourses)
151+
for _, p := range prerequisites {
152+
edges[p[1]] = append(edges[p[1]], p[0])
153+
indegree[p[0]]++
154+
}
155+
var q []int
156+
for i := 0; i < numCourses; i++ {
157+
if indegree[i] == 0 {
158+
q = append(q, i)
159+
}
160+
}
161+
cnt := 0
162+
for len(q) > 0 {
163+
i := q[0]
164+
q = q[1:]
165+
cnt++
166+
for _, j := range edges[i] {
167+
indegree[j]--
168+
if indegree[j] == 0 {
169+
q = append(q, j)
170+
}
171+
}
172+
}
173+
return cnt == numCourses
174+
}
175+
```
59176

177+
### **C#**
178+
179+
```cs
180+
using System.Collections.Generic;
181+
182+
public class Solution {
183+
public bool CanFinish(int numCourses, int[][] prerequisites) {
184+
var indegree = new int[numCourses];
185+
var edgeCount = prerequisites.Length;
186+
var edge = new List<int>[numCourses];
187+
for (var i = 0; i < edgeCount; ++i)
188+
{
189+
var child = prerequisites[i][0];
190+
var parent = prerequisites[i][1];
191+
if (edge[parent] == null)
192+
{
193+
edge[parent] = new List<int>();
194+
}
195+
edge[parent].Add(child);
196+
++indegree[child];
197+
}
198+
199+
var queue = new Queue<int>();
200+
for (var i = 0; i < numCourses; ++i)
201+
{
202+
if (indegree[i] == 0) queue.Enqueue(i);
203+
}
204+
205+
var count = 0;
206+
while (queue.Count > 0)
207+
{
208+
var node = queue.Dequeue();
209+
++count;
210+
if (edge[node] != null)
211+
{
212+
foreach (var next in edge[node])
213+
{
214+
if (--indegree[next] == 0)
215+
{
216+
queue.Enqueue(next);
217+
}
218+
}
219+
}
220+
}
221+
return count == numCourses;
222+
}
223+
}
60224
```
61225

62226
### **...**

0 commit comments

Comments
 (0)