Skip to main content
Talentd

Meeting Scheduler - Solution & Explanation

MediumPremiumFree on FleetCodeArrayTwo PointersSorting9 min readAsked at: Amazon, Microsoft, Apple +8
Practice this problem

Problem Statement

Given the availability time slots arrays slots1 and slots2 of two people and a meeting duration duration, return the earliest time slot that works for both of them and is of duration duration.

If there is no common time slot that satisfies the requirements, return an empty array.

The format of a time slot is an array of two elements [start, end] representing an inclusive time range from start to end.

It is guaranteed that no two availability slots of the same person intersect with each other. That is, for any two time slots [start1, end1] and [start2, end2] of the same person, either start1 > end2 or start2 > end1.

 

Example 1:

Input: slots1 = [[10,50],[60,120],[140,210]], slots2 = [[0,15],[60,70]], duration = 8
Output: [60,68]

Example 2:

Input: slots1 = [[10,50],[60,120],[140,210]], slots2 = [[0,15],[60,70]], duration = 12
Output: []

 

Constraints:

  • 1 <= slots1.length, slots2.length <= 104
  • slots1[i].length, slots2[i].length == 2
  • slots1[i][0] < slots1[i][1]
  • slots2[i][0] < slots2[i][1]
  • 0 <= slots1[i][j], slots2[i][j] <= 109
  • 1 <= duration <= 106

Approach Overview

Problem Overview: You are given two lists of available time slots for two people and a required meeting duration. Each slot is represented as [start, end]. The task is to return the earliest time interval where both people are free for at least the required duration.

Approach 1: Brute Force Interval Comparison (O(n * m) time, O(1) space)

Check every slot from the first list against every slot from the second list. For each pair, compute the overlap using start = max(a_start, b_start) and end = min(a_end, b_end). If end - start >= duration, that overlap can host the meeting. This approach directly simulates the definition of overlapping intervals but requires comparing all pairs, which becomes slow when both lists are large.

Approach 2: Sorting + Two Pointers (O(n log n + m log m) time, O(1) space)

Sort both slot lists by start time, then scan them using two pointers. At each step, compare the current slots from both lists and compute their overlap. If the overlap duration is large enough, return the earliest valid interval. Otherwise, advance the pointer of the slot that ends earlier, since that slot cannot overlap with any later intervals. This technique leverages ordered intervals and reduces unnecessary comparisons, making it the optimal solution using sorting and the two pointers pattern on arrays.

Approach 3: Min Heap Merge (O((n + m) log(n + m)) time, O(n + m) space)

Push all slots from both participants into a min heap ordered by start time. Continuously pop the earliest interval and compare it with the next interval in the heap. If their overlap duration is at least the required meeting length, return the interval. This approach treats the problem like merging sorted intervals using a priority queue. It is slightly heavier in both memory and runtime but works well when intervals come from multiple sources.

Recommended for interviews: The sorting + two pointers approach is what interviewers typically expect. Brute force demonstrates that you understand how interval overlap works, but it does not scale. Sorting the slots and advancing the pointer with the earlier end time shows you recognize the key insight that overlapping windows can be scanned efficiently in linear time after ordering.

Solution

We can sort the free time intervals of both people, then use two pointers to traverse the two arrays and find the intersection of the free time intervals of both people. If the length of the intersection is greater than or equal to duration, return the start time of the intersection and the start time plus duration. Otherwise, if the end time of the first person's free time interval is less than the end time of the second person's free time interval, move the first person's pointer; otherwise, move the second person's pointer. Continue traversing until a suitable time interval is found or the traversal ends.

The time complexity is O(m times log m + n times log n), and the space complexity is O(log m + log n). Here, m and n are the lengths of the two arrays, respectively.

Code

PythonJavaC++GoTypeScriptRust

Python

Java

C++

Go

TypeScript

Rust

Try this approach in the editor →

Detailed Complexity Analysis

ApproachTimeSpaceWhen to Use
Brute Force Interval ComparisonO(n * m)O(1)Small inputs or quick prototype to verify overlap logic
Sorting + Two PointersO(n log n + m log m)O(1)Optimal solution when schedules are arrays of intervals
Min Heap MergeO((n + m) log(n + m))O(n + m)Useful when combining schedules from multiple participants or streams

Video Solution

LeetCode 1229. Meeting Scheduler • Happy Coding • 6,438 views views

Watch 9 more video solutions →

Frequently Asked Questions

Is Meeting Scheduler easy or hard?
Meeting Scheduler is generally classified as a medium difficulty problem. The main challenge is recognizing that sorting the intervals allows a linear scan with two pointers, avoiding the O(n * m) brute force comparison of all pairs.
How to solve Meeting Scheduler in O(n)?
A pure O(n) solution is possible only if both slot lists are already sorted by start time. In that case, use two pointers to compare intervals and compute overlaps while advancing the pointer with the earlier ending time. The scan processes each interval once, giving O(n + m) time.
Meeting Scheduler Python or Java solution
Most implementations sort both slot arrays and use two indices to scan for overlapping windows. Python solutions typically use built-in sorting with a simple loop, while Java solutions use Arrays.sort and pointer variables. Both follow the same O(n log n + m log m) algorithm.
What is the best approach for Meeting Scheduler?
The optimal solution uses sorting and the two pointers technique. First sort both slot lists by start time, then scan them simultaneously to compute overlaps. At each step check if the overlap length is at least the required duration. This runs in O(n log n + m log m) time due to sorting and O(1) extra space.
What data structure is used in Meeting Scheduler?
The primary structures are arrays of intervals combined with sorting and the two pointers technique. Some alternative implementations use a min heap to process intervals by start time, but the two pointer scan after sorting is the most common approach.
What is the time complexity of Meeting Scheduler?
The optimal approach runs in O(n log n + m log m) time because both availability lists must be sorted by start time. After sorting, the two pointer scan processes each interval once, which is O(n + m). Space complexity is O(1) if sorting is done in place.
Is Meeting Scheduler asked at Google, Amazon, or Meta?
Meeting Scheduler is a common interval scheduling problem frequently reported in interviews at companies like Google, Amazon, and Meta. It tests understanding of interval overlap, sorting, and the two pointers pattern, which are standard interview topics.

Ready to solve this problem?

Practice Meeting Scheduler with our built-in code editor and test cases.

Practice on FleetCode
Previous

Merge Two 2D Arrays by Summing Values

Next

Reschedule Meetings for Maximum Free Time I