Codestin Search App

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

Understanding the Visualization

Model as Graph

Each course is a node, prerequisites are directed edges

Find Transitive Closure

Use Floyd-Warshall to find all indirect prerequisite relationships

Answer Queries

Look up precomputed relationships in constant time

Key Takeaway

🎯 Key Insight: By precomputing all transitive relationships using Floyd-Warshall, we transform multiple expensive graph traversals into simple matrix lookups, achieving optimal performance for multiple queries.

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

Approach	Time	Space	Notes
✓ Floyd-Warshall All-Pairs Reachability	O(V³ + Q)	O(V²)	Precompute all prerequisite relationships using Floyd-Warshall algorithm

Floyd-Warshall All-Pairs Reachability — Algorithm Steps

Initialize reachability matrix with direct prerequisites
Apply Floyd-Warshall to find all transitive relationships
For each intermediate course k, update matrix[i][j] if both matrix[i][k] and matrix[k][j] are true
Answer queries by looking up the precomputed matrix

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Matrix

Create boolean matrix with direct prerequisites

Intermediate Course 0

Update all pairs using course 0 as intermediate

Intermediate Course 1

Update all pairs using course 1 as intermediate

Final Matrix

Matrix contains all transitive prerequisite relationships

Code -

solution.c — C

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

bool* checkIfPrerequisite(int numCourses, int** prerequisites, int prerequisitesSize, int** queries, int queriesSize, int* returnSize) {
    // Initialize reachability matrix
    bool** isPrereq = (bool**)malloc(numCourses * sizeof(bool*));
    for (int i = 0; i < numCourses; i++) {
        isPrereq[i] = (bool*)calloc(numCourses, sizeof(bool));
    }
    
    // Mark direct prerequisites
    for (int i = 0; i < prerequisitesSize; i++) {
        isPrereq[prerequisites[i][0]][prerequisites[i][1]] = true;
    }
    
    // Floyd-Warshall to find all transitive relationships
    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]);
            }
        }
    }
    
    bool* result = (bool*)malloc(queriesSize * sizeof(bool));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        result[i] = isPrereq[queries[i][0]][queries[i][1]];
    }
    
    // Free memory
    for (int i = 0; i < numCourses; i++) {
        free(isPrereq[i]);
    }
    free(isPrereq);
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(V³ + Q)

O(V³) for Floyd-Warshall preprocessing plus O(1) per query

✓ Linear Growth

Space Complexity

O(V²)

2D matrix to store all pairwise reachability relationships

✓ 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Floyd-Warshall All-Pairs Reachability — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler