Booking Concert Tickets in Groups - Practice Coding Problems

Booking Concert Tickets in Groups - Problem

Design a Concert Ticketing System

You're building a ticketing system for a popular concert venue! The concert hall has n rows (numbered 0 to n-1) with m seats each (numbered 0 to m-1).

Your system must handle two types of booking requests:

🎫 Group Seating (gather): A group of k people want to sit together in the same row
🎫 Flexible Seating (scatter): A group of k people are okay sitting apart, just want seats

The customers are picky though! They have these requirements:
• Only consider rows 0 through maxRow
• Always prefer the smallest row number available
• Within a row, prefer seats with smallest numbers

Your Task:
Implement BookMyShow class with:
• gather(k, maxRow): Returns [row, seat] of first seat for k consecutive seats, or [] if impossible
• scatter(k, maxRow): Returns true if k seats can be allocated (anywhere), false otherwise

Input & Output

example_1.py — Basic Operations

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

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

💡 Note: BookMyShow bms = new BookMyShow(2, 5); // 2 rows, 5 seats each bms.gather(4, 0); → [0, 0] (4 seats in row 0, starting at seat 0) bms.gather(2, 0); → [] (row 0 only has 1 seat left, can't fit 2 consecutive) bms.scatter(5, 1); → true (can scatter 5 people across rows 0-1) bms.scatter(5, 1); → false (not enough total seats remaining)

example_2.py — MaxRow Constraint

$ Input: ["BookMyShow", "gather", "gather", "gather"] [[3, 4], [2, 1], [3, 2], [2, 2]]

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

💡 Note: BookMyShow bms = new BookMyShow(3, 4); // 3 rows, 4 seats each bms.gather(2, 1); → [0, 0] (row 0 available, fits 2 consecutive seats) bms.gather(3, 2); → [1, 0] (row 0 has only 2 seats left, use row 1) bms.gather(2, 2); → [2, 0] (rows 0,1 don't have enough consecutive seats)

example_3.py — Scatter vs Gather

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

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

💡 Note: BookMyShow bms = new BookMyShow(2, 3); // 2 rows, 3 seats each bms.scatter(4, 1); → true (scatter 4 people across rows 0-1: fills row 0 + 1 seat in row 1) bms.gather(2, 1); → [] (no row has 2 consecutive seats after scattering) bms.scatter(1, 1); → true (1 seat still available in row 1)

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

Each gather() or scatter() operation may need to scan all n*m seats

✓ Linear Growth

Space Complexity

O(n*m)

2D array to store seat occupancy status

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 5 × 10⁴
1 ≤ m, k ≤ 10⁹
0 ≤ maxRow ≤ n - 1
At most 5 × 10⁴ calls will be made to gather and scatter

Asked in

This problem requires efficient data structures to handle seat booking queries. The brute force approach scans each row linearly but is too slow for large inputs. The optimal solution uses segment trees to track maximum consecutive available seats per row and total available seats, enabling O(log n) queries instead of O(n*m). Key insight: maintain separate trees for consecutive seat queries (gather) and total seat counts (scatter).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Scan)	O(n*m)	O(n*m)	Scan each row linearly to find available seats
Segment Tree with Binary Search	O(log n + log m)	O(n*m)	Use segment trees to efficiently query maximum consecutive seats and total available seats

Brute Force (Linear Scan) — Algorithm Steps

Maintain a 2D boolean array to track seat occupancy
For gather(): scan each row to find k consecutive empty seats
For scatter(): count total available seats in valid rows
Update seat occupancy after successful bookings

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create 2D boolean array for seat tracking

Scan Rows

Check each row from 0 to maxRow

Find Seats

For gather: find consecutive seats, for scatter: count available

Book Seats

Mark found seats as occupied

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.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 startSeat = -1;
        
        for (int seat = 0; seat < obj->m; seat++) {
            if (!obj->seats[row][seat]) {
                if (consecutive == 0) startSeat = seat;
                consecutive++;
                if (consecutive == k) {
                    for (int j = startSeat; j < startSeat + k; j++) {
                        obj->seats[row][j] = true;
                    }
                    int* result = (int*)malloc(2 * sizeof(int));
                    result[0] = row;
                    result[1] = startSeat;
                    *returnSize = 2;
                    return result;
                }
            } else {
                consecutive = 0;
            }
        }
    }
    *returnSize = 0;
    return NULL;
}

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

void bookMyShowFree(BookMyShow* obj) {
    for (int i = 0; i < obj->n; i++) {
        free(obj->seats[i]);
    }
    free(obj->seats);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

Each gather() or scatter() operation may need to scan all n*m seats

✓ Linear Growth

Space Complexity

O(n*m)

2D array to store seat occupancy status

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 5 × 10⁴
1 ≤ m, k ≤ 10⁹
0 ≤ maxRow ≤ n - 1
At most 5 × 10⁴ calls will be made to gather and scatter

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Linear Scan) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler