Maximize Area of Square Hole in Grid - Practice Coding Problems

Maximize Area of Square Hole in Grid - Problem

Array Sorting Medium

Maximize Area of Square Hole in Grid

Imagine you have a grid made up of removable bars - some horizontal, some vertical. Your mission is to strategically remove some of these bars to create the largest possible square-shaped hole in the grid!

You're given:
• A grid with n + 2 horizontal bars and m + 2 vertical bars
• Two arrays: hBars (removable horizontal bars) and vBars (removable vertical bars)
• All other bars are fixed and cannot be removed

The bars create a grid of 1×1 unit cells. When you remove consecutive bars, you create holes. Your goal is to find the maximum area of a square-shaped hole you can create by removing some (or none) of the bars from the given arrays.

Key insight: To form a square hole of side length k, you need k consecutive removable bars both horizontally and vertically!

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: We can remove horizontal bars 2 and 3 (consecutive) and vertical bar 2. This creates a 2×2 square hole with area 4.

example_2.py — Larger Grid

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

› Output: 4

💡 Note: We can remove horizontal bar 2 and vertical bars 2,3 (consecutive). The square is limited by the shorter dimension: min(1,2)+1 = 2, so area = 4.

example_3.py — No Consecutive Bars

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

› Output: 1

💡 Note: No consecutive bars can be removed, so we can only create individual 1×1 holes. Maximum area is 1.

Visualization

Tap to expand

Understanding the Visualization

Identify Removable Bars

Mark which horizontal and vertical bars can be removed from the grid

Sort by Position

Arrange removable bars in order to easily find consecutive sequences

Find Consecutive Groups

Locate the longest consecutive sequences in both directions

Calculate Square Size

The square is constrained by the shorter of the two consecutive sequences

Key Takeaway

🎯 Key Insight: The maximum square hole is constrained by the shorter of the two longest consecutive removable bar sequences, requiring only sorting and linear scanning for an optimal solution.

Time & Space Complexity

Time Complexity

⏱️

O((h + v) log(h + v))

Sorting both arrays takes O(h log h + v log v), finding consecutive sequences takes O(h + v)

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables to track consecutive sequences, sorting can be done in-place

✓ Linear Space

Constraints

1 ≤ n, m ≤ 10⁵
1 ≤ hBars.length, vBars.length ≤ 10⁵
1 ≤ hBars[i] ≤ n + 1
1 ≤ vBars[i] ≤ m + 1
All values in hBars and vBars are unique
Bars are indexed from 1 to n+1 (horizontal) and 1 to m+1 (vertical)

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The key insight is that to form a square hole, we need consecutive removable bars in both directions. The optimal approach is to sort both bar arrays and find the longest consecutive sequence in each. The maximum square area equals (min(max_h_consecutive, max_v_consecutive) + 1)², achieved in O((h+v) log(h+v)) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Sliding Window	O((h + v) log(h + v))	O(1)	Sort bars and find longest consecutive sequences efficiently
Brute Force (All Combinations)	O(2^(h+v) × (h+v))	O(h + v)	Try all possible combinations of removing bars and check maximum square

Sorting + Sliding Window — Algorithm Steps

Sort both hBars and vBars arrays
For each array, find all consecutive subsequences
Track the maximum length consecutive sequence for horizontal bars
Track the maximum length consecutive sequence for vertical bars
Return (min(maxH, maxV) + 1)²

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Arrays

Sort both hBars and vBars to group consecutive numbers together

Find Consecutive H-Bars

Scan sorted horizontal bars to find longest consecutive sequence

Find Consecutive V-Bars

Scan sorted vertical bars to find longest consecutive sequence

Calculate Square

Square side = min(max_h_consecutive, max_v_consecutive) + 1

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int findMaxConsecutive(int* bars, int barsSize) {
    if (barsSize == 0) return 0;
    
    qsort(bars, barsSize, sizeof(int), compare);
    int maxLen = 1, currentLen = 1;
    
    for (int i = 1; i < barsSize; i++) {
        if (bars[i] == bars[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) {
    int maxH = findMaxConsecutive(hBars, hBarsSize);
    int maxV = findMaxConsecutive(vBars, vBarsSize);
    
    int sideLength = (maxH < maxV ? maxH : maxV) + 1;
    return sideLength * sideLength;
}

Time & Space Complexity

Time Complexity

⏱️

O((h + v) log(h + v))

Sorting both arrays takes O(h log h + v log v), finding consecutive sequences takes O(h + v)

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables to track consecutive sequences, sorting can be done in-place

✓ Linear Space

Constraints

1 ≤ n, m ≤ 10⁵
1 ≤ hBars.length, vBars.length ≤ 10⁵
1 ≤ hBars[i] ≤ n + 1
1 ≤ vBars[i] ≤ m + 1
All values in hBars and vBars are unique
Bars are indexed from 1 to n+1 (horizontal) and 1 to m+1 (vertical)

23.4K Views

Medium Frequency

~18 min Avg. Time

892 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

Sorting + Sliding Window — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler