Elevator Requests I - Solution & Explanation

Problem Overview: You are given a list of elevator requests, each with a start and end floor. The elevator starts at floor 0 and can move in either direction. Your task is to determine the maximum number of requests the elevator can serve without exceeding its capacity or violating any constraints. This is a classic simulation problem that tests your ability to model real-world scenarios with code.

Approach 1: Brute Force Simulation (O(n^2) time, O(1) space)

For each request, simulate the elevator's movement from its current floor to the request's start floor, then to the end floor. Track the total distance traveled and the number of requests served. This approach is straightforward but inefficient for large inputs because it recalculates the path for every request. Use it only when the input size is small or when you need a quick, simple solution. The time complexity is O(n^2) due to nested loops over requests, and space complexity is O(1) as no extra data structures are used.

Approach 2: Greedy with Sorting (O(n log n) time, O(1) space)

Sort the requests by their start floor, then process them in order. For each request, check if the elevator can reach the start floor from its current position within the given time. If yes, serve the request and update the elevator's position and the count. The key insight is that sorting by start floor minimizes the total travel distance, allowing you to serve more requests. This approach is optimal when the requests are not already sorted. Time complexity is O(n log n) due to sorting, space is O(1) if sorting in-place.

Approach 3: Single Pass Simulation (O(n) time, O(1) space) - Recommended

This is the optimal approach. Iterate through the requests once, maintaining the elevator's current floor and the count of served requests. For each request, compute the absolute difference between the current floor and the start floor, then add the distance from start to end. If the total distance does not exceed the elevator's total travel time, serve the request and update the current floor to the end floor. Otherwise, skip the request. The key insight is that you don't need to sort or backtrack; a single pass suffices because the elevator's movement is linear and you always serve the next request if possible. This approach is what interviewers expect—it shows you can optimize a simulation to O(n). It runs in O(n) time and O(1) space, making it scalable for large inputs.

Recommended for interviews: The single pass simulation is the go-to solution. It demonstrates your ability to reason about state and optimize away unnecessary work. While brute force shows you understand the problem, the O(n) solution proves you can write clean, efficient code under pressure. Interviewers at top companies like Google and Amazon value this kind of thinking. For more practice, check out our simulation and greedy topic pages.