Course Schedule IV

Course Schedule IV - Problem

Imagine you're planning your college course schedule! 🎓 You have numCourses courses numbered from 0 to numCourses - 1, and some courses have prerequisites that must be completed first.

You're given an array prerequisites where prerequisites[i] = [ai, bi] means you must complete course ai before taking course bi. For example, [0, 1] means course 0 is required before course 1.

Here's the tricky part: Prerequisites can be indirect! If course A is required for course B, and course B is required for course C, then course A is also required for course C (transitivity).

You need to answer multiple queries where each query [u, v] asks: "Is course u a prerequisite of course v?"

Goal: Return a boolean array where each element answers the corresponding query efficiently.

Input & Output

example_1.py — Basic Prerequisites

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

› Output: [false, true]

💡 Note: Course 1 is a prerequisite of course 0, but course 0 is not a prerequisite of course 1. So [0,1] returns false and [1,0] returns true.

example_2.py — Transitive Prerequisites

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

› Output: [true, true]

💡 Note: Course 1 is directly a prerequisite of both courses 0 and 2. The transitive relationship 1→2→0 also makes 1 a prerequisite of 0.

example_3.py — No Prerequisites

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

› Output: [false, false, false]

💡 Note: No prerequisites are given, so no course is a prerequisite of any other course. All queries return false.

Constraints

2 ≤ numCourses ≤ 100
0 ≤ prerequisites.length ≤ (numCourses * (numCourses - 1) / 2)
prerequisites[i].length == 2
0 ≤ a_i, b_i ≤ numCourses - 1
a_i ≠ b_i
All the pairs [a_i, b_i] are unique
The prerequisites graph has no cycles
1 ≤ queries.length ≤ 10⁴
0 ≤ u_j, v_j ≤ numCourses - 1
u_j ≠ v_j

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 25

The optimal approach uses Floyd-Warshall algorithm to precompute all transitive prerequisite relationships in O(V³) time. This creates a 2D boolean matrix allowing O(1) query lookup, making it ideal when handling many queries. For fewer queries, simple DFS per query might be more practical due to lower space complexity.

Common Approaches

✓ One Pass Hash

⏱️ Time: N/A Space: N/A

Floyd-Warshall All-Pairs Reachability

⏱️ Time: O(V³ + Q) Space: O(V²)

Use the Floyd-Warshall algorithm to precompute all transitive prerequisite relationships. This creates a 2D boolean matrix where matrix[i][j] indicates if course i is a prerequisite of course j. After preprocessing, each query is answered in O(1) time.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

static bool isPrereq[100][100];

void checkIfPrerequisite(int numCourses, int prerequisites[][2], int prereqSize, int queries[][2], int querySize, bool* result) {
    // Initialize adjacency matrix
    for (int i = 0; i < numCourses; i++) {
        for (int j = 0; j < numCourses; j++) {
            isPrereq[i][j] = false;
        }
    }
    
    // Initialize direct prerequisites
    for (int i = 0; i < prereqSize; i++) {
        isPrereq[prerequisites[i][0]][prerequisites[i][1]] = true;
    }
    
    // Floyd-Warshall to find all transitive prerequisites
    for (int k = 0; k < numCourses; k++) {
        for (int i = 0; i < numCourses; i++) {
            for (int j = 0; j < numCourses; j++) {
                isPrereq[i][j] = isPrereq[i][j] || (isPrereq[i][k] && isPrereq[k][j]);
            }
        }
    }
    
    // Answer queries
    for (int i = 0; i < querySize; i++) {
        result[i] = isPrereq[queries[i][0]][queries[i][1]];
    }
}

int parseArray(char* str, int arr[][2]) {
    int count = 0;
    if (strcmp(str, "[]") == 0) {
        return 0;
    }
    
    char* ptr = str;
    while (*ptr && *ptr != '[') ptr++; // Find first '['
    if (!*ptr) return 0;
    ptr++; // Skip first '['
    
    while (*ptr) {
        if (*ptr == '[') {
            ptr++; // Skip '['
            
            // Parse first number
            int num1 = 0;
            while (*ptr >= '0' && *ptr <= '9') {
                num1 = num1 * 10 + (*ptr - '0');
                ptr++;
            }
            
            // Skip comma
            while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
            if (*ptr == ',') ptr++;
            
            // Parse second number
            int num2 = 0;
            while (*ptr >= '0' && *ptr <= '9') {
                num2 = num2 * 10 + (*ptr - '0');
                ptr++;
            }
            
            arr[count][0] = num1;
            arr[count][1] = num2;
            count++;
            
            // Skip to next '[' or end
            while (*ptr && *ptr != '[' && *ptr != '\0') ptr++;
        } else {
            ptr++;
        }
    }
    
    return count;
}

int main() {
    int numCourses;
    scanf("%d\n", &numCourses);
    
    char prereqLine[10000], queryLine[10000];
    fgets(prereqLine, sizeof(prereqLine), stdin);
    fgets(queryLine, sizeof(queryLine), stdin);
    
    // Remove newlines
    prereqLine[strcspn(prereqLine, "\n")] = 0;
    queryLine[strcspn(queryLine, "\n")] = 0;
    
    int prerequisites[5000][2], queries[10000][2];
    int prereqSize = parseArray(prereqLine, prerequisites);
    int querySize = parseArray(queryLine, queries);
    
    bool* result = malloc(querySize * sizeof(bool));
    checkIfPrerequisite(numCourses, prerequisites, prereqSize, queries, querySize, result);
    
    printf("[");
    for (int i = 0; i < querySize; i++) {
        if (i > 0) printf(", ");
        printf("%s", result[i] ? "true" : "false");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.4K Views

Medium Frequency

~18 min Avg. Time

985 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