Course Schedule II - Practice Coding Problems

Course Schedule II - Problem

Course Schedule II is a classic graph problem that challenges you to find a valid ordering of courses based on their prerequisites.

You're a university student planning your academic journey! You have numCourses courses labeled from 0 to numCourses - 1, and an array of prerequisites where each prerequisites[i] = [a, b] means you must complete course b before taking course a.

Your goal is to return any valid ordering of courses that allows you to complete all of them. If it's impossible to finish all courses (due to circular dependencies), return an empty array.

For example, if you have courses [0, 1] with prerequisite [[0, 1]], you must take course 1 first, then course 0. The valid order would be [1, 0].

Input & Output

example_1.py — Basic Course Schedule

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

› Output: [0, 1]

💡 Note: There are 2 courses. Course 1 depends on course 0, so we must take course 0 first, then course 1. One valid order is [0, 1].

example_2.py — Multiple Prerequisites

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

› Output: [0, 1, 2, 3] or [0, 2, 1, 3]

💡 Note: Course 0 has no prerequisites. Courses 1 and 2 both depend on 0. Course 3 depends on both 1 and 2. Valid orders include [0,1,2,3] or [0,2,1,3].

example_3.py — Circular Dependency

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

› Output: []

💡 Note: Course 1 requires course 0, and course 0 requires course 1. This creates a circular dependency, making it impossible to complete all courses.

Visualization

Tap to expand

Understanding the Visualization

Map Dependencies

Create a prerequisite map showing which courses unlock other courses

Find Starting Courses

Identify courses with no prerequisites - these can be taken in the first semester

Plan Semester by Semester

Each semester, take available courses and see what new courses become available

Check for Impossible Situations

If we can't complete all courses, there must be circular dependencies

Key Takeaway

🎯 Key Insight: Course scheduling is topological sorting on a directed graph. Use in-degree counting (Kahn's algorithm) to process courses level by level, naturally detecting impossible circular dependencies.

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Each course (vertex) and prerequisite (edge) is processed exactly once

✓ Linear Growth

Space Complexity

O(V + E)

Space for adjacency list O(E), in-degree array O(V), and queue O(V)

✓ Linear Space

Constraints

1 ≤ numCourses ≤ 2000
0 ≤ prerequisites.length ≤ numCourses × (numCourses - 1)
prerequisites[i].length == 2
0 ≤ a_i, b_i < numCourses
a_i ≠ b_i
All the pairs [a_i, b_i] are distinct

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses Kahn's Algorithm (BFS topological sort) to process courses level by level. We maintain an in-degree count for each course and start with courses having zero prerequisites. As we process each course, we reduce the in-degree of dependent courses and add newly available courses to the queue. This approach naturally detects cycles and runs in O(V + E) time.

Common Approaches

Approach	Time	Space	Notes
✓ DFS with Topological Sort	O(V + E)	O(V + E)	Build adjacency graph first, then use DFS to detect cycles and build topological order
Brute Force (Try All Permutations)	O(n! × m)	O(n)	Generate all possible course orderings and check which one satisfies prerequisites
Kahn's Algorithm (BFS Topological Sort)	O(V + E)	O(V + E)	Use BFS with in-degree tracking to build topological order in one pass

DFS with Topological Sort — Algorithm Steps

Build adjacency list from prerequisites array
Initialize color array: 0=white (unvisited), 1=gray (visiting), 2=black (visited)
For each unvisited course, perform DFS
In DFS, mark node as gray, visit all neighbors, then mark as black
If we encounter a gray node during DFS, we found a cycle
Add courses to result in post-order (after visiting all dependencies)

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph

Create adjacency list from prerequisites

DFS Traversal

Use three colors: white (unvisited), gray (visiting), black (visited)

Cycle Detection

If we encounter a gray node, we found a cycle

Post-order Result

Add nodes to result after visiting all dependencies

Code -

solution.c — C

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

typedef struct {
    int* data;
    int size;
    int capacity;
} IntArray;

IntArray* createIntArray() {
    IntArray* arr = (IntArray*)malloc(sizeof(IntArray));
    arr->capacity = 10;
    arr->size = 0;
    arr->data = (int*)malloc(arr->capacity * sizeof(int));
    return arr;
}

void pushIntArray(IntArray* arr, int val) {
    if (arr->size >= arr->capacity) {
        arr->capacity *= 2;
        arr->data = (int*)realloc(arr->data, arr->capacity * sizeof(int));
    }
    arr->data[arr->size++] = val;
}

IntArray** graph;
int* color;
IntArray* result;

bool dfs(int node) {
    if (color[node] == 1) return false; // Cycle
    if (color[node] == 2) return true;  // Already processed
    
    color[node] = 1; // Mark as visiting
    
    for (int i = 0; i < graph[node]->size; i++) {
        if (!dfs(graph[node]->data[i])) return false;
    }
    
    color[node] = 2; // Mark as visited
    pushIntArray(result, node);
    return true;
}

int* findOrder(int numCourses, int** prerequisites, int prerequisitesSize, int* returnSize) {
    // Build adjacency list
    graph = (IntArray**)malloc(numCourses * sizeof(IntArray*));
    for (int i = 0; i < numCourses; i++) {
        graph[i] = createIntArray();
    }
    
    for (int i = 0; i < prerequisitesSize; i++) {
        pushIntArray(graph[prerequisites[i][1]], prerequisites[i][0]);
    }
    
    color = (int*)calloc(numCourses, sizeof(int));
    result = createIntArray();
    
    // Try DFS from each unvisited node
    for (int i = 0; i < numCourses; i++) {
        if (color[i] == 0 && !dfs(i)) {
            *returnSize = 0;
            return NULL; // Cycle detected
        }
    }
    
    // Reverse result
    int* order = (int*)malloc(result->size * sizeof(int));
    for (int i = 0; i < result->size; i++) {
        order[i] = result->data[result->size - 1 - i];
    }
    
    *returnSize = result->size;
    return order;
}

int main() {
    int returnSize;
    int* prereq1 = (int*)malloc(2 * sizeof(int));
    prereq1[0] = 1; prereq1[1] = 0;
    int** prerequisites = &prereq1;
    
    int* result = findOrder(2, prerequisites, 1, &returnSize);
    
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    printf("\n");
    
    free(prereq1);
    if (result) free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

V is number of courses, E is number of prerequisites. Each node and edge visited once

✓ Linear Growth

Space Complexity

O(V + E)

Space for adjacency list O(E), recursion stack O(V), and auxiliary arrays O(V)

✓ Linear Space

Constraints

1 ≤ numCourses ≤ 2000
0 ≤ prerequisites.length ≤ numCourses × (numCourses - 1)
prerequisites[i].length == 2
0 ≤ a_i, b_i < numCourses
a_i ≠ b_i
All the pairs [a_i, b_i] are distinct

68.0K Views

High Frequency

~25 min Avg. Time

1.9K 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 with Topological Sort — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler