Cinema Seat Allocation

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,8 blocked → Left pattern [2,3,4,5] blocked, middle [4,5,6,7] available, right [6,7,8,9] blocked → 1 group. Row 2: Seat 6 blocked → Left [2,3,4,5] available, middle and right blocked → 1 group. Row 3: Seats 1,10 blocked → All patterns available → 2 groups. Total: 1+1+2=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

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

Visualization

Tap to expand

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

✓ Brute Force (Row by Row Check)

⏱️ Time: O(n) Space: O(r)

For each row from 1 to n, check if any of the three possible four-person arrangements ([2,3,4,5], [4,5,6,7], [6,7,8,9]) conflict with reserved seats. This approach processes every row even if it has no reservations.

Hash Map + Bit Manipulation (Optimal)

⏱️ Time: O(r) Space: O(r)

Instead of checking all n rows, we only process rows that have reservations. We use a hash map to group reserved seats by row, then use bit manipulation to efficiently check which seating patterns are blocked. For rows without reservations, we automatically get 2 groups each.

Brute Force (Row by Row Check) — Algorithm Steps

Create a set of reserved seats for O(1) lookup
For each row from 1 to n:
Check if seats [2,3,4,5] are all available (left arrangement)
Check if seats [4,5,6,7] are all available (middle arrangement)
Check if seats [6,7,8,9] are all available (right arrangement)
Count maximum non-overlapping arrangements for this row
Add to total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create reserved seats lookup and start with row 1

Check Row

For current row, test all three seating patterns

Count Groups

Add maximum possible groups for this row

Next Row

Move to next row and repeat until all rows processed

Code -

solution.c — C

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

// Definition for N-ary tree node
struct Node {
    int val;
    struct Node** children;
    int childrenSize;
};

// Create a new node
struct Node* createNode(int val) {
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->val = val;
    node->children = NULL;
    node->childrenSize = 0;
    return node;
}

// Clone N-ary tree
struct Node* cloneTree(struct Node* root) {
    if (root == NULL) return NULL;
    
    // Create new node with same value
    struct Node* clonedNode = createNode(root->val);
    
    // Clone all children
    if (root->childrenSize > 0) {
        clonedNode->children = (struct Node**)malloc(root->childrenSize * sizeof(struct Node*));
        clonedNode->childrenSize = root->childrenSize;
        
        for (int i = 0; i < root->childrenSize; i++) {
            clonedNode->children[i] = cloneTree(root->children[i]);
        }
    }
    
    return clonedNode;
}

// Queue for BFS traversal
struct QueueNode {
    struct Node* node;
    struct QueueNode* next;
};

struct Queue {
    struct QueueNode* front;
    struct QueueNode* rear;
};

struct Queue* createQueue() {
    struct Queue* q = (struct Queue*)malloc(sizeof(struct Queue));
    q->front = q->rear = NULL;
    return q;
}

void enqueue(struct Queue* q, struct Node* node) {
    struct QueueNode* newNode = (struct QueueNode*)malloc(sizeof(struct QueueNode));
    newNode->node = node;
    newNode->next = NULL;
    
    if (q->rear == NULL) {
        q->front = q->rear = newNode;
        return;
    }
    
    q->rear->next = newNode;
    q->rear = newNode;
}

struct Node* dequeue(struct Queue* q) {
    if (q->front == NULL) return NULL;
    
    struct QueueNode* temp = q->front;
    struct Node* node = temp->node;
    q->front = q->front->next;
    
    if (q->front == NULL) q->rear = NULL;
    
    free(temp);
    return node;
}

int isEmpty(struct Queue* q) {
    return q->front == NULL;
}

// Serialize tree to match expected output format
void serializeTree(struct Node* root) {
    if (root == NULL) {
        printf("null");
        return;
    }
    
    printf("[");
    
    struct Queue* q = createQueue();
    enqueue(q, root);
    int first = 1;
    
    while (!isEmpty(q)) {
        struct Node* node = dequeue(q);
        
        if (!first) printf(",");
        first = 0;
        
        if (node == NULL) {
            printf("null");
        } else {
            printf("%d", node->val);
            if (node->childrenSize > 0) {
                printf(",null"); // separator
                for (int i = 0; i < node->childrenSize; i++) {
                    enqueue(q, node->children[i]);
                }
            }
        }
    }
    
    printf("]");
    free(q);
}

int main() {
    // Create test tree: root(1) with children [3,2,4]
    struct Node* root = createNode(1);
    root->childrenSize = 3;
    root->children = (struct Node**)malloc(3 * sizeof(struct Node*));
    root->children[0] = createNode(3);
    root->children[1] = createNode(2);
    root->children[2] = createNode(4);
    
    // Clone the tree
    struct Node* cloned = cloneTree(root);
    
    // Serialize and output
    serializeTree(cloned);
    printf("\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We check each of the n rows once, and for each row we do constant work (checking 3 patterns)

✓ Linear Growth

Space Complexity

O(r)

Where r is the number of reserved seats, stored in a hash set for fast lookup

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Row by Row Check) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler