Maximize Distance to Closest Person

Maximize Distance to Closest Person - Problem

Array Medium

You are given an array representing a row of seats where seats[i] = 1 represents a person sitting in the i-th seat, and seats[i] = 0 represents that the i-th seat is empty (0-indexed).

There is at least one empty seat, and at least one person sitting.

Alex wants to sit in the seat such that the distance between him and the closest person to him is maximized. Return that maximum distance to the closest person.

Input & Output

Example 1 — Basic Gap

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

› Output: 2

💡 Note: The largest gap is between positions 0 and 4. Sitting at position 2 gives distance 2 to the closest person.

Example 2 — End Position

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

› Output: 3

💡 Note: Sitting at the rightmost position (index 3) gives distance 3 to the person at index 0.

Example 3 — Multiple Gaps

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

› Output: 2

💡 Note: The gap between positions 1 and 5 has length 3, so sitting in the middle gives distance 2.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 f Facebook 15

The key insight is that the maximum distance occurs either at the ends or in the middle of the largest gap between consecutive people. Best approach is Gap Analysis with Time: O(n), Space: O(1).

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Dfs

⏱️ Time: N/A Space: N/A

Brute Force

⏱️ Time: O(n²) Space: O(1)

Check every empty seat position and calculate the minimum distance to any occupied seat. Keep track of the maximum such distance found.

Gap Analysis

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

The optimal seat is either at the ends of the array or in the middle of the largest gap between consecutive occupied seats. We only need to check these positions.

Two Pass Distance Calculation

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

Make two passes through the array: first from left to calculate distance to nearest person on the left, then from right for nearest person on the right. The minimum of these two distances at each position gives us the distance to closest person.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int maxDistToClosest(int* seats, int seatsSize) {
    int maxDist = 0;
    
    for (int i = 0; i < seatsSize; i++) {
        if (seats[i] == 0) { // Empty seat
            int leftDist = -1, rightDist = -1;
            
            // Find nearest person to the left
            for (int j = i - 1; j >= 0; j--) {
                if (seats[j] == 1) {
                    leftDist = i - j;
                    break;
                }
            }
            
            // Find nearest person to the right
            for (int j = i + 1; j < seatsSize; j++) {
                if (seats[j] == 1) {
                    rightDist = j - i;
                    break;
                }
            }
            
            // Calculate minimum distance to nearest person
            int minDist;
            if (leftDist == -1 && rightDist == -1) {
                minDist = seatsSize; // No people (shouldn't happen per problem)
            } else if (leftDist == -1) {
                minDist = rightDist;
            } else if (rightDist == -1) {
                minDist = leftDist;
            } else {
                minDist = (leftDist < rightDist) ? leftDist : rightDist;
            }
            
            if (minDist > maxDist) {
                maxDist = minDist;
            }
        }
    }
    
    return maxDist;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    input[strcspn(input, "\n")] = 0;
    
    static int seats[10000];
    int size;
    parseArray(input, seats, &size);
    
    int result = maxDistToClosest(seats, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~15 min Avg. Time

890 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