Course Schedule II

Course Schedule II - Problem

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] = [a_i, b_i] indicates that you must take course b_i first if you want to take course a_i.

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.

Input & Output

Example 1 — Basic Prerequisites

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

› Output: [0,1]

💡 Note: Course 0 has no prerequisites, so take it first. Course 1 requires course 0, so take it after completing course 0.

Example 2 — Multiple Prerequisites

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

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

💡 Note: Course 0 first (no prerequisites), then courses 1 and 2 (both depend on 0), finally course 3 (depends on both 1 and 2).

Example 3 — Impossible (Cycle)

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

› Output: []

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

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.

Visualization

Tap to expand

Asked in

f Facebook 42 a Amazon 38 G Google 35 M Microsoft 28 U Uber 25

The key insight is to use topological sorting to order courses based on dependencies. BFS (Kahn's algorithm) is most intuitive: count prerequisites (indegrees), start with courses having no prerequisites, and process level by level while reducing dependency counts. Time: O(V + E), Space: O(V + E).

Common Approaches

✓ BFS - Kahn's Algorithm

⏱️ Time: O(V + E) Space: O(V + E)

Build a graph and count indegrees (prerequisites) for each course. Start with courses having no prerequisites, process them level by level, and reduce indegrees of dependent courses.

Brute Force - Try All Orders

⏱️ Time: O(n! × p) Space: O(n)

Generate every possible permutation of courses and check if each ordering respects all prerequisite constraints. Return the first valid ordering found, or empty array if none exists.

DFS - Topological Sort

⏱️ Time: O(V + E) Space: O(V + E)

Build adjacency list from prerequisites. Use DFS to visit each course, detecting cycles using color coding (white/gray/black). Add courses to result in post-order (after visiting all dependencies).

BFS - Kahn's Algorithm — Algorithm Steps

Build adjacency list and count indegrees
Add all courses with 0 indegree to queue
Process queue: add course to result, reduce neighbors' indegrees
If processed all courses, return result; else return empty array

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Graph & Count Indegrees

Create adjacency list and count prerequisites for each course

Start with Zero Indegree

Add all courses with no prerequisites to queue

Process Level by Level

Remove courses from queue, add to result, update indegrees

Code -

solution.c — C

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

int* solution(int numCourses, int** prerequisites, int prerequisitesSize, int* returnSize) {
    *returnSize = 0;
    
    // Build adjacency list and indegree count
    int** graph = (int**)malloc(numCourses * sizeof(int*));
    int* graphSize = (int*)calloc(numCourses, sizeof(int));
    int* indegree = (int*)calloc(numCourses, sizeof(int));
    
    // Count edges for each node to allocate memory
    for (int i = 0; i < prerequisitesSize; i++) {
        graphSize[prerequisites[i][1]]++;
    }
    
    // Allocate memory for adjacency lists
    for (int i = 0; i < numCourses; i++) {
        if (graphSize[i] > 0) {
            graph[i] = (int*)malloc(graphSize[i] * sizeof(int));
        } else {
            graph[i] = NULL;
        }
    }
    
    // Reset graphSize to use as index
    memset(graphSize, 0, numCourses * sizeof(int));
    
    // Build graph and calculate indegrees
    for (int i = 0; i < prerequisitesSize; i++) {
        int course = prerequisites[i][0];
        int pre = prerequisites[i][1];
        graph[pre][graphSize[pre]++] = course;
        indegree[course]++;
    }
    
    // Queue for BFS
    int* queue = (int*)malloc(numCourses * sizeof(int));
    int front = 0, rear = 0;
    
    // Add courses with no prerequisites to queue
    for (int i = 0; i < numCourses; i++) {
        if (indegree[i] == 0) {
            queue[rear++] = i;
        }
    }
    
    int* result = (int*)malloc(numCourses * sizeof(int));
    int count = 0;
    
    // Process queue
    while (front < rear) {
        int course = queue[front++];
        result[count++] = course;
        
        // Reduce indegree of dependent courses
        for (int i = 0; i < graphSize[course]; i++) {
            int neighbor = graph[course][i];
            indegree[neighbor]--;
            if (indegree[neighbor] == 0) {
                queue[rear++] = neighbor;
            }
        }
    }
    
    // Clean up
    for (int i = 0; i < numCourses; i++) {
        if (graph[i]) free(graph[i]);
    }
    free(graph);
    free(graphSize);
    free(indegree);
    free(queue);
    
    if (count == numCourses) {
        *returnSize = numCourses;
        return result;
    } else {
        // Cycle detected - return empty array
        free(result);
        *returnSize = 0;
        return (int*)malloc(0);  // Return valid empty array instead of NULL
    }
}

int main() {
    int numCourses;
    scanf("%d", &numCourses);
    
    // Read the prerequisites line
    char line[10000];
    scanf(" %[^\n]", line);  // Read entire line including spaces
    
    // Parse prerequisites array
    int** prerequisites = NULL;
    int prerequisitesSize = 0;
    
    // Handle empty array case
    if (strcmp(line, "[]") == 0) {
        prerequisitesSize = 0;
    } else {
        // Count pairs by counting opening brackets
        for (int i = 0; line[i]; i++) {
            if (line[i] == '[' && i > 0) prerequisitesSize++;  // Skip the first '['
        }
        
        if (prerequisitesSize > 0) {
            prerequisites = (int**)malloc(prerequisitesSize * sizeof(int*));
            for (int i = 0; i < prerequisitesSize; i++) {
                prerequisites[i] = (int*)malloc(2 * sizeof(int));
            }
            
            // Parse the array
            int idx = 0;
            char* ptr = line + 1;  // Skip first '['
            
            while (*ptr && idx < prerequisitesSize) {
                if (*ptr == '[') {
                    ptr++;  // Skip '['
                    prerequisites[idx][0] = strtol(ptr, &ptr, 10);
                    if (*ptr == ',') ptr++;  // Skip ','
                    prerequisites[idx][1] = strtol(ptr, &ptr, 10);
                    while (*ptr && *ptr != ']') ptr++;  // Find ']'
                    if (*ptr == ']') ptr++;  // Skip ']'
                    idx++;
                }
                ptr++;
            }
        }
    }
    
    int returnSize;
    int* result = solution(numCourses, prerequisites, prerequisitesSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    // Clean up
    if (result) free(result);
    for (int i = 0; i < prerequisitesSize; i++) {
        free(prerequisites[i]);
    }
    if (prerequisites) free(prerequisites);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(V + E)

Visit each course once and each prerequisite edge once

✓ Linear Growth

Space Complexity

O(V + E)

Adjacency list stores all edges, queue stores up to V courses

✓ Linear Space

89.2K Views

High Frequency

~25 min Avg. Time

2.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

Constraints

Visualization

Related Problems

Common Approaches

BFS - Kahn's Algorithm — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler