Cinema Seat Allocation - Practice Coding Problems

Cinema Seat Allocation - Problem

Welcome to the Cinema Seat Allocation problem! Imagine you're working for a popular movie theater chain, and your job is to maximize the number of four-person groups that can be seated together.

Each cinema has n rows of seats, numbered from 1 to n. Every row contains exactly 10 seats labeled 1 through 10, with a layout like this:

[1][2][3] | [4][5][6][7] | [8][9][10]

Notice the aisles (|) that separate the seats into three sections. A four-person group needs four adjacent seats in the same row. The tricky part? There are three possible arrangements:

Left section: seats [2,3,4,5] (crosses the left aisle)
Middle section: seats [4,5,6,7] (entirely in the middle)
Right section: seats [6,7,8,9] (crosses the right aisle)

Given an array reservedSeats where reservedSeats[i] = [row, seat] represents already booked seats, your task is to find the maximum number of four-person groups you can accommodate.

Goal: Return the maximum number of complete 4-person groups that can be seated.

Input & Output

example_1.py — Basic Case

$ Input: n = 3, reservedSeats = [[1,2],[1,3],[1,8],[2,6],[3,1],[3,10]]

› Output: 4

💡 Note: Row 1: Seats 2,3 blocked → Left pattern blocked, but middle [4,5,6,7] and right [6,7,8,9] available → Choose left+right impossible, so pick middle → 1 group. Row 2: Seat 6 blocked → Left [2,3,4,5] available, middle blocked, right available → Choose left+right → 2 groups. Row 3: Seats 1,10 blocked → All patterns available → 2 groups. Total: 1+2+1=4

example_2.py — All Available

$ Input: n = 2, reservedSeats = []

› Output: 4

💡 Note: No reserved seats, so each row can accommodate 2 groups (left+right patterns [2,3,4,5] and [6,7,8,9]). Total: 2*2 = 4 groups.

example_3.py — Heavy Blocking

$ Input: n = 4, reservedSeats = [[4,3],[1,4],[4,6],[1,7]]

› Output: 4

💡 Note: Row 1: Seats 4,7 blocked → All three patterns blocked → 0 groups. Row 2,3: No reservations → 2 groups each. Row 4: Seats 3,6 blocked → All patterns blocked → 0 groups. Total: 0+2+2+0=4

Visualization

Tap to expand

Understanding the Visualization

Map the Layout

Visualize cinema rows with aisles: [1][2][3]|[4][5][6][7]|[8][9][10]

Identify Patterns

Three valid 4-seat groups: Left [2,3,4,5], Middle [4,5,6,7], Right [6,7,8,9]

Check Conflicts

Use reserved seats to eliminate blocked patterns

Maximize Groups

Choose left+right when possible (2 groups), otherwise pick any available pattern (1 group)

Key Takeaway

🎯 Key Insight: Each row supports at most 2 four-person groups. Use bit manipulation to efficiently check pattern availability and prioritize non-overlapping arrangements (left+right) over middle pattern when possible.

Time & Space Complexity

Time Complexity

⏱️

O(r)

Where r is the number of reserved seats. We only process rows that have reservations, not all n rows

✓ Linear Growth

Space Complexity

O(r)

Hash map stores reserved seats grouped by row, maximum r entries total

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁹
1 ≤ reservedSeats.length ≤ 4 * 10⁴
reservedSeats[i].length == 2
1 ≤ reservedSeats[i][0] ≤ n
1 ≤ reservedSeats[i][1] ≤ 10
Each seat appears at most once in reservedSeats

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 29 f Meta 22

The optimal solution uses a hash map to group reserved seats by row and bit manipulation to efficiently check seating patterns. Key insight: only process rows with reservations (O(r) instead of O(n)), and use bitmasks to quickly test if patterns [2,3,4,5], [4,5,6,7], or [6,7,8,9] are available. Empty rows automatically contribute 2 groups each.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map + Bit Manipulation (Optimal)	O(r)	O(r)	Group reserved seats by row and use bit manipulation for efficient pattern checking
Brute Force (Row by Row Check)	O(n)	O(r)	Check each row individually and test all three possible seating arrangements

Hash Map + Bit Manipulation (Optimal) — Algorithm Steps

Group all reserved seats by row number using a hash map
For each row with reservations, convert seat numbers to bitmask
Use bitwise AND to check if seating patterns conflict with reserved seats
Apply greedy selection: prioritize left+right over middle when possible
Add 2 groups for each row that has no reservations: 2 * (n - rows_with_reservations)

Visualization

Tap to expand

Step-by-Step Walkthrough

Group by Row

Use hash map to group reserved seats by row number

Create Bitmask

Convert reserved seats to bitmask for efficient checking

Pattern Match

Use bitwise AND to check pattern availability

Add Empty Rows

Each unreserved row contributes 2 groups automatically

Code -

solution.c — C

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

#define MAX_ROWS 100000

struct RowData {
    int row;
    int mask;
};

int compare(const void* a, const void* b) {
    return ((struct RowData*)a)->row - ((struct RowData*)b)->row;
}

int maxNumberOfFamilies(int n, int** reservedSeats, int reservedSeatsSize, int* reservedSeatsColSize) {
    struct RowData rows[MAX_ROWS];
    int uniqueRows = 0;
    
    // Sort reserved seats by row
    qsort(reservedSeats, reservedSeatsSize, sizeof(int*), NULL);
    
    // Group by rows and create bitmasks
    int currentRow = -1, currentMask = 0;
    for (int i = 0; i < reservedSeatsSize; i++) {
        int row = reservedSeats[i][0];
        int seat = reservedSeats[i][1];
        
        if (row != currentRow) {
            if (currentRow != -1) {
                rows[uniqueRows++] = (struct RowData){currentRow, currentMask};
            }
            currentRow = row;
            currentMask = 0;
        }
        
        if (seat >= 2 && seat <= 9) {
            currentMask |= (1 << (seat - 2));
        }
    }
    
    if (currentRow != -1) {
        rows[uniqueRows++] = (struct RowData){currentRow, currentMask};
    }
    
    int totalGroups = 0;
    int leftPattern = 0b00001111;    // seats 2,3,4,5
    int middlePattern = 0b00111100;  // seats 4,5,6,7
    int rightPattern = 0b11110000;   // seats 6,7,8,9
    
    // Process rows with reservations
    for (int i = 0; i < uniqueRows; i++) {
        int mask = rows[i].mask;
        
        bool leftAvailable = (mask & leftPattern) == 0;
        bool middleAvailable = (mask & middlePattern) == 0;
        bool rightAvailable = (mask & rightPattern) == 0;
        
        if (leftAvailable && rightAvailable) {
            totalGroups += 2;
        } else if (leftAvailable || middleAvailable || rightAvailable) {
            totalGroups += 1;
        }
    }
    
    // Add 2 groups for each row without reservations
    totalGroups += 2 * (n - uniqueRows);
    
    return totalGroups;
}

Time & Space Complexity

Time Complexity

⏱️

O(r)

Where r is the number of reserved seats. We only process rows that have reservations, not all n rows

✓ Linear Growth

Space Complexity

O(r)

Hash map stores reserved seats grouped by row, maximum r entries total

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁹
1 ≤ reservedSeats.length ≤ 4 * 10⁴
reservedSeats[i].length == 2
1 ≤ reservedSeats[i][0] ≤ n
1 ≤ reservedSeats[i][1] ≤ 10
Each seat appears at most once in reservedSeats

38.2K Views

Medium Frequency

~18 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Map + Bit Manipulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler