Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit b3e1475

Browse files
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)

AltStyle によって変換されたページ (->オリジナル) /