Minimum Number of Work Sessions to Finish the Tasks

Minimum Number of Work Sessions to Finish the Tasks - Problem

You're a productivity consultant helping someone optimize their work schedule! 🚀

Given n tasks with specific durations and a maximum session time, you need to find the minimum number of work sessions required to complete all tasks.

Key Rules:

🎯 Each task must be completed within a single work session (no splitting)
⏱️ Each work session can last at most sessionTime hours
🔄 You can complete tasks in any order
✅ Tasks can be done back-to-back within the same session

Goal: Return the minimum number of work sessions needed to finish all tasks.

Example: If you have tasks [1,2,3] and sessionTime = 3, you could do [3] in session 1 and [1,2] in session 2, requiring just 2 sessions.

Input & Output

Basic Example

$ Input: tasks = [1,2,3], sessionTime = 3

› Output: 2

💡 Note: We can group tasks as [3] and [1,2]. Task 3 takes one full session, while tasks 1 and 2 can fit together in another session (1+2=3 ≤ 3).

All Tasks in One Session

$ Input: tasks = [2,1,3], sessionTime = 6

› Output: 1

💡 Note: All tasks can fit in a single session since 2+1+3 = 6 ≤ 6. Order doesn't matter: we could do [2,1,3] or any other arrangement.

Each Task Needs Its Own Session

$ Input: tasks = [3,4,3], sessionTime = 4

› Output: 3

💡 Note: Tasks [3,4,3] with sessionTime=4 means: task 1 (3≤4) ✓, task 2 (4≤4) ✓, task 3 (3≤4) ✓, but no two tasks can fit together (3+4>4, 3+3>4, 4+3>4). Each needs its own session.

Visualization

Tap to expand

Understanding the Visualization

Identify Valid Groups

Find all combinations of tasks that can fit in one session

Build DP Table

For each subset of tasks, calculate minimum sessions needed

Combine Optimally

Use previously computed optimal solutions to build larger ones

Extract Answer

The DP entry for all tasks gives us the minimum sessions

Key Takeaway

🎯 Key Insight: By representing task subsets as bitmasks and using dynamic programming, we can efficiently explore all possible groupings while avoiding redundant calculations, leading to the optimal minimum number of work sessions.

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

For each of 2^n subsets, we check all its subsets, leading to sum of C(n,k)*2^k = 3^n

✓ Linear Growth

Space Complexity

O(2^n)

DP array stores minimum sessions needed for each possible subset of tasks

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 14 (small enough for bitmask DP)
1 ≤ tasks[i] ≤ 10
max(tasks[i]) ≤ sessionTime ≤ 15
All tasks are guaranteed to fit within a single session

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 22

The optimal solution uses Dynamic Programming with Bitmasks to efficiently explore all possible ways to group tasks into sessions. We precompute all valid single-session combinations, then use DP to build up the minimum sessions needed for larger task sets. Time complexity is O(3^n) where n ≤ 14, making it practical for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Bitmask (Optimal)	O(3^n)	O(2^n)	Use DP with bitmasks to efficiently explore all task combinations and find optimal groupings
Brute Force Backtracking	O(k^n)	O(n)	Try all possible ways to assign tasks to sessions using recursive backtracking

Dynamic Programming with Bitmask (Optimal) — Algorithm Steps

Precompute all valid task combinations that fit in one session using bitmasks
Create DP array where dp[mask] represents min sessions needed for tasks in the mask
For each subset, try all valid single-session combinations that are subsets of it
Take minimum across all ways to split the current subset
Return dp[(1 << n) - 1] which represents all tasks

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

dp[0] = 0 (no tasks need 0 sessions)

Single tasks

Each single task needs exactly 1 session

Task pairs

Try combining single tasks or use 1 session if they fit together

Larger sets

Build solutions using previously computed optimal subsets

Code -

solution.c — C

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

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

int minimumWorkingSessions(int* tasks, int tasksSize, int sessionTime) {
    int n = tasksSize;
    
    // Precompute all valid single-session combinations
    int* valid = (int*)malloc((1 << n) * sizeof(int));
    int validCount = 0;
    
    for (int mask = 1; mask < (1 << n); mask++) {
        int total = 0;
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                total += tasks[i];
            }
        }
        if (total <= sessionTime) {
            valid[validCount++] = mask;
        }
    }
    
    // DP: dp[mask] = minimum sessions needed for tasks in mask
    int* dp = (int*)malloc((1 << n) * sizeof(int));
    for (int i = 0; i < (1 << n); i++) {
        dp[i] = INT_MAX;
    }
    dp[0] = 0;
    
    for (int mask = 0; mask < (1 << n); mask++) {
        if (dp[mask] == INT_MAX) continue;
        
        // Try all valid combinations that are subsets of remaining tasks
        int remaining = ((1 << n) - 1) ^ mask;
        for (int i = 0; i < validCount; i++) {
            int validMask = valid[i];
            if ((validMask & remaining) == validMask) { // validMask is subset of remaining
                int newMask = mask | validMask;
                dp[newMask] = min(dp[newMask], dp[mask] + 1);
            }
        }
    }
    
    int result = dp[(1 << n) - 1];
    free(valid);
    free(dp);
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    int* tasks = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &tasks[i]);
    }
    int sessionTime;
    scanf("%d", &sessionTime);
    printf("%d\n", minimumWorkingSessions(tasks, sessionTime));
    free(tasks);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

For each of 2^n subsets, we check all its subsets, leading to sum of C(n,k)*2^k = 3^n

✓ Linear Growth

Space Complexity

O(2^n)

DP array stores minimum sessions needed for each possible subset of tasks

⚠ Quadratic Space

Constraints

1 ≤ n ≤ 14 (small enough for bitmask DP)
1 ≤ tasks[i] ≤ 10
max(tasks[i]) ≤ sessionTime ≤ 15
All tasks are guaranteed to fit within a single session

34.2K Views

Medium Frequency

~25 min Avg. Time

1.2K 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