Corporate Flight Bookings

Corporate Flight Bookings - Problem

There are n flights that are labeled from 1 to n.

You are given an array of flight bookings bookings, where bookings[i] = [first_i, last_i, seats_i] represents a booking for flights first_i through last_i (inclusive) with seats_i seats reserved for each flight in the range.

Return an array answer of length n, where answer[i] is the total number of seats reserved for flight i.

Input & Output

Example 1 — Basic Overlapping Bookings

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

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

💡 Note: Flight 1: 10 seats from [1,2,10]. Flight 2: 10+20+25=55 seats (all three bookings cover flight 2). Flight 3: 20+25=45 seats. Flights 4,5: 25 seats each from [2,5,25].

Example 2 — Single Booking

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

› Output: [10,10]

💡 Note: One booking [1,2,10] covers flights 1 and 2, so both get 10 seats.

Example 3 — Non-overlapping Ranges

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

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

💡 Note: First booking covers flights 1-2 with 10 seats each. Second booking covers flights 3-4 with 20 seats each. No overlap.

Constraints

1 ≤ n ≤ 2 × 10⁴
1 ≤ bookings.length ≤ 2 × 10⁴
bookings[i].length == 3
1 ≤ first_i ≤ last_i ≤ n
1 ≤ seats_i ≤ 10⁴

Visualization

Tap to expand

Asked in

A Amazon 15 G Google 12 M Microsoft 8

The key insight is to use a difference array instead of updating ranges directly. Mark booking start/end boundaries, then compute prefix sum. Best approach is difference array with Time: O(m+n), Space: O(n).

Common Approaches

✓ Brute Force - Direct Range Updates

⏱️ Time: O(m × k) Space: O(1)

Iterate through each booking and for every flight in the range [first, last], add the number of seats to that flight's total. This directly simulates the booking process.

Difference Array (Optimal)

⏱️ Time: O(m + n) Space: O(n)

Instead of updating each position in a range, mark the start and end of each booking range in a difference array. Then compute the prefix sum to get the final result. This transforms range updates into point updates.

Brute Force - Direct Range Updates — Algorithm Steps

Initialize result array of size n with zeros
For each booking, iterate through range [first, last]
Add seats to each flight in the range

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Booking

Take booking [1,3,10] and add 10 seats to flights 1,2,3

Update Range

Iterate through each flight in range and increment

Repeat

Process all bookings one by one

Code -

solution.c — C

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

int* solution(int** bookings, int bookingsSize, int* bookingsColSize, int n, int* returnSize) {
    int* result = (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];
        // Add seats to each flight in range [first, last] (1-indexed)
        for (int j = first - 1; j < last; j++) {  // Convert to 0-indexed
            result[j] += seats;
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for the format [[1,3,10],[2,4,20]]
    int bookingsSize = 0;
    int** bookings = (int**)malloc(100 * sizeof(int*));
    
    char* ptr = line + 1; // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            bookings[bookingsSize] = (int*)malloc(3 * sizeof(int));
            ptr++; // Skip '['
            bookings[bookingsSize][0] = strtol(ptr, &ptr, 10);
            ptr++; // Skip ','
            bookings[bookingsSize][1] = strtol(ptr, &ptr, 10);
            ptr++; // Skip ','
            bookings[bookingsSize][2] = strtol(ptr, &ptr, 10);
            bookingsSize++;
        }
        ptr++;
    }
    
    int n;
    scanf("%d", &n);
    
    int returnSize;
    int* bookingsColSize = (int*)malloc(bookingsSize * sizeof(int));
    for (int i = 0; i < bookingsSize; i++) bookingsColSize[i] = 3;
    
    int* result = solution(bookings, bookingsSize, bookingsColSize, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × k)

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

✓ Linear Growth

Space Complexity

O(1)

Only using the output array, no extra space

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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 - Direct Range Updates — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler