Maximal Rectangle - Practice Coding Problems

Maximal Rectangle - Problem

Imagine you're a city planner looking at a blueprint from above, where 1's represent buildable land and 0's represent water or restricted areas. Your task is to find the largest rectangular plot that can be built on, containing only buildable land (1's).

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

Example: In a matrix like [[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 (a 2×3 rectangle).

Input & Output

example_1.py — Standard Case

$ 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 maximal rectangle is formed by the 2×3 rectangle in the bottom-right area, containing only 1's with area 6

example_2.py — Single Row

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

› Output: 1

💡 Note: Single cell containing '1' forms a rectangle of area 1

example_3.py — All Zeros

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

› Output: 0

💡 Note: No rectangle can be formed with only 1's since all cells contain 0's

Visualization

Tap to expand

Understanding the Visualization

Survey the Land

Look at the blueprint where 1's are buildable land and 0's are restricted areas

Build Height Profile

For each row, measure how tall we could build at each column (consecutive 1's above)

Find Best Rectangle

Use smart measuring tools (monotonic stack) to efficiently find the largest rectangular plot

Compare All Options

Repeat for each row and keep track of the best rectangular plot found

Key Takeaway

🎯 Key Insight: Transform the 2D rectangle problem into multiple 1D histogram problems, then use a monotonic stack to efficiently solve each histogram in linear time.

Time & Space Complexity

Time Complexity

⏱️

O(mn)

O(mn) to build heights + O(mn) for histogram processing (each element pushed/popped once)

✓ Linear Growth

Space Complexity

O(n)

O(n) for heights array + O(n) for stack in worst case

⚡ Linearithmic Space

Constraints

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

Asked in

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

The optimal solution uses dynamic programming with histogram transformation. For each row, we calculate the height of consecutive 1's above (forming a histogram), then apply the monotonic stack algorithm to find the largest rectangle in each histogram. This reduces the 2D problem to multiple 1D problems with O(mn) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Histogram	O(mn)	O(n)	Transform each row into histogram heights, then find largest rectangle in each histogram
Brute Force (All Rectangles)	O(m³n³)	O(1)	Check every possible rectangle by trying all corner combinations

Dynamic Programming with Histogram — Algorithm Steps

For each row, calculate heights: consecutive 1's above (including current cell)
If current cell is '0', height is 0; if '1', height is previous row's height + 1
Apply largest rectangle in histogram algorithm to each row's heights
Use monotonic stack to efficiently find largest rectangle in each histogram
Track maximum area across all rows

Visualization

Tap to expand

Step-by-Step Walkthrough

Build height array

For each row, calculate consecutive 1's above (histogram heights)

Apply histogram algorithm

Use monotonic stack to find largest rectangle in current histogram

Process next row

Update heights and repeat for next row

Track maximum

Keep track of the largest rectangle found across all rows

Code -

solution.c — C

int largestRectangleArea(int* heights, int heightsSize) {
    int* stack = (int*)malloc((heightsSize + 1) * sizeof(int));
    int top = -1;
    int maxArea = 0;
    
    for (int i = 0; i <= heightsSize; i++) {
        int h = i == heightsSize ? 0 : heights[i];
        while (top >= 0 && heights[stack[top]] > h) {
            int height = heights[stack[top--]];
            int width = top == -1 ? i : i - stack[top] - 1;
            int area = height * width;
            if (area > maxArea) maxArea = area;
        }
        stack[++top] = i;
    }
    
    free(stack);
    return maxArea;
}

int maximalRectangle(char** matrix, int matrixSize, int* matrixColSize) {
    if (matrixSize == 0 || matrixColSize[0] == 0) return 0;
    
    int rows = matrixSize, cols = matrixColSize[0];
    int* heights = (int*)calloc(cols, sizeof(int));
    int maxArea = 0;
    
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            heights[j] = matrix[i][j] == '1' ? heights[j] + 1 : 0;
        }
        int area = largestRectangleArea(heights, cols);
        if (area > maxArea) maxArea = area;
    }
    
    free(heights);
    return maxArea;
}

Time & Space Complexity

Time Complexity

⏱️

O(mn)

O(mn) to build heights + O(mn) for histogram processing (each element pushed/popped once)

✓ Linear Growth

Space Complexity

O(n)

O(n) for heights array + O(n) for stack in worst case

⚡ Linearithmic Space

Constraints

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

48.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 with Histogram — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler