Parallel Courses II - Practice Coding Problems

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.

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.

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n * C(n,k))

We have 2^n possible states, for each state we check n courses, and generate up to C(n,k) combinations to try

⚠ Quadratic Growth

Space Complexity

O(2^n)

Memoization table stores results for up to 2^n different states of completed courses

⚠ Quadratic Space

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)

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
✓ 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)	O(3^n)	O(2^n)	Try all possible combinations of courses to take each semester using BFS

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Build adjacency list and prerequisite mapping
Use bitmask to represent which courses are completed
For each state, find all courses that can be taken (prerequisites satisfied)
Try all valid combinations of courses (up to k) for next semester
Use memoization to cache results for each state
Return minimum semesters needed to reach state with all courses completed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Start with state 0 (no courses completed)

Check Prerequisites

For each course, verify all prerequisites are satisfied

Generate Combinations

Create all valid combinations of available courses (≤k)

Recursive Call

Recursively solve for new state after taking courses

Memoize Result

Cache result to avoid recomputing same state

Code -

solution.c — C

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

#define MAXN 15
#define MAXSTATES 32768

typedef struct {
    int mask;
    int value;
} MemoEntry;

static MemoEntry memo[MAXSTATES];
static int memoSize = 0;
static int prerequisites[MAXN][MAXN];
static int prereqCount[MAXN];
static int n, k;

int findMemo(int mask) {
    for (int i = 0; i < memoSize; i++) {
        if (memo[i].mask == mask) {
            return memo[i].value;
        }
    }
    return -1;
}

void addMemo(int mask, int value) {
    memo[memoSize].mask = mask;
    memo[memoSize].value = value;
    memoSize++;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int dp(int completedMask) {
    if (completedMask == (1 << n) - 1) {
        return 0;
    }
    
    int cached = findMemo(completedMask);
    if (cached != -1) {
        return cached;
    }
    
    int available[MAXN];
    int availableCount = 0;
    
    for (int course = 1; course <= n; course++) {
        if (completedMask & (1 << (course - 1))) continue;
        
        int canTake = 1;
        for (int i = 0; i < prereqCount[course]; i++) {
            int prereq = prerequisites[course][i];
            if (!(completedMask & (1 << (prereq - 1)))) {
                canTake = 0;
                break;
            }
        }
        
        if (canTake) {
            available[availableCount++] = course;
        }
    }
    
    if (availableCount == 0) {
        addMemo(completedMask, INT_MAX);
        return INT_MAX;
    }
    
    int minSemesters = INT_MAX;
    
    // Try all combinations using bitmask
    int maxCombinations = min(1 << availableCount, 1 << k);
    for (int mask = 1; mask < maxCombinations; mask++) {
        if (__builtin_popcount(mask) > k) continue;
        
        int newMask = completedMask;
        for (int i = 0; i < availableCount; i++) {
            if (mask & (1 << i)) {
                newMask |= (1 << (available[i] - 1));
            }
        }
        
        int result = dp(newMask);
        if (result != INT_MAX) {
            minSemesters = min(minSemesters, 1 + result);
        }
    }
    
    addMemo(completedMask, minSemesters);
    return minSemesters;
}

int minimumSemesters(int numCourses, int relations[][2], int relationsSize, int maxCoursesPerSemester) {
    n = numCourses;
    k = maxCoursesPerSemester;
    memoSize = 0;
    
    memset(prereqCount, 0, sizeof(prereqCount));
    
    for (int i = 0; i < relationsSize; i++) {
        int prev = relations[i][0];
        int next = relations[i][1];
        prerequisites[next][prereqCount[next]++] = prev;
    }
    
    return dp(0);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n * n * C(n,k))

We have 2^n possible states, for each state we check n courses, and generate up to C(n,k) combinations to try

⚠ Quadratic Growth

Space Complexity

O(2^n)

Memoization table stores results for up to 2^n different states of completed courses

⚠ Quadratic Space

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)

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler