Codestin Search App

Largest Rectangle in Histogram - Problem

Imagine you're looking at a histogram - a bar chart where each bar has a height and width of 1 unit. Your task is to find the largest rectangle that can be formed within this histogram.

Given an array heights where heights[i] represents the height of the i-th bar, you need to calculate the maximum area of any rectangle that can be formed using one or more consecutive bars.

The key insight is that a rectangle's height is limited by the shortest bar it contains, but it can extend horizontally as far as possible while maintaining that minimum height.

Example: For heights [2,1,5,6,2,3], the largest rectangle has area 10 (height=5, width=2, using bars at indices 2 and 3).

Input & Output

example_1.py — Basic Case

$ Input: [2,1,5,6,2,3]

› Output: 10

💡 Note: The largest rectangle has area 10, formed by bars with heights [5,6] (indices 2-3). The rectangle has height 5 (minimum of the two bars) and width 2, giving area 5×2=10.

example_2.py — Single Bar

$ Input: [2,4]

› Output: 4

💡 Note: We can choose either a rectangle of height 2 and width 2 (area=4) or height 4 and width 1 (area=4). Both give the same maximum area of 4.

example_3.py — Edge Case

$ Input: [1]

› Output: 1

💡 Note: With only one bar of height 1, the largest (and only) rectangle has area 1×1=1.

Constraints

1 ≤ heights.length ≤ 10⁵
0 ≤ heights[i] ≤ 10⁴
All heights are non-negative integers

Visualization

Tap to expand

Understanding the Visualization

Survey the Skyline

Look at all buildings and identify potential billboard positions

Track Promising Buildings

Keep a list of buildings where billboards could start, in height order

Hit a Shorter Building

When you reach a shorter building, calculate rectangles ending there

Find Maximum Area

The billboard with the largest area is your answer

Key Takeaway

🎯 Key Insight: Use a monotonic stack to efficiently track potential rectangle starting positions. When heights decrease, we can immediately calculate all rectangles ending at that point!

Asked in

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

The optimal solution uses a monotonic stack approach with O(n) time complexity. We maintain a stack of bar indices in increasing height order. When we encounter a shorter bar, we calculate the maximum rectangle area using previously seen taller bars. This elegant technique ensures each bar is processed exactly once, making it highly efficient for large inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Brute Force (Stack Approach)	O(n)	O(n)	Use monotonic stack to efficiently find largest rectangle
Brute Force (All Subarrays)	O(n³)	O(1)	Check every possible rectangle by examining all subarrays

Optimized Brute Force (Stack Approach) — Algorithm Steps

Iterate through each bar in the histogram
Maintain a stack of bar indices in increasing height order
When current bar is shorter than stack top, pop and calculate area
For each popped bar, it becomes the height of rectangle extending back
Add current bar index to stack and continue

Visualization

Tap to expand

Step-by-Step Walkthrough

Push Increasing Heights

Add bar indices to stack while heights are increasing

Encounter Shorter Bar

When we find a shorter bar, we need to process taller ones

Pop and Calculate

Pop indices and calculate rectangle areas using the popped height

Continue Process

Repeat until stack is empty or heights are increasing again

Code -

solution.c — C

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

int largestRectangleArea(int* heights, int n) {
    int* stack = (int*)malloc(n * sizeof(int));
    int top = -1;
    int maxArea = 0;
    
    for (int i = 0; i < n; i++) {
        // Process bars that are taller than current bar
        while (top >= 0 && heights[stack[top]] > heights[i]) {
            int h = heights[stack[top--]];
            int w = top == -1 ? i : i - stack[top] - 1;
            int area = h * w;
            if (area > maxArea) maxArea = area;
        }
        stack[++top] = i;
    }
    
    // Process remaining bars in stack
    while (top >= 0) {
        int h = heights[stack[top--]];
        int w = top == -1 ? n : n - stack[top] - 1;
        int area = h * w;
        if (area > maxArea) maxArea = area;
    }
    
    free(stack);
    return maxArea;
}

int main() {
    int heights[1000];
    int n = 0;
    char c;
    
    scanf("%c", &c); // skip '['
    while (scanf("%d", &heights[n]) == 1) {
        n++;
        scanf("%c", &c);
        if (c == ']') break;
    }
    
    printf("%d\n", largestRectangleArea(heights, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each bar is pushed and popped from stack at most once, giving us linear time

✓ Linear Growth

Space Complexity

O(n)

Stack can contain up to n elements in worst case (strictly increasing heights)

⚡ Linearithmic Space

67.0K Views

High Frequency

~25 min Avg. Time

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

Optimized Brute Force (Stack Approach) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler