feat: refactored docs structure

apps/docs/content/(04-relational)/topological-sort/(problems)/207_course-schedule.mdx

@@ -1,62 +0,0 @@
----
-title: '207. Course Schedule'
-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
-icon: dot
-topics:
-  - { name: "Depth-First Search", slug: "depth-first-search" }
-  - { name: "Breadth-First Search", slug: "breadth-first-search" }
-  - { name: "Graph Theory", slug: "graph" }
-  - { name: "Topological Sort", slug: "topological-sort" }
-  - { name: "Directed Acyclic Graph", slug: "directed-acyclic-graph" }
-issue: "https://github.com/prdlk/leetcode/issues/142"
-sidebar:
-  label: 'Course Schedule'
-  badge: 'Medium'
----
-
-### Example 1:
-- Input: `numCourses = 2, prerequisites = [[1,0]]`
-- Output: `true`
-- Explanation: There are a total of `2` courses to take. To take course `1` you should have finished course `0`. So it is possible.
-
-### Example 2:
-- Input: `numCourses = 2, prerequisites = [[1,0],[0,1]]`
-- Output: `false`
-- Explanation: There are a total of `2` courses to take. To take course `1` you should have finished course `0`, and to take course `0` you should also have finished course `1`. So it is impossible.
-
-### Constraints:
-
-- `1 <= numCourses <= 2000`
-- `0 <= prerequisites.length <= 5000`
-- `prerequisites[i].length == 2`
-- `0 <= ai, bi < numCourses`
-- All the pairs `prerequisites[i]` are unique.
-
-## Solution
-
-```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/(04-relational)/topological-sort/(problems)/210_course-schedule-ii.mdx

@@ -1,76 +0,0 @@
----
-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
-icon: dot
-topics:
-  - { name: "Depth-First Search", slug: "depth-first-search" }
-  - { name: "Breadth-First Search", slug: "breadth-first-search" }
-  - { name: "Graph Theory", slug: "graph" }
-  - { name: "Topological Sort", slug: "topological-sort" }
-issue: "https://github.com/prdlk/leetcode/issues/143"
-sidebar:
-  label: 'Course Schedule II'
-  badge: 'Medium'
----
-
-### 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]:
-        prereq = {c: [] for c in range(numCourses)}
-        for crs, pre in prerequisites:
-            prereq[crs].append(pre)
-
-        # course has 3 possible states:
-        # visited -> crs has been added to output
-        # visiting -> crs not added to output, but added to cycle
-        # unvisited -> crs not added to output nor cycle
-        output = []
-        visit, cycle = set(), set()
-
-        def dfs(crs):
-            if crs in cycle:
-                return False
-            if crs in visit:
-                return True
-
-            cycle.add(crs)
-            for pre in prereq[crs]:
-                if dfs(pre) == False:
-                    return False
-
-            cycle.remove(crs)
-            visit.add(crs)
-            output.append(crs)
-            return True
-
-        for c in range(numCourses):
-            if dfs(c) == False:
-                return []
-
-        return output
-```