Maximal Square

Maximal Square - Problem

Find the Largest Square of 1s in a Binary Matrix

You're given an m x n binary matrix filled with 0s and 1s. Your task is to find the largest square that contains only 1s and return its area.

Think of this matrix as a grid where 1 represents a solid block and 0 represents empty space. You need to find the biggest perfect square you can form using only the solid blocks.

Example:

[[1,0,1,0,0],
 [1,0,1,1,1],
 [1,1,1,1,1],
 [1,0,0,1,0]]

The largest square of 1s has side length 2, so the answer is 4 (area = 2 × 2).

Input & Output

example_1.py — Basic Square

$ Input: [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]

› Output: 4

💡 Note: The largest square of 1s has side length 2 (in rows 1-2, cols 2-3), so area = 2×2 = 4

example_2.py — Single Cell

$ Input: [["0","1"],["1","0"]]

› Output: 1

💡 Note: The largest square of 1s has side length 1 (any single '1'), so area = 1×1 = 1

example_3.py — No Squares

$ Input: [["0"]]

› Output: 0

💡 Note: No 1s in the matrix, so no square can be formed, area = 0

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 300
matrix[i][j] is '0' or '1'

Visualization

Tap to expand

Asked in

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

The optimal solution uses Dynamic Programming with the key insight that for any cell (i,j), the largest square ending there equals min(left, top, diagonal) + 1. This achieves O(m×n) time complexity compared to the brute force O(m²n²) approach.

Common Approaches

✓ Greedy

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

Brute Force (Check All Squares)

⏱️ Time: O(m²n²) Space: O(1)

This approach checks every possible square in the matrix. For each cell that contains a '1', we treat it as the top-left corner of a potential square and keep expanding the square size until we encounter a '0' or reach the matrix boundary.

Dynamic Programming (Optimal)

⏱️ Time: O(m×n) Space: O(m×n)

This is the optimal approach using dynamic programming. The key insight is that for any cell (i,j), the largest square ending at that position depends on the largest squares ending at positions (i-1,j), (i,j-1), and (i-1,j-1). We can compute this in a single pass through the matrix.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int pos;
    int height;
} Point;

int comparePoints(const void *a, const void *b) {
    Point *pa = (Point*)a;
    Point *pb = (Point*)b;
    return pa->pos - pb->pos;
}

int solution(int n, int restrictionMap[][2], int restrictionCount) {
    Point points[1001];
    int pointCount = 1;
    points[0].pos = 1;
    points[0].height = 0;
    
    for (int i = 0; i < restrictionCount; i++) {
        points[pointCount].pos = restrictionMap[i][0];
        points[pointCount].height = restrictionMap[i][1];
        pointCount++;
    }
    
    qsort(points, pointCount, sizeof(Point), comparePoints);
    
    // Forward pass
    for (int i = 1; i < pointCount; i++) {
        int prevPos = points[i-1].pos;
        int prevHeight = points[i-1].height;
        int currPos = points[i].pos;
        int currMax = points[i].height;
        int dist = currPos - prevPos;
        if (prevHeight + dist < currMax) {
            points[i].height = prevHeight + dist;
        }
    }
    
    // Backward pass
    for (int i = pointCount - 2; i >= 0; i--) {
        int currPos = points[i].pos;
        int currHeight = points[i].height;
        int nextPos = points[i+1].pos;
        int nextHeight = points[i+1].height;
        int dist = nextPos - currPos;
        if (nextHeight + dist < currHeight) {
            points[i].height = nextHeight + dist;
        }
    }
    
    int maxHeight = 0;
    
    // Check heights at restriction points
    for (int i = 0; i < pointCount; i++) {
        if (points[i].height > maxHeight) {
            maxHeight = points[i].height;
        }
    }
    
    // Check peaks between consecutive restrictions
    for (int i = 0; i < pointCount - 1; i++) {
        int pos1 = points[i].pos, h1 = points[i].height;
        int pos2 = points[i+1].pos, h2 = points[i+1].height;
        if (pos2 - pos1 > 1) {
            int dist = pos2 - pos1;
            int peakPos = dist / 2;
            int peakHeight = h1 + peakPos;
            if (h2 + (dist - peakPos) < peakHeight) {
                peakHeight = h2 + (dist - peakPos);
            }
            if (peakHeight > maxHeight) {
                maxHeight = peakHeight;
            }
        }
    }
    
    // Check segment after last restriction
    if (pointCount > 0) {
        int lastPos = points[pointCount-1].pos;
        int lastHeight = points[pointCount-1].height;
        if (lastPos < n) {
            int remaining = n - lastPos;
            if (lastHeight + remaining > maxHeight) {
                maxHeight = lastHeight + remaining;
            }
        }
    }
    
    return maxHeight;
}

int main() {
    int n;
    scanf("%d", &n);
    getchar();
    
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int restrictions[100][2];
    int restrictionCount = 0;
    
    if (strcmp(line, "[]\n") != 0) {
        char* ptr = line + 1;
        while (*ptr != ']' && *ptr != '\0') {
            if (*ptr == '[') {
                ptr++;
                sscanf(ptr, "%d,%d", &restrictions[restrictionCount][0], &restrictions[restrictionCount][1]);
                restrictionCount++;
                while (*ptr != ']' && *ptr != '\0') ptr++;
            }
            ptr++;
        }
    }
    
    printf("%d\n", solution(n, restrictions, restrictionCount));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

68.0K Views

High Frequency

~25 min Avg. Time

1.9K 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