Maximal Rectangle - Practice Coding Problems

Maximal Rectangle - Problem

Given a rows x cols binary matrix filled with 0's and 1's, find the largest rectangle containing only 1's and return its area.

The rectangle must be axis-aligned (no rotation allowed) and can be anywhere within the matrix.

Example: In matrix [[1,0,1,0,0],[1,0,1,1,1],[1,1,1,1,1],[1,0,0,1,0]], the largest rectangle of 1's has area 6.

Input & Output

Example 1 — Basic Rectangle

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

› Output: 6

💡 Note: The largest rectangle is from (1,2) to (2,4) with height 2 and width 3, giving area 2×3 = 6

Example 2 — Single Row

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

› Output: 1

💡 Note: The largest rectangle is the single cell (0,1) containing "1", giving area 1

Example 3 — All Zeros

$ Input: matrix = [["0"]]

› Output: 0

💡 Note: No rectangle of 1s exists, so the maximum area is 0

Constraints

rows == matrix.length
cols == matrix[i].length
1 ≤ rows, cols ≤ 200
matrix[i][j] is '0' or '1'

Visualization

Tap to expand

Understanding the Visualization

Input Matrix

Binary matrix with 0s and 1s

Find Rectangle

Identify largest rectangle containing only 1s

Calculate Area

Return area of the maximal rectangle

Key Takeaway

🎯 Key Insight: Convert 2D rectangle problem into multiple 1D histogram problems using height arrays and monotonic stack

Asked in

a Amazon 42 G Google 38 M Microsoft 29 f Facebook 25

The key insight is to transform the 2D matrix problem into multiple 1D histogram problems. For each row, calculate the heights of consecutive 1s, then find the largest rectangle in that histogram using a monotonic stack. Best approach uses dynamic programming with stack optimization achieving Time: O(mn), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Check All Rectangles	O(m²n²mn)	O(1)	Check every possible rectangle by trying all corner combinations
Optimized Stack with Heights	O(mn)	O(n)	Use monotonic stack to efficiently solve histogram subproblems
Dynamic Programming with Heights	O(mn)	O(n)	Convert to histogram problem for each row using height arrays

Brute Force - Check All Rectangles — Algorithm Steps

For each cell (i,j) as top-left corner
For each cell (x,y) as bottom-right corner where x≥i, y≥j
Check if rectangle from (i,j) to (x,y) contains only 1s
Update maximum area if valid rectangle found

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick Top-Left

Choose starting corner (i,j)

Try All Bottom-Right

Test every possible ending corner

Validate Rectangle

Check if all cells in rectangle are 1s

Code -

solution.c — C

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

int solution(char matrix[][100], int rows, int cols) {
    if (rows == 0 || cols == 0) return 0;
    
    int maxArea = 0;
    
    // Try all possible top-left corners
    for (int top = 0; top < rows; top++) {
        for (int left = 0; left < cols; left++) {
            // Try all possible bottom-right corners
            for (int bottom = top; bottom < rows; bottom++) {
                for (int right = left; right < cols; right++) {
                    // Check if rectangle contains only 1s
                    int valid = 1;
                    for (int i = top; i <= bottom && valid; i++) {
                        for (int j = left; j <= right; j++) {
                            if (matrix[i][j] == '0') {
                                valid = 0;
                                break;
                            }
                        }
                    }
                    
                    if (valid) {
                        int area = (bottom - top + 1) * (right - left + 1);
                        if (area > maxArea) {
                            maxArea = area;
                        }
                    }
                }
            }
        }
    }
    
    return maxArea;
}

int main() {
    char matrix[100][100];
    int rows = 0, cols = 0;
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing
    int i = 0, j = 0;
    for (int k = 0; line[k]; k++) {
        if (line[k] == '0' || line[k] == '1') {
            matrix[i][j++] = line[k];
        } else if (line[k] == ']' && line[k+1] == ',') {
            if (cols == 0) cols = j;
            i++;
            j = 0;
        }
    }
    if (j > 0) {
        if (cols == 0) cols = j;
        i++;
    }
    rows = i;
    
    printf("%d\n", solution(matrix, rows, cols));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²mn)

Four nested loops for corners O(m²n²) and checking each rectangle O(mn)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for tracking coordinates and maximum area

✓ Linear Space

269.4K Views

High Frequency

~35 min Avg. Time

8.4K 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 Rectangles — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler