Codestin Search App

Parallel Courses II - Problem

Course Scheduling Optimization Challenge

Imagine you're a university student planning your course schedule efficiently! You have n courses numbered from 1 to n, but there's a catch - some courses have prerequisites that must be completed first.

You're given a list of prerequisite relationships in the relations array, where relations[i] = [prevCourse, nextCourse] means you must complete prevCourse before taking nextCourse.

Here's the constraint: you can only take at most k courses per semester, and you must have completed all prerequisites in previous semesters.

Your goal: Find the minimum number of semesters needed to complete all courses.

Example: With courses [1,2,3,4], relations [[2,1],[3,1],[1,4]], and k=2, you need 3 semesters: first take courses 2&3, then course 1, finally course 4.

Input & Output

example_1.py — Basic Case

$ Input: n = 4, relations = [[2,1],[3,1],[1,4]], k = 2

› Output: 3

💡 Note: Semester 1: Take courses 2 and 3 (no prerequisites). Semester 2: Take course 1 (prerequisites 2,3 satisfied). Semester 3: Take course 4 (prerequisite 1 satisfied). Total: 3 semesters.

example_2.py — Chain Dependencies

$ Input: n = 5, relations = [[2,1],[3,2],[4,3],[1,5]], k = 2

› Output: 4

💡 Note: Semester 1: Take courses 3,4. Semester 2: Take course 2. Semester 3: Take course 1. Semester 4: Take course 5. The chain dependencies force a specific order despite k=2.

example_3.py — Independent Courses

$ Input: n = 6, relations = [], k = 3

› Output: 2

💡 Note: No prerequisites means all courses are independent. Semester 1: Take any 3 courses. Semester 2: Take remaining 3 courses. Total: 2 semesters.

Constraints

1 ≤ n ≤ 15
1 ≤ k ≤ n
0 ≤ relations.length ≤ n × (n-1) / 2
relations[i].length = 2
1 ≤ prevCoursei, nextCoursei ≤ n
prevCoursei ≠ nextCoursei
All the pairs [prevCoursei, nextCoursei] are unique
The given graph is a valid DAG (no cycles)

Visualization

Tap to expand

Understanding the Visualization

Identify Available Skills

Find courses with no unfulfilled prerequisites (skills you can learn now)

Choose Skill Combination

Select up to k courses to take this semester (spend your skill points)

Unlock Dependencies

Completing courses unlocks new courses that depend on them

Progress to Next Level

Move to next semester with updated available courses

Optimize Path

Use DP to find the shortest path to unlock all skills

Key Takeaway

🎯 Key Insight: Use dynamic programming with bitmasks to efficiently track which courses are completed, while trying all valid combinations of available courses each semester to find the optimal scheduling path.

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 31

This problem requires finding the minimum semesters to complete all courses with prerequisite constraints and capacity limits. The optimal approach uses Dynamic Programming with Bitmasks to represent completion states and memoization to avoid redundant calculations. Each state represents which courses are completed, and we try all valid combinations of available courses (up to k) for the next semester. The key insight is using bitmask DP to efficiently explore the state space while respecting topological constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (BFS with State Enumeration)	O(3^n)	O(2^n)	Try all possible combinations of courses to take each semester using BFS
Dynamic Programming with Bitmask (Optimal)	O(2^n * n * C(n,k))	O(2^n)	Use DP with bitmask to represent states and find optimal semester count

Brute Force (BFS with State Enumeration) — Algorithm Steps

Build adjacency list and in-degree count for prerequisites
Use BFS where each state represents completed courses
For each state, generate all valid subsets of available courses (size ≤ k)
Continue until all courses are completed
Return the minimum semesters needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with no courses completed (state 0)

Find Available

Identify courses with satisfied prerequisites

Generate Combinations

Create all valid subsets of size ≤ k

Explore States

Add new states to queue for next semester

Complete

Return semesters when all courses done

Code -

solution.c — C

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

#define MAXN 15
#define MAXSTATES 32768

typedef struct {
    int mask;
    int semesters;
} State;

typedef struct {
    State states[MAXSTATES];
    int front, rear;
} Queue;

void enqueue(Queue* q, State s) {
    q->states[q->rear++] = s;
}

State dequeue(Queue* q) {
    return q->states[q->front++];
}

int isEmpty(Queue* q) {
    return q->front == q->rear;
}

int minimumSemesters(int n, int relations[][2], int relationsSize, int k) {
    int graph[MAXN][MAXN] = {0};
    int inDegree[MAXN] = {0};
    
    for (int i = 0; i < relationsSize; i++) {
        int prev = relations[i][0];
        int next = relations[i][1];
        graph[prev][next] = 1;
        inDegree[next]++;
    }
    
    Queue queue = {0};
    int visited[MAXSTATES] = {0};
    
    State initial = {0, 0};
    enqueue(&queue, initial);
    visited[0] = 1;
    
    int target = (1 << n) - 1;
    
    while (!isEmpty(&queue)) {
        State curr = dequeue(&queue);
        
        if (curr.mask == target) {
            return curr.semesters;
        }
        
        int available[MAXN];
        int availableCount = 0;
        
        for (int course = 1; course <= n; course++) {
            if (curr.mask & (1 << (course - 1))) continue;
            
            int canTake = 1;
            for (int prev = 1; prev <= n; prev++) {
                if (graph[prev][course] && !(curr.mask & (1 << (prev - 1)))) {
                    canTake = 0;
                    break;
                }
            }
            
            if (canTake) {
                available[availableCount++] = course;
            }
        }
        
        // Generate all combinations (simplified for space)
        for (int mask = 1; mask < (1 << availableCount); mask++) {
            if (__builtin_popcount(mask) > k) continue;
            
            int newMask = curr.mask;
            for (int i = 0; i < availableCount; i++) {
                if (mask & (1 << i)) {
                    newMask |= (1 << (available[i] - 1));
                }
            }
            
            if (!visited[newMask]) {
                visited[newMask] = 1;
                State newState = {newMask, curr.semesters + 1};
                enqueue(&queue, newState);
            }
        }
    }
    
    return -1;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

For each course, we have 3 choices: not taken, can take, or already taken. In worst case, we explore all combinations.

✓ Linear Growth

Space Complexity

O(2^n)

We need to store all possible states of completed courses in the BFS queue.

⚠ Quadratic Space

56.2K Views

Medium Frequency

~25 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (BFS with State Enumeration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler