Booking Concert Tickets in Groups

Booking Concert Tickets in Groups - Problem

A concert hall has n rows numbered from 0 to n - 1, each with m seats, numbered from 0 to m - 1. You need to design a ticketing system that can allocate seats in the following cases:

If a group of k spectators can sit together in a row.
If every member of a group of k spectators can get a seat. They may or may not sit together.

Note that the spectators are very picky. Hence:

They will book seats only if each member of their group can get a seat with row number less than or equal to maxRow. maxRow can vary from group to group.
In case there are multiple rows to choose from, the row with the smallest number is chosen. If there are multiple seats to choose in the same row, the seat with the smallest number is chosen.

Implement the BookMyShow class:

BookMyShow(int n, int m) Initializes the object with n as number of rows and m as number of seats per row.
int[] gather(int k, int maxRow) Returns an array of length 2 denoting the row and seat number (respectively) of the first seat being allocated to the k members of the group, who must sit together. In other words, it returns the smallest possible r and c such that all [c, c + k - 1] seats are valid and empty in row r, and r <= maxRow. Returns [] in case it is not possible to allocate seats to the group.
boolean scatter(int k, int maxRow) Returns true if all k members of the group can be allocated seats in rows 0 to maxRow, who may or may not sit together. If the seats can be allocated, it allocates k seats to the group with the smallest row numbers, and the smallest possible seat numbers in each row. Otherwise, returns false.

Input & Output

Example 1 — Basic Operations

$ Input: operations = [["BookMyShow",2,5],["gather",4,0],["gather",2,0],["scatter",5,1],["scatter",5,1]]

› Output: [null,[0,0],[0,4],true,false]

💡 Note: Initialize 2×5 hall. First gather(4,0) allocates seats 0-3 in row 0. Second gather(2,0) fails (row 0 full). Scatter(5,1) uses remaining seat in row 0 plus 4 in row 1. Second scatter(5,1) fails (no seats left).

Example 2 — Multiple Rows

$ Input: operations = [["BookMyShow",3,3],["gather",3,1],["scatter",2,2]]

› Output: [null,[0,0],true]

💡 Note: Initialize 3×3 hall. Gather(3,1) finds 3 consecutive seats in row 0. Scatter(2,2) places 2 seats in row 1.

Example 3 — Edge Case

$ Input: operations = [["BookMyShow",1,1],["gather",1,0],["gather",1,0]]

› Output: [null,[0,0],[]]

💡 Note: Single seat hall. First gather succeeds, second fails as hall is full.

Constraints

1 ≤ n ≤ 5 × 10⁴
1 ≤ m ≤ 10⁹
1 ≤ k ≤ min(maxRow + 1, n) × m
0 ≤ maxRow ≤ n - 1
At most 5 × 10⁴ calls to gather and scatter

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15 f Facebook 12

This problem requires designing an efficient seat booking system for a concert hall. The key insight is using segment trees to quickly find rows with enough consecutive seats (gather) or total available seats (scatter). The optimal approach uses two segment trees - one for maximum consecutive seats per row and another for total available seats per row, achieving O(log n + m) time per operation. Time: O(log n + m), Space: O(n + m).

Common Approaches

✓ Brute Force with Arrays

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

Maintain a 2D array to track seat occupancy. For gather operations, scan each row linearly to find k consecutive empty seats. For scatter operations, greedily fill seats from the earliest rows.

Optimized with Segment Tree

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

Build a segment tree to track maximum consecutive empty seats per row. For gather operations, query the segment tree to find the first row with enough consecutive seats. For scatter, maintain a sum segment tree for total available seats.

Brute Force with Arrays — Algorithm Steps

Step 1: Initialize 2D boolean array for seat tracking
Step 2: For gather, scan rows 0 to maxRow linearly for k consecutive empty seats
Step 3: For scatter, fill seats greedily from row 0 onwards

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create 2D boolean array to track occupied seats

Gather Scan

Scan each row linearly to find k consecutive empty seats

Scatter Fill

Fill available seats greedily from earliest rows

Code -

solution.c — C

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

typedef struct {
    int n, m;
    bool** seats;
} BookMyShow;

BookMyShow* bookMyShowCreate(int n, int m) {
    BookMyShow* obj = (BookMyShow*)malloc(sizeof(BookMyShow));
    obj->n = n;
    obj->m = m;
    obj->seats = (bool**)malloc(n * sizeof(bool*));
    for (int i = 0; i < n; i++) {
        obj->seats[i] = (bool*)calloc(m, sizeof(bool));
    }
    return obj;
}

int* bookMyShowGather(BookMyShow* obj, int k, int maxRow, int* returnSize) {
    int maxR = (maxRow < obj->n - 1) ? maxRow : obj->n - 1;
    
    for (int row = 0; row <= maxR; row++) {
        int consecutive = 0;
        int startCol = -1;
        for (int col = 0; col < obj->m; col++) {
            if (!obj->seats[row][col]) {
                if (consecutive == 0) startCol = col;
                consecutive++;
                if (consecutive == k) {
                    for (int c = startCol; c < startCol + k; c++) {
                        obj->seats[row][c] = true;
                    }
                    int* result = (int*)malloc(2 * sizeof(int));
                    result[0] = row;
                    result[1] = startCol;
                    *returnSize = 2;
                    return result;
                }
            } else {
                consecutive = 0;
            }
        }
    }
    *returnSize = 0;
    return NULL;
}

bool bookMyShowScatter(BookMyShow* obj, int k, int maxRow) {
    int maxR = (maxRow < obj->n - 1) ? maxRow : obj->n - 1;
    
    int available = 0;
    for (int row = 0; row <= maxR; row++) {
        for (int col = 0; col < obj->m; col++) {
            if (!obj->seats[row][col]) available++;
        }
    }
    
    if (available < k) return false;
    
    int needed = k;
    for (int row = 0; row <= maxR && needed > 0; row++) {
        for (int col = 0; col < obj->m && needed > 0; col++) {
            if (!obj->seats[row][col]) {
                obj->seats[row][col] = true;
                needed--;
            }
        }
    }
    return true;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Manual JSON parsing - simple approach
    char operations[100][1000];
    int opCount = 0;
    
    char* ptr = line + 1; // Skip first [
    char current[1000] = "";
    int depth = 0;
    int pos = 0;
    
    while (*ptr && *ptr != '\n') {
        if (*ptr == '[') depth++;
        else if (*ptr == ']') depth--;
        else if (*ptr == ',' && depth == 0) {
            current[pos] = '\0';
            strcpy(operations[opCount++], current);
            pos = 0;
            ptr++;
            continue;
        }
        current[pos++] = *ptr;
        ptr++;
    }
    if (pos > 0) {
        current[pos-1] = '\0'; // Remove last ]
        strcpy(operations[opCount++], current);
    }
    
    printf("[");
    BookMyShow* obj = NULL;
    
    for (int i = 0; i < opCount; i++) {
        if (i > 0) printf(",");
        
        char* op = operations[i];
        if (op[0] == '[') op++; // Remove leading [
        
        if (strstr(op, "\"BookMyShow\"")) {
            char* comma1 = strchr(op, ',');
            char* comma2 = strchr(comma1 + 1, ',');
            int n = atoi(comma1 + 1);
            int m = atoi(comma2 + 1);
            obj = bookMyShowCreate(n, m);
            printf("null");
        } else if (strstr(op, "\"gather\"")) {
            char* comma1 = strchr(op, ',');
            char* comma2 = strchr(comma1 + 1, ',');
            int k = atoi(comma1 + 1);
            int maxRow = atoi(comma2 + 1);
            int returnSize;
            int* result = bookMyShowGather(obj, k, maxRow, &returnSize);
            if (returnSize == 0) {
                printf("[]");
            } else {
                printf("[%d,%d]", result[0], result[1]);
                free(result);
            }
        } else if (strstr(op, "\"scatter\"")) {
            char* comma1 = strchr(op, ',');
            char* comma2 = strchr(comma1 + 1, ',');
            int k = atoi(comma1 + 1);
            int maxRow = atoi(comma2 + 1);
            bool result = bookMyShowScatter(obj, k, maxRow);
            printf(result ? "true" : "false");
        }
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

Each gather operation scans up to n×m seats in worst case

✓ Linear Growth

Space Complexity

O(n×m)

2D array stores occupancy state of all n×m seats

⚡ Linearithmic Space

15.4K Views

Medium Frequency

~45 min Avg. Time

387 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 with Arrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler