Maximal Square - Practice Coding Problems

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

Visualization

Tap to expand

Understanding the Visualization

Start with Basics

First row and column squares can only be size 1 if the cell contains '1'

Build from Previous

For any other cell, look at the three neighbors (left, top, diagonal) and take the minimum square size found there

Add Current Block

If current cell is '1', add 1 to the minimum neighbor value. This gives you the largest square ending at current position

Track Maximum

Keep track of the largest square side found throughout the process

Key Takeaway

🎯 Key Insight: Instead of checking every possible square from scratch, we build the solution incrementally by remembering what we've computed before. Each cell's answer depends on just three previously computed neighbors, making this an elegant O(mn) solution.

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Single pass through all cells in the matrix, constant work per cell

✓ Linear Growth

Space Complexity

O(m×n)

DP table of same size as input matrix (can be optimized to O(n))

⚡ Linearithmic Space

Constraints

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

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

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(m×n)	O(m×n)	Build solution using previously computed squares, processing matrix once
Brute Force (Check All Squares)	O(m²n²)	O(1)	For each cell, try to expand the largest possible square starting from that position

Dynamic Programming (Optimal) — Algorithm Steps

Create a DP table to store largest square side ending at each position
Initialize first row and column based on matrix values
For each cell, if it's '1', compute: min(left, top, diagonal) + 1
Keep track of maximum square side found so far
Return the area (max_side²) of the largest square

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP Table

Create table same size as matrix, fill with zeros

Process Cell by Cell

For each '1', compute min(left, top, diagonal) + 1

Update Maximum

Track the largest square side found so far

Return Area

Return max_side² as the final answer

Code -

solution.c — C

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

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

int maximalSquare(char** matrix, int matrixSize, int* matrixColSize) {
    if (matrixSize == 0 || matrixColSize[0] == 0) return 0;
    
    int rows = matrixSize, cols = matrixColSize[0];
    int** dp = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        dp[i] = (int*)calloc(cols, sizeof(int));
    }
    
    int maxSide = 0;
    
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (matrix[i][j] == '1') {
                if (i == 0 || j == 0) {
                    dp[i][j] = 1;
                } else {
                    dp[i][j] = min(min(dp[i-1][j], dp[i][j-1]), dp[i-1][j-1]) + 1;
                }
                if (dp[i][j] > maxSide) {
                    maxSide = dp[i][j];
                }
            }
        }
    }
    
    // Free memory
    for (int i = 0; i < rows; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return maxSide * maxSide;
}

int main() {
    printf("Dynamic Programming Solution\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Single pass through all cells in the matrix, constant work per cell

✓ Linear Growth

Space Complexity

O(m×n)

DP table of same size as input matrix (can be optimized to O(n))

⚡ Linearithmic Space

Constraints

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

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler