Maximize Distance to Closest Person - Practice Coding Problems

Maximize Distance to Closest Person - Problem

Array Medium

Cinema Seating Problem: You're entering a movie theater represented by an array seats, where seats[i] = 1 means someone is already sitting in seat i, and seats[i] = 0 means the seat is empty.

Your goal is to find the optimal seat that maximizes your distance from the nearest occupied seat. Think of it as finding the most "private" spot in the theater!

Example: In seats [1,0,0,0,1,0,1], you'd want to sit at index 2 because it's distance 2 from the nearest person (at indices 0 and 4).

Return: The maximum possible distance to the closest person.

Input & Output

example_1.py — Basic Case

$ Input: [1,0,0,0,1,0,1]

› Output: 2

💡 Note: Sitting at index 2 gives distance 2 to nearest people at indices 0 and 4. This is the maximum possible distance.

example_2.py — Edge Seat

$ Input: [1,0,0,0]

› Output: 3

💡 Note: Sitting at the rightmost seat (index 3) gives distance 3 from the person at index 0. Edge seats can provide maximum distance.

example_3.py — Multiple Options

$ Input: [0,1,0,0,0,1,0]

› Output: 2

💡 Note: The optimal seats are at indices 3 or 4, both giving distance 2 to the nearest occupied seats.

Constraints

2 ≤ seats.length ≤ 2 × 10⁴
seats[i] is either 0 or 1
At least one seat is empty (seats[i] = 0)
At least one seat is occupied (seats[i] = 1)

Visualization

Tap to expand

Understanding the Visualization

Scan Theater Layout

Identify all occupied (1) and empty (0) seats in the row

Calculate Left Distances

For each seat, find distance to nearest person on the left

Calculate Right Distances

For each seat, find distance to nearest person on the right

Find Optimal Seat

Choose the empty seat with maximum distance to closest person

Key Takeaway

🎯 Key Insight: The optimal seat maximizes the distance to the nearest person, which occurs either at the ends of the row or in the center of the largest gap between occupied seats.

Asked in

G Google 28 a Amazon 22 f Meta 15 Apple 12

The optimal solution uses a two-pass approach to precompute distances to the nearest person on both left and right sides, then finds the position that maximizes the minimum distance. Time complexity: O(n), Space complexity: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Seat)	O(n²)	O(1)	For each empty seat, find distance to nearest occupied seat
Two Pointers (Optimal)	O(n)	O(n)	Use two passes to precompute distances, then find maximum

Brute Force (Check Every Seat) — Algorithm Steps

Iterate through each seat position
If seat is empty, calculate distance to nearest person
Scan left and right to find closest occupied seats
Keep track of maximum distance found

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Empty Seat

Check if current position is empty (seats[i] = 0)

Scan Left

Look leftward until finding nearest occupied seat

Scan Right

Look rightward until finding nearest occupied seat

Calculate Distance

Take minimum of left and right distances

Code -

solution.c — C

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

int maxDistToClosest(int* seats, int n) {
    int maxDist = 0;
    
    for (int i = 0; i < n; i++) {
        if (seats[i] == 0) { // Empty seat
            int leftDist = INT_MAX;
            int rightDist = INT_MAX;
            
            // Check left side
            for (int j = i - 1; j >= 0; j--) {
                if (seats[j] == 1) {
                    leftDist = i - j;
                    break;
                }
            }
            
            // Check right side
            for (int j = i + 1; j < n; j++) {
                if (seats[j] == 1) {
                    rightDist = j - i;
                    break;
                }
            }
            
            int closestDist = (leftDist < rightDist) ? leftDist : rightDist;
            maxDist = (closestDist > maxDist) ? closestDist : maxDist;
        }
    }
    
    return maxDist;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int seats[100];
    int n = 0;
    char* token = strtok(input, "[],\n");
    
    while (token != NULL) {
        seats[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", maxDistToClosest(seats, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n seats, we potentially scan all n seats to find nearest person

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track maximum distance

✓ Linear Space

78.3K Views

Medium Frequency

~15 min Avg. Time

1.9K 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 (Check Every Seat) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler