Corporate Flight Bookings - Practice Coding Problems

Corporate Flight Bookings - Problem

Imagine you're working for a corporate travel management system that handles flight reservations for multiple business trips. Your airline operates n flights numbered from 1 to n.

You receive an array of booking requests where each booking bookings[i] = [first_i, last_i, seats_i] represents:

first_i: The first flight number in the range
last_i: The last flight number in the range (inclusive)
seats_i: Number of seats to reserve on each flight in this range

Your task is to calculate the total number of reserved seats for each individual flight. Return an array answer of length n where answer[i] represents the total seats reserved for flight i+1.

Example: If you have booking [2, 4, 10], it means reserve 10 seats on flights 2, 3, and 4.

Input & Output

example_1.py — Basic Range Bookings

$ Input: bookings = [[1,2,10],[2,3,20],[2,5,25]], n = 5

› Output: [10,55,45,25,25]

💡 Note: Flight 1: booking [1,2,10] → 10 seats. Flight 2: bookings [1,2,10] + [2,3,20] + [2,5,25] → 55 seats. Flight 3: bookings [2,3,20] + [2,5,25] → 45 seats. Flights 4,5: booking [2,5,25] → 25 seats each.

example_2.py — Single Booking

$ Input: bookings = [[1,2,10]], n = 2

› Output: [10,10]

💡 Note: Only one booking reserves 10 seats for flights 1 and 2, so both flights have exactly 10 reserved seats.

example_3.py — Non-overlapping Ranges

$ Input: bookings = [[1,2,10],[3,4,20]], n = 4

› Output: [10,10,20,20]

💡 Note: Flights 1-2 get 10 seats from first booking, flights 3-4 get 20 seats from second booking. No overlap between ranges.

Constraints

1 ≤ bookings.length ≤ 2 × 10⁴
1 ≤ first_i ≤ last_i ≤ n ≤ 2 × 10⁴
1 ≤ seats_i ≤ 10⁴
All flight numbers are 1-indexed

Visualization

Tap to expand

Understanding the Visualization

Booking Requests

Guests book rooms for date ranges [check-in, check-out] with room counts

Smart Tracking

Instead of updating every night, mark check-in (+rooms) and check-out (-rooms)

Daily Calculation

Process chronologically to get running totals for each night

Final Occupancy

Each night shows total occupied rooms from all overlapping bookings

Key Takeaway

🎯 Key Insight: Range update problems can be solved efficiently using difference arrays - mark boundaries instead of updating entire ranges, then compute prefix sums.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 B Bloomberg 28

The optimal solution uses the difference array technique to achieve O(m + n) time complexity. Instead of updating every element in each booking range, we mark only the start (+seats) and end+1 (-seats) boundaries, then compute a prefix sum to get the final seat counts for all flights.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(m × n)	O(1)	Directly update each flight in every booking range
Difference Array (Optimal)	O(m + n)	O(1)	Use difference array technique with prefix sum for O(m + n) solution

Brute Force (Nested Loops) — Algorithm Steps

Initialize result array with zeros
For each booking [first, last, seats]
Iterate through flights from first to last (inclusive)
Add seats to each flight in the range
Return the final result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Array

Create array of zeros for n flights

Process Booking

For each booking, iterate through the entire range

Update Elements

Add seats to each flight in the range

Repeat

Continue for all bookings

Code -

solution.c — C

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

int* corpFlightBookings(int** bookings, int bookingsSize, int* bookingsColSize, int n, int* returnSize) {
    int* answer = (int*)calloc(n, sizeof(int));
    *returnSize = n;
    
    for (int i = 0; i < bookingsSize; i++) {
        int first = bookings[i][0], last = bookings[i][1], seats = bookings[i][2];
        // Update each flight in the range
        for (int flight = first - 1; flight < last; flight++) { // Convert to 0-indexed
            answer[flight] += seats;
        }
    }
    
    return answer;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

m bookings × average range size of n flights, worst case O(m × n)

✓ Linear Growth

Space Complexity

O(1)

Only using the output array, no extra space for algorithm

✓ Linear Space

52.3K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler