Codestin Search App

Employee Free Time - Problem

Find Common Free Time for All Employees

Imagine you're managing a team and need to schedule a meeting that works for everyone. You have each employee's working schedule as a list of time intervals, and you need to find all the time slots when everyone is free.

Given a list schedule where schedule[i] represents the working intervals for employee i, return all the common free time intervals for all employees. Each employee's intervals are non-overlapping and sorted.

Goal: Find time slots when ALL employees are simultaneously free
Input: List of employee schedules (each schedule is a list of intervals)
Output: List of intervals representing common free time

Note: Only return intervals with positive length (exclude zero-length intervals like [5,5])

Input & Output

example_1.py — Basic Case

$ Input: schedule = [[[1,3],[6,7]],[[2,4]],[[2,5],[9,12]]]

› Output: [[5,6],[7,9]]

💡 Note: Employee 1 works [1,3] and [6,7]. Employee 2 works [2,4]. Employee 3 works [2,5] and [9,12]. The common free times are [5,6] (between 5-6, no one is working) and [7,9] (between 7-9, no one is working).

example_2.py — Overlapping Schedules

$ Input: schedule = [[[1,3],[4,6]],[[2,5],[7,9]]]

› Output: [[6,7]]

💡 Note: Employee 1 works [1,3] and [4,6]. Employee 2 works [2,5] and [7,9]. The merged busy time is [1,6] and [7,9], so the only free time is [6,7].

example_3.py — No Free Time

$ Input: schedule = [[[1,10]],[[2,6],[8,10]],[[1,9]]]

› Output: []

💡 Note: Employee 1 works [1,10], Employee 2 works [2,6] and [8,10], Employee 3 works [1,9]. When we merge all intervals, we get [1,10] with no gaps, so there's no common free time.

Constraints

1 ≤ schedule.length, schedule[i].length ≤ 50
0 ≤ schedule[i][j].start < schedule[i][j].end ≤ 10⁸
Each employee's intervals are non-overlapping and sorted
Only return positive-length intervals (exclude zero-length like [5,5])

Visualization

Tap to expand

Understanding the Visualization

Collect All Busy Times

Gather all working intervals from every employee's schedule

Sort Chronologically

Arrange all intervals by their start time to process them in order

Merge Overlapping Periods

Combine overlapping work periods to get consolidated busy times

Find the Gaps

The spaces between merged busy periods are your meeting opportunities

Key Takeaway

🎯 Key Insight: Free time exists in the gaps between merged busy intervals. By combining all schedules and finding the holes, we discover when everyone is simultaneously available.

Asked in

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

The optimal approach uses a line sweep algorithm with either interval merging or priority queue. First, collect all working intervals from all employees. Then, merge overlapping intervals to get consolidated busy periods. Finally, find the gaps between merged intervals - these gaps represent the common free time when all employees are available. Time complexity is O(n log n) due to sorting, where n is the total number of intervals.

Common Approaches

Approach	Time	Space	Notes
✓ Priority Queue Line Sweep	O(n log n)	O(n)	Use a min-heap to process intervals in chronological order and track active employees
Brute Force (Flatten and Sort)	O(n log n)	O(n)	Collect all intervals, sort them, then find gaps between merged intervals

Priority Queue Line Sweep — Algorithm Steps

Create a priority queue with all intervals sorted by start time
Process intervals chronologically using the priority queue
Track the number of active (working) employees at each point
When active count drops to 0, we have potential free time
Record free time intervals between busy periods

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Events

Convert intervals to start/end events and add to priority queue

Process Chronologically

Pop events from queue in time order

Track Active Workers

Maintain set of currently working employees

Detect Free Time

When no employees are active, we have free time

Code -

solution.c — C

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

typedef struct {
    int start, end;
} Interval;

typedef struct {
    int time, type, empId;
} Event;

int compareEvents(const void* a, const void* b) {
    Event* ea = (Event*)a;
    Event* eb = (Event*)b;
    if (ea->time == eb->time) {
        return ea->type - eb->type;
    }
    return ea->time - eb->time;
}

Interval* employeeFreeTime(Interval** schedule, int* scheduleSizes, int scheduleSize, int* returnSize) {
    // Count total events
    int totalEvents = 0;
    for (int i = 0; i < scheduleSize; i++) {
        totalEvents += scheduleSizes[i] * 2;
    }
    
    // Create events array
    Event* events = malloc(totalEvents * sizeof(Event));
    int eventIdx = 0;
    
    for (int i = 0; i < scheduleSize; i++) {
        for (int j = 0; j < scheduleSizes[i]; j++) {
            events[eventIdx++] = (Event){schedule[i][j].start, 0, i};
            events[eventIdx++] = (Event){schedule[i][j].end, 1, i};
        }
    }
    
    // Sort events
    qsort(events, totalEvents, sizeof(Event), compareEvents);
    
    // Process events
    Interval* result = malloc(totalEvents * sizeof(Interval));
    *returnSize = 0;
    
    bool* activeEmployees = calloc(scheduleSize, sizeof(bool));
    int activeCount = 0;
    int lastFreeStart = -1;
    bool hasFreeStart = false;
    
    for (int i = 0; i < totalEvents; i++) {
        Event event = events[i];
        
        if (event.type == 0) { // Start work
            if (activeCount == 0 && hasFreeStart) {
                if (lastFreeStart < event.time) {
                    result[*returnSize] = (Interval){lastFreeStart, event.time};
                    (*returnSize)++;
                }
            }
            if (!activeEmployees[event.empId]) {
                activeEmployees[event.empId] = true;
                activeCount++;
            }
        } else { // End work
            if (activeEmployees[event.empId]) {
                activeEmployees[event.empId] = false;
                activeCount--;
            }
            if (activeCount == 0) {
                lastFreeStart = event.time;
                hasFreeStart = true;
            }
        }
    }
    
    free(events);
    free(activeEmployees);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Where n is total intervals. Each interval is processed once with heap operations

⚡ Linearithmic

Space Complexity

O(n)

Priority queue stores all intervals at worst case

⚡ Linearithmic Space

52.0K Views

Medium Frequency

~25 min Avg. Time

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

Priority Queue Line Sweep — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler