Maximum Side Length of a Square with Sum Less than or Equal to Threshold

Maximum Side Length of a Square with Sum Less than or Equal to Threshold - Problem

Imagine you're analyzing satellite images of farmland divided into a grid, where each cell represents the crop yield value for that area. You need to find the largest square region where the total crop yield doesn't exceed a given threshold.

Given an m x n matrix mat where each cell contains a non-negative integer, and an integer threshold, return the maximum side length of a square subregion whose sum is less than or equal to the threshold.

If no such square exists, return 0.

Example: In a 3×3 grid with threshold 4, a 2×2 square with sum 4 would be valid, but a 2×2 square with sum 5 would not be.

Input & Output

example_1.py — Basic Square

$ Input: mat = [[1,1,3,2,4,3,2],[1,1,3,2,4,3,2],[1,1,3,2,4,3,2]], threshold = 4

› Output: 2

💡 Note: The maximum side length of a square with sum ≤ 4 is 2. The 2×2 square at top-left has sum 1+1+1+1 = 4.

example_2.py — No Valid Square

$ Input: mat = [[2,2,2,2,5,5],[2,2,2,2,5,5],[2,2,2,2,5,5]], threshold = 1

› Output: 0

💡 Note: No square (even 1×1) has sum ≤ 1 since all elements are ≥ 2.

example_3.py — Large Square Possible

$ Input: mat = [[1,1,1,1],[1,0,0,1],[1,0,0,1],[1,1,1,1]], threshold = 6

› Output: 3

💡 Note: The 3×3 square starting at (0,1) has sum = 1+1+1+0+0+0+0+0+1 = 4 ≤ 6.

Constraints

1 ≤ m, n ≤ 300
0 ≤ mat[i][j] ≤ 10⁴
0 ≤ threshold ≤ 10⁵
The matrix contains only non-negative integers

Visualization

Tap to expand

Understanding the Visualization

Build Cost Database

Create prefix sums to instantly calculate any rectangular area cost

Smart Size Search

Use binary search instead of checking every size linearly

Quick Validation

For each candidate size, check all positions using O(1) sum calculations

Key Takeaway

🎯 Key Insight: Binary search on the answer eliminates the need to check every possible square size, while prefix sums make range sum queries instant. This combination transforms an O(n⁵) brute force into an efficient O(mn log n) solution.

Asked in

f Facebook 38 G Google 25 a Amazon 18 ⊞ Microsoft 12

The optimal solution uses binary search on the square size combined with 2D prefix sums for O(1) range sum queries. This achieves O(mn × log(min(m,n))) time complexity, much better than the brute force O(mn × min(m,n)³) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Squares)	O(m × n × min(m,n)³)	O(1)	Check every possible square by calculating sum directly
Binary Search + Prefix Sum (Optimal)	O(mn × log(min(m,n)))	O(mn)	Binary search on answer with prefix sums for O(1) range queries

Brute Force (Check All Squares) — Algorithm Steps

Try each possible square size from 1 to min(m,n)
For each size, try all possible top-left positions
For each position, calculate sum by iterating through the square
If sum ≤ threshold, update maximum size found
Return the maximum valid size

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with size 1

Check all 1x1 squares across the matrix

Try size 2

Check all 2x2 squares, calculating sum for each

Continue until max size

Keep increasing size until we've tried all possibilities

Code -

solution.c — C

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

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

int max(int a, int b) {
    return a > b ? a : b;
}

int numPointsInLargestSquare(int** mat, int m, int n, int threshold) {
    int maxSize = 0;
    
    // Try all possible square sizes
    for (int size = 1; size <= min(m, n); size++) {
        // Try all possible top-left positions
        for (int i = 0; i <= m - size; i++) {
            for (int j = 0; j <= n - size; j++) {
                // Calculate sum of current square
                int currentSum = 0;
                for (int r = i; r < i + size; r++) {
                    for (int c = j; c < j + size; c++) {
                        currentSum += mat[r][c];
                    }
                }
                
                // Check if this square is valid
                if (currentSum <= threshold) {
                    maxSize = max(maxSize, size);
                }
            }
        }
    }
    
    return maxSize;
}

int main() {
    int m, n;
    scanf("%d %d", &m, &n);
    
    int** mat = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        mat[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            scanf("%d", &mat[i][j]);
        }
    }
    
    int threshold;
    scanf("%d", &threshold);
    
    printf("%d\n", numPointsInLargestSquare(mat, m, n, threshold));
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(mat[i]);
    }
    free(mat);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n × min(m,n)³)

For each of O(mn) positions and O(min(m,n)) sizes, we sum O(size²) elements

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track current sum and maximum size

✓ Linear Space

28.4K Views

Medium-High Frequency

~25 min Avg. Time

876 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

Brute Force (Check All Squares) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler