Maximum Square Area by Removing Fences From a Field

Maximum Square Area by Removing Fences From a Field - Problem

Imagine you're a landscape architect working with a large rectangular field that's divided by various fences. Your goal is to create the largest possible square area by strategically removing some of these fences!

You have a field with dimensions (m-1) × (n-1) that spans from coordinate (1,1) to (m,n). The field contains:

Horizontal fences: Each fence at position hFences[i] runs from (hFences[i], 1) to (hFences[i], n)
Vertical fences: Each fence at position vFences[i] runs from (1, vFences[i]) to (m, vFences[i])

Important: The field has a permanent border (four outer fences) that cannot be removed.

Your task is to find the maximum area of a square that can be formed by removing some fences (or keeping all of them). Return the area modulo 10^9 + 7, or -1 if no square can be formed.

Input & Output

example_1.py — Basic Square Formation

$ Input: m = 4, n = 3, hFences = [2, 3], vFences = [2]

› Output: 4

💡 Note: We can form a square with side length 2 by using boundaries at positions 1 and 3 horizontally, and 1 and 3 vertically. This gives us area = 2² = 4.

example_2.py — Large Square Possible

$ Input: m = 6, n = 7, hFences = [2], vFences = [4]

› Output: 9

💡 Note: The maximum square has side length 3, formed using various fence combinations. The area is 3² = 9.

example_3.py — No Square Possible

$ Input: m = 4, n = 3, hFences = [], vFences = []

› Output: 9

💡 Note: With just the boundary fences, we can form a 3×3 square (limited by the smaller dimension), so area = 9.

Visualization

Tap to expand

Understanding the Visualization

Map the Field

Identify all fence positions including permanent boundaries

Calculate Distances

Compute all possible horizontal and vertical distances

Find Valid Squares

Identify distances that work for both dimensions

Maximize Area

Select the largest valid square and return its area

Key Takeaway

🎯 Key Insight: By pre-computing all possible distances and using hash sets for intersection, we can efficiently find the maximum valid square without checking every combination individually.

Time & Space Complexity

Time Complexity

⏱️

O(h² + v²)

O(h²) to generate horizontal distances and O(v²) for vertical distances, where h and v are number of fences

✓ Linear Growth

Space Complexity

O(h² + v²)

Space needed to store all possible horizontal and vertical distances in hash sets

✓ Linear Space

Constraints

3 ≤ m, n ≤ 10⁹
1 ≤ hFences.length, vFences.length ≤ 1000
1 < hFences[i] < m
1 < vFences[i] < n
All fence positions are unique within their respective arrays

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses hash sets to efficiently compute all possible distances between fence pairs. By finding the intersection of horizontal and vertical distances, we can identify valid square side lengths in O(h² + v²) time, which is much better than the brute force O(h² × v²) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Hash Set Approach	O(h² + v²)	O(h² + v²)	Use hash sets to efficiently find all possible side lengths and determine maximum square
Brute Force (Check All Possible Squares)	O(h² × v²)	O(1)	Try every possible square position and size, checking if it can be formed

Optimized Hash Set Approach — Algorithm Steps

Add boundary coordinates and remove duplicates from fence arrays
Generate all possible horizontal distances and store in a set
Generate all possible vertical distances and store in a set
Find intersection of horizontal and vertical distance sets
Return the maximum common distance squared, or -1 if no common distance exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Compute Horizontal Distances

Generate all possible distances between horizontal fence pairs

Compute Vertical Distances

Generate all possible distances between vertical fence pairs

Find Intersection

Identify common distances that can form valid squares

Return Maximum

Square the largest common distance for maximum area

Code -

solution.c — C

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

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

int maximizeSquareArea(int m, int n, int* hFences, int hFencesSize, int* vFences, int vFencesSize) {
    const int MOD = 1000000007;
    const int MAX_DIST = 1000000;
    
    // Create arrays with boundaries
    int hSize = hFencesSize + 2;
    int vSize = vFencesSize + 2;
    
    int* hArray = (int*)malloc(hSize * sizeof(int));
    int* vArray = (int*)malloc(vSize * sizeof(int));
    bool* hDistances = (bool*)calloc(MAX_DIST + 1, sizeof(bool));
    
    // Add boundaries
    hArray[0] = 1; hArray[1] = m;
    vArray[0] = 1; vArray[1] = n;
    
    for (int i = 0; i < hFencesSize; i++) {
        hArray[i + 2] = hFences[i];
    }
    for (int i = 0; i < vFencesSize; i++) {
        vArray[i + 2] = vFences[i];
    }
    
    // Sort and remove duplicates (simplified)
    qsort(hArray, hSize, sizeof(int), compare);
    qsort(vArray, vSize, sizeof(int), compare);
    
    // Generate horizontal distances
    for (int i = 0; i < hSize; i++) {
        for (int j = i + 1; j < hSize; j++) {
            int dist = hArray[j] - hArray[i];
            if (dist <= MAX_DIST) {
                hDistances[dist] = true;
            }
        }
    }
    
    // Find maximum common vertical distance
    int maxSide = 0;
    for (int i = 0; i < vSize; i++) {
        for (int j = i + 1; j < vSize; j++) {
            int dist = vArray[j] - vArray[i];
            if (dist <= MAX_DIST && hDistances[dist]) {
                if (dist > maxSide) {
                    maxSide = dist;
                }
            }
        }
    }
    
    free(hArray);
    free(vArray);
    free(hDistances);
    
    if (maxSide == 0) {
        return -1;
    }
    
    return ((long long)maxSide * maxSide) % MOD;
}

Time & Space Complexity

Time Complexity

⏱️

O(h² + v²)

O(h²) to generate horizontal distances and O(v²) for vertical distances, where h and v are number of fences

✓ Linear Growth

Space Complexity

O(h² + v²)

Space needed to store all possible horizontal and vertical distances in hash sets

✓ Linear Space

Constraints

3 ≤ m, n ≤ 10⁹
1 ≤ hFences.length, vFences.length ≤ 1000
1 < hFences[i] < m
1 < vFences[i] < n
All fence positions are unique within their respective arrays

23.5K Views

Medium-High Frequency

~25 min Avg. Time

847 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

Optimized Hash Set Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler