feat(work): add Course Schedule II solution and clean up Course Schedule I implementation

apps/docs/content/topological-sort/207-course-schedule.mdx

@@ -31,4 +31,26 @@ sidebar:
 ```py
 class Solution:
     def canFinish(self, numCourses: int, prerequisites: list[list[int]]) -> bool:
+        indegree = [0] * numCourses
+        adj = [[] for x in range(numCourses)]
+        for prereq in prerequisites:
+            adj[prereq[1]].append(prereq[0])
+            indegree[prereq[0]] += 1
+
+        queue = []
+
+        for i in range(numCourses):
+            if indegree[i] == 0:
+                queue.append(i)
+
+        visited = 0
+        while queue:
+            node = queue.pop(0)
+            visited += 1
+            for neighbor in adj[node]:
+                indegree[neighbor] -= 1
+                if indegree[neighbor] == 0:
+                    queue.append(neighbor)
+
+        return numCourses == visited
 ```

apps/docs/content/topological-sort/210-course-schedule-ii.mdx

@@ -0,0 +1,39 @@
+---
+title: '210. Course Schedule II'
+description: There are a total of numCourses courses you have to take, labeled from 0 to numCourses - 1. You are given an array prerequisites where prerequisites[i] = [ai, bi] indicates that you must take course bi first if you want to take course ai
+sidebar:
+  label: 'Course Schedule II'
+  badge: 'Medium'
+---
+
+<Badge variant="accent">Depth-First Search</Badge>
+
+### Example 1:
+- Input: `numCourses = 2, prerequisites = [[1,0]]`
+- Output: `[0,1]`
+- Explanation: There are a total of `2` courses to take. To take course `1` you should have finished course `0`. So the correct course order is `[0,1]`.
+
+### Example 2:
+- Input: `numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]`
+- Output: `[0,2,1,3]`
+- Explanation: There are a total of `4` courses to take. To take course `3` you should have finished both courses `1` and `2`. Both courses `1` and `2` should be taken after you finished course `0`. So one correct course order is `[0,1,2,3]`. Another correct ordering is `[0,2,1,3]`.
+
+### Example 3:
+- Input: `numCourses = 1, prerequisites = []`
+- Output: `[0]`
+
+### Constraints:
+
+- `1 <= numCourses <= 2000`
+- `0 <= prerequisites.length <= numCourses * (numCourses - 1)`
+- `prerequisites[i].length == 2`
+- `0 <= ai, bi < numCourses`
+- `ai != bi`
+- All the pairs [ai, bi] are distinct.
+
+## Solution
+
+```py
+class Solution:
+    def findOrder(self, numCourses: int, prerequisites: list[list[int]]) -> list[int]:
+```

work/1/Medium/Depth-First Search/207.course-schedule.py

@@ -47,6 +47,28 @@ Constraints:
         • All the pairs prerequisites[i] are unique.
 """
 
+
 class Solution:
     def canFinish(self, numCourses: int, prerequisites: list[list[int]]) -> bool:
+        indegree = [0] * numCourses
+        adj = [[] for x in range(numCourses)]
+        for prereq in prerequisites:
+            adj[prereq[1]].append(prereq[0])
+            indegree[prereq[0]] += 1
 
+        queue = []
+
+        for i in range(numCourses):
+            if indegree[i] == 0:
+                queue.append(i)
+
+        visited = 0
+        while queue:
+            node = queue.pop(0)
+            visited += 1
+            for neighbor in adj[node]:
+                indegree[neighbor] -= 1
+                if indegree[neighbor] == 0:
+                    queue.append(neighbor)
+
+        return numCourses == visited

work/1/Medium/Depth-First Search/210.course-schedule-ii.py

@@ -0,0 +1,64 @@
+"""
+210. Course Schedule II
+Difficulty: Medium
+https://leetcode.com/problems/course-schedule-ii/
+
+──────────────────────────────────────────────────
+
+There are a total of numCourses courses you have to take, labeled
+from 0 to numCourses - 1. You are given an array prerequisites where
+prerequisites[i] = [ai, bi] indicates that you must take course bi
+first if you want to take course ai.
+
+• For example, the pair [0, 1], indicates that to take course 0 you
+have to first take course 1.
+
+Return the ordering of courses you should take to finish all courses.
+If there are many valid answers, return any of them. If it is
+impossible to finish all courses, return an empty array.
+
+ 
+
+Example 1:
+
+Input: numCourses = 2, prerequisites = [[1,0]]
+Output: [0,1]
+Explanation: There are a total of 2 courses to take. To take course 1
+you should have finished course 0. So the correct course order is
+[0,1].
+
+Example 2:
+
+Input: numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
+Output: [0,2,1,3]
+Explanation: There are a total of 4 courses to take. To take course 3
+you should have finished both courses 1 and 2. Both courses 1 and 2
+should be taken after you finished course 0.
+So one correct course order is [0,1,2,3]. Another correct ordering is
+[0,2,1,3].
+
+Example 3:
+
+Input: numCourses = 1, prerequisites = []
+Output: [0]
+
+ 
+
+Constraints:
+
+	• 1 <= numCourses <= 2000
+
+	• 0 <= prerequisites.length <= numCourses * (numCourses - 1)
+
+	• prerequisites[i].length == 2
+
+	• 0 <= ai, bi < numCourses
+
+	• ai != bi
+
+	• All the pairs [ai, bi] are distinct.
+"""
+
+class Solution:
+    def findOrder(self, numCourses: int, prerequisites: list[list[int]]) -> list[int]:
+