Course Schedule - Practice Coding Problems

Course Schedule - Problem

Imagine you're a college student planning your course schedule for graduation. You need to take numCourses different courses, numbered from 0 to numCourses - 1. However, some courses have prerequisites - you must complete certain courses before taking others.

You're given an array prerequisites where each element [a, b] means you must take course b before you can take course a. For example, [0, 1] means you need to complete course 1 first before taking course 0.

Your goal: Determine if it's possible to finish all courses without getting stuck in impossible prerequisite loops. Return true if you can complete all courses, false otherwise.

This is essentially asking: "Does the prerequisite dependency graph contain a cycle?" If there's a cycle, it's impossible to satisfy all prerequisites.

Input & Output

example_1.py — Basic Valid Case

$ Input: numCourses = 2, prerequisites = [[1,0]]

› Output: true

💡 Note: To take course 1, you need to complete course 0 first. This is possible: take course 0, then course 1.

example_2.py — Circular Dependency

$ Input: numCourses = 2, prerequisites = [[1,0],[0,1]]

› Output: false

💡 Note: Course 1 requires course 0, but course 0 also requires course 1. This creates a circular dependency that cannot be resolved.

example_3.py — Complex Valid Case

$ Input: numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]

› Output: true

💡 Note: Take courses in order: 0 → 1,2 → 3. Course 0 has no prerequisites, courses 1&2 need 0, course 3 needs both 1&2.

Visualization

Tap to expand

Understanding the Visualization

Model as Graph

Each course is a node, prerequisites are directed edges

Detect Cycles

Use DFS with three states to find circular dependencies

Return Result

No cycles = possible to complete all courses

Key Takeaway

🎯 Key Insight: Convert the course scheduling problem into cycle detection in a directed graph. If any cycle exists in the prerequisite dependencies, it's impossible to complete all courses.

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex once and traverse each edge once, where V=numCourses, E=prerequisites

✓ Linear Growth

Space Complexity

O(V + E)

Adjacency list storage plus recursion stack depth

✓ Linear Space

Constraints

1 ≤ numCourses ≤ 2000
0 ≤ prerequisites.length ≤ 5000
prerequisites[i].length == 2
0 ≤ a_i, b_i < numCourses
All the pairs prerequisites[i] are unique

Asked in

G Google 73 a Amazon 45 f Meta 38 ⊞ Microsoft 29 Apple 22

The optimal solution uses DFS cycle detection to solve this graph problem. We model courses as nodes and prerequisites as directed edges, then check if the resulting graph contains any cycles. A cycle would make it impossible to satisfy all prerequisites. The algorithm runs in O(V + E) time using a three-state approach: unvisited, visiting, and visited.

Common Approaches

Approach	Time	Space	Notes
✓ DFS Cycle Detection	O(V + E)	O(V + E)	Use Depth-First Search to detect cycles in the prerequisite dependency graph

DFS Cycle Detection — Algorithm Steps

Build adjacency list representation of the prerequisite graph
For each unvisited course, start a DFS traversal
Use three states: unvisited (0), visiting (1), visited (2)
If during DFS we encounter a course in 'visiting' state, we found a cycle
If no cycles are found after checking all courses, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from prerequisites

Start DFS

Mark current course as 'visiting' (gray)

Check Dependencies

If we encounter a 'visiting' course, cycle found!

Mark Visited

After exploring, mark course as 'visited' (black)

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct {
    int* courses;
    int size;
    int capacity;
} CourseList;

bool hasCycle(int course, CourseList* graph, int* states) {
    if (states[course] == 1) return true;  // Cycle detected
    if (states[course] == 2) return false; // Already visited
    
    states[course] = 1; // Mark as visiting
    
    for (int i = 0; i < graph[course].size; i++) {
        if (hasCycle(graph[course].courses[i], graph, states)) {
            return true;
        }
    }
    
    states[course] = 2; // Mark as visited
    return false;
}

bool canFinish(int numCourses, int prerequisites[][2], int prereqCount) {
    // Initialize graph
    CourseList* graph = (CourseList*)malloc(numCourses * sizeof(CourseList));
    for (int i = 0; i < numCourses; i++) {
        graph[i].courses = (int*)malloc(100 * sizeof(int));
        graph[i].size = 0;
        graph[i].capacity = 100;
    }
    
    // Build adjacency list
    for (int i = 0; i < prereqCount; i++) {
        int prereq = prerequisites[i][1];
        int course = prerequisites[i][0];
        graph[prereq].courses[graph[prereq].size++] = course;
    }
    
    int* states = (int*)calloc(numCourses, sizeof(int));
    
    for (int course = 0; course < numCourses; course++) {
        if (states[course] == 0 && hasCycle(course, graph, states)) {
            // Cleanup
            for (int i = 0; i < numCourses; i++) {
                free(graph[i].courses);
            }
            free(graph);
            free(states);
            return false;
        }
    }
    
    // Cleanup
    for (int i = 0; i < numCourses; i++) {
        free(graph[i].courses);
    }
    free(graph);
    free(states);
    return true;
}

int main() {
    int prerequisites[1][2] = {{1, 0}};
    printf("%s\n", canFinish(2, prerequisites, 1) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each vertex once and traverse each edge once, where V=numCourses, E=prerequisites

✓ Linear Growth

Space Complexity

O(V + E)

Adjacency list storage plus recursion stack depth

✓ Linear Space

Constraints

1 ≤ numCourses ≤ 2000
0 ≤ prerequisites.length ≤ 5000
prerequisites[i].length == 2
0 ≤ a_i, b_i < numCourses
All the pairs prerequisites[i] are unique

67.8K Views

High Frequency

~18 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

DFS Cycle Detection — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler