Maximize Area of Square Hole in Grid - Problem

Array Sorting Medium

You are given two integers n and m representing a grid with n + 2 horizontal and m + 2 vertical bars, creating 1 x 1 unit cells. The bars are indexed starting from 1.

You are also given two integer arrays hBars and vBars representing the bars that can be removed from horizontal and vertical bars respectively. Note that other bars are fixed and cannot be removed.

Return an integer denoting the maximum area of a square-shaped hole that can be created in the grid after removing some bars (possibly none).

Input & Output

Example 1 — Basic Grid

$ Input: n = 2, m = 3, hBars = [2, 3], vBars = [2, 4]

› Output: 4

💡 Note: Remove horizontal bars 2,3 and vertical bars 2,4 to create a 2×2 square hole with area 4.

Example 2 — Small Grid

$ Input: n = 1, m = 1, hBars = [2], vBars = [2]

› Output: 4

💡 Note: Remove both removable bars to create a 2×2 square hole.

Example 3 — No Removable Bars

$ Input: n = 2, m = 2, hBars = [], vBars = []

› Output: 1

💡 Note: Cannot remove any bars, so maximum hole is 1×1 with area 1.

Constraints

1 ≤ n, m ≤ 100
1 ≤ hBars.length, vBars.length ≤ n+1, m+1
1 ≤ hBars[i] ≤ n+1
1 ≤ vBars[i] ≤ m+1

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is that the maximum square area is limited by the shortest dimension. We need to find the longest consecutive sequence of removable bars in both directions. The optimal approach sorts the arrays and finds consecutive sequences in O(n log n) time and O(1) space.

Common Approaches

✓ Sort First

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

Brute Force - Try All Combinations

⏱️ Time: O(2^(|hBars| + |vBars|)) Space: O(n × m)

Generate all possible subsets of removable bars, remove them, and calculate the maximum square hole area for each combination. This involves checking all 2^n × 2^m combinations.

Optimized - Find Longest Consecutive Sequences

⏱️ Time: O(n log n + m log m) Space: O(1)

Instead of trying all combinations, sort the removable bars and find the longest consecutive sequence in each direction. The maximum square is limited by the shorter dimension.

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 compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int findMaxConsecutive(int* arr, int size) {
    if (size == 0) return 0;
    
    qsort(arr, size, sizeof(int), compare);
    
    int maxLen = 1;
    int currentLen = 1;
    
    for (int i = 1; i < size; i++) {
        if (arr[i] == arr[i-1] + 1) {
            currentLen++;
            if (currentLen > maxLen) {
                maxLen = currentLen;
            }
        } else {
            currentLen = 1;
        }
    }
    
    return maxLen;
}

int maximizeSquareHoleArea(int n, int m, int* hBars, int hBarsSize, int* vBars, int vBarsSize) {
    if (hBarsSize == 0 || vBarsSize == 0) {
        return 0;
    }
    
    int maxHorizontal = findMaxConsecutive(hBars, hBarsSize);
    int maxVertical = findMaxConsecutive(vBars, vBarsSize);
    
    int sideLength = (maxHorizontal < maxVertical) ? maxHorizontal : maxVertical;
    
    return sideLength * sideLength;
}

int main() {
    char line[10000];
    int n, m;
    int hBars[1000], vBars[1000];
    int hBarsSize, vBarsSize;
    
    // Read n
    fgets(line, sizeof(line), stdin);
    n = atoi(line);
    
    // Read m
    fgets(line, sizeof(line), stdin);
    m = atoi(line);
    
    // Read hBars array
    fgets(line, sizeof(line), stdin);
    parseArray(line, hBars, &hBarsSize);
    
    // Read vBars array
    fgets(line, sizeof(line), stdin);
    parseArray(line, vBars, &vBarsSize);
    
    int result = maximizeSquareHoleArea(n, m, hBars, hBarsSize, vBars, vBarsSize);
    
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

✓ Linear Space

8.8K Views

Medium Frequency

~25 min Avg. Time

234 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