Learning Path Recommendation Engine

1. Graph model and invalid-data validation

Scenario: you're building the algorithm behind a 'what should I learn next' recommendation feature. Model courses as graph nodes and prerequisites as directed edges, using an adjacency list (Map<string, string[]>). Write validateGraph(courses, prerequisites) that rejects (returns a specific error, does not throw an uncaught exception) invalid input: a prerequisite referencing a course ID that doesn't exist in courses, and a course listed as its own prerequisite (a trivial self-cycle).

• Courses and prerequisites are modeled as an adjacency-list graph, not an adjacency matrix
• validateGraph correctly rejects a prerequisite referencing an unknown course ID
• validateGraph correctly rejects a course listed as its own direct prerequisite

2. Cycle detection

Implement hasCycle(graph) using DFS with a visited set AND an in-progress ('currently on this path') set, correctly distinguishing a genuine cycle from simply revisiting an already-fully-processed node through a different path (which is normal and NOT a cycle in a DAG). Test it against a genuinely cyclic prerequisite chain (A requires B, B requires C, C requires A) and a non-cyclic graph where two different courses share a common prerequisite (which must NOT be flagged as a cycle).

• hasCycle correctly detects a genuine multi-step cycle (A -> B -> C -> A)
• hasCycle does NOT falsely flag a diamond-shaped dependency (two courses sharing one common prerequisite) as a cycle
• hasCycle correctly reports false for a graph with no edges at all

3. Valid learning order (topological sort)

Implement computeLearningOrder(graph) returning an array of course IDs in an order where every prerequisite appears before the course that depends on it. Use either a BFS-based approach (repeatedly removing nodes with no remaining unmet prerequisites) or a DFS-based approach (postorder, then reverse) — document which you chose and why in a code comment. The function must throw a clear, specific error if the graph contains a cycle (reuse hasCycle from milestone 2), since no valid order exists in that case.

• computeLearningOrder returns an order where every prerequisite precedes every course that depends on it, verified across at least 3 different graph shapes
• computeLearningOrder throws a clear, specific error for a cyclic graph rather than returning an incomplete or incorrect order
• A code comment explains and justifies the BFS-or-DFS choice actually made

4. Priority-based recommendation

Using a min-heap (or an equivalent priority-queue implementation from this course's heaps lesson), implement recommendNext(graph, completedCourseIds, priorities) returning the single highest-priority course whose prerequisites are ALL already in completedCourseIds — i.e. among every course that's currently eligible to start, pick the one with the best (lowest) priority number. Document this function's time complexity in a comment, in terms of the number of courses and edges.

• recommendNext correctly identifies the set of currently-eligible courses (every prerequisite already completed)
• Among eligible courses, recommendNext correctly returns the one with the best priority using a heap-based selection, not a linear scan re-sorted from scratch on every call
• A code comment states the function's time complexity and the reasoning behind it

5. Deterministic tests for every required edge case

Write a deterministic test suite (reusing this course's runner-based exercise pattern) covering: a valid multi-course graph, a graph with an invalid prerequisite reference, a self-cycle, a multi-step cycle, a diamond dependency (correctly NOT flagged as a cycle), an empty graph, and at least one recommendNext call where multiple courses are simultaneously eligible (verifying the priority tie-break is genuinely being used, not just the first eligible course found).

• At least 8 deterministic test cases exist, covering every scenario listed above
• Every test asserts a specific, exact expected result — not just 'it didn't throw'
• All tests pass when run