Number Of Rectangles That Can Form The Largest Square

Number Of Rectangles That Can Form The Largest Square - Problem

Array Easy

Imagine you're a carpenter working with various rectangular pieces of wood. You have an array rectangles where rectangles[i] = [li, wi] represents the length and width of the i-th rectangle.

From each rectangle, you can cut out a square with side length k, but only if both dimensions are at least k (i.e., k <= li and k <= wi). For example, from a [4,6] rectangle, you can cut a square with side length up to 4.

Your goal: Find the largest possible square you can cut from any rectangle, then count how many rectangles can produce a square of that maximum size.

Input: An array of rectangles with their dimensions
Output: The number of rectangles that can form the largest possible square

Input & Output

example_1.py — Basic Case

$ Input: rectangles = [[5,8],[3,9],[5,12],[16,5]]

› Output: 3

💡 Note: The largest square we can cut is 5×5 from rectangles [5,8], [5,12], and [16,5]. Rectangle [3,9] can only make a 3×3 square, so it's not counted.

example_2.py — All Same Size

$ Input: rectangles = [[2,3],[3,7],[4,3],[3,7]]

› Output: 3

💡 Note: Maximum square size is 3 (min dimension). Rectangles [2,3], [4,3], and [3,7] can all make a 3×3 square, while [3,7] appears twice but we count each occurrence.

example_3.py — Single Rectangle

$ Input: rectangles = [[10,20]]

› Output: 1

💡 Note: Only one rectangle exists, and it can make a 10×10 square (limited by the shorter dimension). So the count is 1.

Constraints

1 <= rectangles.length <= 1000
rectangles[i].length == 2
1 <= li, wi <= 10⁹
All rectangle dimensions are positive integers

Visualization

Tap to expand

Understanding the Visualization

Identify Constraint

The maximum square size is limited by the rectangle's shorter dimension

Calculate Max Square

For each rectangle [l,w], max square = min(l,w)

Track Global Maximum

Find the largest square possible across all rectangles

Count Winners

Count how many rectangles can produce the maximum square

Key Takeaway

🎯 Key Insight: The maximum square from any rectangle is always limited by its shorter dimension - simply calculate min(length, width) for each rectangle!

Asked in

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

The optimal approach uses a single-pass algorithm with O(n) time complexity. For each rectangle, calculate the maximum square size as min(length, width). Track the global maximum and count rectangles that can produce this maximum square. Key insight: the largest square from any rectangle is simply its smaller dimension.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Optimal Solution	O(n)	O(1)	Find maximum and count in a single pass through the array
Two-Pass Brute Force	O(n)	O(1)	Find maximum square size first, then count rectangles that can make it

One-Pass Optimal Solution — Algorithm Steps

Initialize maxSquare = 0 and count = 0
For each rectangle, calculate squareSize = min(length, width)
If squareSize > maxSquare: update maxSquare and reset count = 1
If squareSize == maxSquare: increment count
Return count after single pass

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Rectangle 1

5×8 → square=5, maxSquare=5, count=1

Process Rectangle 2

3×9 → square=3, maxSquare=5, count=1 (no change)

Process Rectangle 3

5×12 → square=5, maxSquare=5, count=2 (equal to max)

Process Rectangle 4

16×5 → square=5, maxSquare=5, count=3 (equal to max)

Code -

solution.c — C

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

int min(int a, int b) {
    return (a < b) ? a : b;
}

int countGoodRectangles(int** rectangles, int rectanglesSize) {
    int maxSquare = 0;
    int count = 0;
    
    for (int i = 0; i < rectanglesSize; i++) {
        int squareSize = min(rectangles[i][0], rectangles[i][1]);
        
        if (squareSize > maxSquare) {
            maxSquare = squareSize;
            count = 1; // Reset count for new maximum
        } else if (squareSize == maxSquare) {
            count++; // Increment count for current maximum
        }
    }
    
    return count;
}

int main() {
    int data[4][2] = {{5,8},{3,9},{5,12},{16,5}};
    int* rectangles[4];
    for (int i = 0; i < 4; i++) {
        rectangles[i] = data[i];
    }
    printf("%d\n", countGoodRectangles(rectangles, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array of n rectangles, each operation is O(1)

✓ Linear Growth

Space Complexity

O(1)

Only uses constant space for maxSquare and count variables

✓ Linear Space

24.5K Views

Medium Frequency

~8 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

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler