Maximum of minimums of every window size in a given array

Largest Rectangular Area in a Histogram

Last Updated : 18 Feb, 2025

Given a histogram represented by an array arr[], where each element of the array denotes the height of the bars in the histogram. All bars have the same width of 1 unit.

Task is to find the largest rectangular area possible in a given histogram where the largest rectangle can be made of a number of contiguous bars whose heights are given in an array.

Example:

Input: arr[] = [60, 20, 50, 40, 10, 50, 60]
Output: 100

Explanation: We get the maximum are by picking bars highlighted above in green (50, and 60). The area is computed (smallest height) * (no. of the picked bars) = 50 * 2 = 100.
Input: arr[] = [3, 5, 1, 7, 5, 9]
Output: 15
Explanation: We get the maximum are by picking bars 7, 5 and 9. The area is computed (smallest height) * (no. of the picked bars) = 5 * 3 = 15.

Table of Content

[Naive Approach] By Finding Max Area of Rectangles all Heights - O(n^2) Time and O(1) Space

The idea is to consider each bar as the minimum height and find the maximum area. We traverse toward left of it and add its height until we see a smaller element. We do the same thing for right side of it.
So the area with current bar as minimum is going to be height of current bar multiplied by total width traversed on both left and right including the current bar. The area is the bar’s height multiplied by the total traversed width. Finally, we return the maximum of all such areas.

C++

// C++ program to find the largest rectangular area possible 
// in a given histogram 
#include <bits/stdc++.h>
using namespace std;

// Function to calculate the maximum rectangular
// area in the Histogram
int getMaxArea(vector<int> &arr){
    int res = 0, n = arr.size();
  
    // Consider every bar one by one
    for(int i = 0; i < n; i++){
        int curr = arr[i];
      
        // Traverse left while we have a greater height bar
        for(int j = i-1; j>=0 && arr[j] >= arr[i]; j--)
             curr += arr[i];
      
        // Traverse right while we have a greater height bar      
        for(int j = i+1; j<n && arr[j] >= arr[i]; j++)
            curr += arr[i];
      
        res = max(res, curr);
    }
    return res;
}

int main() { 
    vector<int> arr =  {60, 20, 50, 40, 10, 50, 60};
    cout << getMaxArea(arr);
    return 0; 
}

// Cprogram to find the largest rectangular area possible 
// in a given histogram 
#include <stdio.h>

// Function to calculate the maximum rectangular
// area in the Histogram
int getMaxArea(int arr[], int n) {
    int res = 0;

    // Consider every bar one by one
    for (int i = 0; i < n; i++) {
        int curr = arr[i];

        // Traverse left while we have a greater height bar
        for (int j = i - 1; j >= 0 && arr[j] >= arr[i]; j--) {
            curr += arr[i];
        }

        // Traverse right while we have a greater height bar
        for (int j = i + 1; j < n && arr[j] >= arr[i]; j++) {
            curr += arr[i];
        }

        if (curr > res) {
            res = curr;
        }
    }

    return res;
}

int main() {
    int arr[] = {60, 20, 50, 40, 10, 50, 60};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("%d\n", getMaxArea(arr, n));
    return 0;
}

Java

// Java program to find the largest rectangular area possible 
// in a given histogram 
import java.util.*;

class GfG {
    
    // Function to calculate the maximum rectangular
    // area in the Histogram
    static int getMaxArea(int[] arr) {
        int res = 0, n = arr.length;
        
        for (int i = 0; i < n; i++) {
            int curr = arr[i];
            
            // Traverse left while we have a greater height bar
            for (int j = i - 1; j >= 0 && arr[j] >= arr[i]; j--)
                curr += arr[i];
            
            // Traverse right while we have a greater height bar
            for (int j = i + 1; j < n && arr[j] >= arr[i]; j++)
                curr += arr[i];
            
            res = Math.max(res, curr);
        }
        return res;
    }
    
    public static void main(String[] args) {
        int[] arr = {60, 20, 50, 40, 10, 50, 60};
        System.out.println(getMaxArea(arr));
    }
}

Python

# Python program to find the largest rectangular area possible 
# in a given histogram 

# Function to calculate the maximum rectangular
# area in the Histogram
def getMaxArea(arr):
    res = 0
    n = len(arr)
    
    for i in range(n):
        curr = arr[i]
        
        # Traverse left while we have a greater height bar
        j = i - 1
        while j >= 0 and arr[j] >= arr[i]:
            curr += arr[i]
            j -= 1
        
        # Traverse right while we have a greater height bar
        j = i + 1
        while j < n and arr[j] >= arr[i]:
            curr += arr[i]
            j += 1
        
        res = max(res, curr)
    
    return res
    
if __name__ == "__main__":
    arr = [60, 20, 50, 40, 10, 50, 60]
    print(getMaxArea(arr))

// C# program to find the largest rectangular area possible 
// in a given histogram 

using System;

class GfG {
    
    // Function to calculate the maximum rectangular
    // area in the Histogram
    static int getMaxArea(int[] arr) {
        int n = arr.Length;
        int res = 0;

        // Consider every bar one by one
        for (int i = 0; i < n; i++) {
            int curr = arr[i];

            // Traverse left while we have a greater height bar
            int j = i - 1;
            while (j >= 0 && arr[j] >= arr[i]) {
                curr += arr[i];
                j--;
            }

            // Traverse right while we have a greater height bar
            j = i + 1;
            while (j < n && arr[j] >= arr[i]) {
                curr += arr[i];
                j++;
            }

            res = Math.Max(res, curr);
        }

        return res;
    }

    static void Main(string[] args) {
        int[] arr = {60, 20, 50, 40, 10, 50, 60};
        Console.WriteLine(getMaxArea(arr));
    }
}

JavaScript

// JavaScript program to find the largest rectangular area possible 
// in a given histogram 

// Function to calculate the maximum rectangular
// area in the Histogram
function getMaxArea(arr) {
    let n = arr.length;
    let res = 0;

    // Consider every bar one by one
    for (let i = 0; i < n; i++) {
        let curr = arr[i];

        // Traverse left while we have a greater height bar
        let j = i - 1;
        while (j >= 0 && arr[j] >= arr[i]) {
            curr += arr[i];
            j--;
        }

        // Traverse right while we have a greater height bar
        j = i + 1;
        while (j < n && arr[j] >= arr[i]) {
            curr += arr[i];
            j++;
        }

        res = Math.max(res, curr);
    }

    return res;
}

// Driver code
let arr = [ 60, 20, 50, 40, 10, 50, 60 ];
console.log(getMaxArea(arr));

Output

[Expected Approach] Precomputing (Using Two Stack) - O(n) Time and O(n) Space

The idea is based on the naive approach. Instead of linearly finding previous smaller and next smaller for every element, we find previous smaller and next smaller for the whole array in linear time.

Build an array prevS[] in O(n) time using stack that holds index of previous smaller element for every item.
Build another array nextS[] in O(n) time using stack that holds index of next smaller element for every item.
Now do following for every element arr[i]. Consider arr[i] find width of the largest histogram with arr[i] being the smallest height. width = nextS[i] - prevS[i] - 1. Now find the area as arr[i] * width.
Return the maximum of all values found in step 3.

C++

// C++ program to find the largest rectangular area possible 
// in a given histogram 

#include <bits/stdc++.h>
using namespace std;

// Function to find next smaller for every element
vector<int> nextSmaller(vector<int>& arr) {
    int n = arr.size();
  
    // Initialize with n for the cases when next smaller
    // does not exist
    vector<int> nextS(n, n);
  
    stack<int> st;
 
    // Traverse all array elements from left to right
    for (int i = 0; i < n; ++i) {
        while (!st.empty() && arr[i] < arr[st.top()]) {

            // Setting the index of the next smaller element
            // for the top of the stack
            nextS[st.top()] = i;
            st.pop();
        }
        st.push(i);
    }
    return nextS;
}

// Function to find previous smaller for every element
vector<int> prevSmaller(vector<int>& arr) {
    int n = arr.size();
  
    // Initialize with -1 for the cases when prev smaller
    // does not exist
    vector<int> prevS(n, -1);
  
    stack<int> st;
 
    // Traverse all array elements from left to right
    for (int i = 0; i < n; ++i) {
        while (!st.empty() && arr[i] < arr[st.top()]) {

            // Setting the index of the previous smaller element
            //  for the top of the stack
            st.pop();
        }
        if (!st.empty()) {
            prevS[i] = st.top();
        }
        st.push(i);
    }
    return prevS;
}

// Function to calculate the maximum rectangular
// area in the Histogram
int getMaxArea(vector<int>& arr) {
    vector<int> prevS = prevSmaller(arr);
    vector<int> nextS = nextSmaller(arr);
    
    int maxArea = 0;

    // Calculate the area for each Histogram bar
    for (int i = 0; i < arr.size(); ++i) {
        int width = nextS[i] - prevS[i] - 1; 
        int area = arr[i] * width;          
        maxArea = max(maxArea, area);        
    }
    
    return maxArea;
}

int main() {
    vector<int> arr = {60, 20, 50, 40, 10, 50, 60};
    cout << getMaxArea(arr) << endl;
    return 0;
}

// C program to find the largest rectangular area possible 
// in a given histogram 

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

// Stack structure
struct Stack {
    int top;
    int capacity;
    int* items;
};

// Function to create an empty stack with dynamic memory allocation
struct Stack* createStack(int capacity) {
    struct Stack* stack = 
                (struct Stack*)malloc(sizeof(struct Stack));
    stack->capacity = capacity;
    stack->top = -1;
    stack->items = (int*)malloc(stack->capacity * sizeof(int));
    return stack;
}

// Function to check if the stack is empty
int isEmpty(struct Stack* stack) {
    return stack->top == -1;
}

// Function to push an element onto the stack
void push(struct Stack* stack, int value) {
    if (stack->top == stack->capacity - 1) {
        printf("Stack overflow\n");
        return;
    }
    stack->items[++(stack->top)] = value;
}

// Function to pop an element from the stack
int pop(struct Stack* stack) {
    if (isEmpty(stack)) {
        printf("Stack underflow\n");
        return -1;
    }
    return stack->items[(stack->top)--];
}

// Function to get the top element of the stack
int peek(struct Stack* stack) {
    if (!isEmpty(stack)) {
        return stack->items[stack->top];
    }
    return -1;
}

// Function to find the next smaller element for every element
void nextSmaller(int arr[], int n, int nextS[]) {
    struct Stack* stack = createStack(n);

    // Initialize with n for the cases
    // when next smaller does not exist
    for (int i = 0; i < n; i++) {
        nextS[i] = n;
    }

    // Traverse all array elements from left to right
    for (int i = 0; i < n; i++) {
        while (!isEmpty(stack) && arr[i] < arr[peek(stack)]) {
            nextS[peek(stack)] = i;
            pop(stack);
        }
        push(stack, i);
    }
}

// Function to find the previous smaller element for every element
void prevSmaller(int arr[], int n, int prevS[]) {
    struct Stack* stack = createStack(n);

    // Initialize with -1 for the cases when prev smaller does not exist
    for (int i = 0; i < n; i++) {
        prevS[i] = -1;
    }

    // Traverse all array elements from left to right
    for (int i = 0; i < n; i++) {
        while (!isEmpty(stack) && arr[i] < arr[peek(stack)]) {
            pop(stack);
        }
        if (!isEmpty(stack)) {
            prevS[i] = peek(stack);
        }
        push(stack, i);
    }
}

// Function to calculate the maximum rectangular
// area in the Histogram
int getMaxArea(int arr[], int n) {
    int* prevS = (int*)malloc(n * sizeof(int));
    int* nextS = (int*)malloc(n * sizeof(int));
    int maxArea = 0;

    // Find previous and next smaller elements
    prevSmaller(arr, n, prevS);
    nextSmaller(arr, n, nextS);

    // Calculate the area for each arrogram bar
    for (int i = 0; i < n; i++) {
        int width = nextS[i] - prevS[i] - 1;
        int area = arr[i] * width;
        if (area > maxArea) {
            maxArea = area;
        }
    }
    return maxArea;
}

// Driver code
int main() {
    int arr[] = {60, 20, 50, 40, 10, 50, 60};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("%d\n", getMaxArea(arr, n));
    return 0;
}

Java

// Java program to find the largest rectangular area possible 
// in a given histogram 

import java.util.Stack;

class GfG {

    // Function to find next smaller for every element
    static int[] nextSmaller(int[] arr) {
        int n = arr.length;

        // Initialize with n for the cases when next smaller
        // does not exist
        int[] nextS = new int[n];
        for (int i = 0; i < n; i++) {
            nextS[i] = n;
        }

        Stack<Integer> st = new Stack<>();

        // Traverse all array elements from left to right
        for (int i = 0; i < n; i++) {
            while (!st.isEmpty() && arr[i] < arr[st.peek()]) {

                // Setting the index of the next smaller element
                // for the top of the stack
                nextS[st.pop()] = i;
            }
            st.push(i);
        }
        return nextS;
    }

    // Function to find previous smaller for every element
    static int[] prevSmaller(int[] arr) {
        int n = arr.length;

        // Initialize with -1 for the cases when prev smaller
        // does not exist
        int[] prevS = new int[n];
        for (int i = 0; i < n; i++) {
            prevS[i] = -1;
        }

        Stack<Integer> st = new Stack<>();

        // Traverse all array elements from left to right
        for (int i = 0; i < n; i++) {
            while (!st.isEmpty() && arr[i] < arr[st.peek()]) {
                st.pop();
            }
            if (!st.isEmpty()) {
                prevS[i] = st.peek();
            }
            st.push(i);
        }
        return prevS;
    }

    // Function to calculate the maximum rectangular
    // area in the histogram
    static int getMaxArea(int[] arr) {
        int[] prevS = prevSmaller(arr);
        int[] nextS = nextSmaller(arr);
        int maxArea = 0;

        // Calculate the area for each arrogram bar
        for (int i = 0; i < arr.length; i++) {
            int width = nextS[i] - prevS[i] - 1;
            int area = arr[i] * width;
            maxArea = Math.max(maxArea, area);
        }
        return maxArea;
    }

    public static void main(String[] args) {
        int[] arr = {60, 20, 50, 40, 10, 50, 60};
        System.out.println(getMaxArea(arr));
    }
}

Python

# Python program to find the largest rectangular area possible 
# in a given histogram 

# Function to find next smaller for every element
def nextSmaller(arr):
    n = len(arr)
    
    # Initialize with n for the cases when next smaller
    # does not exist
    nextS = [n] * n
    st = []
    
    # Traverse all array elements from left to right
    for i in range(n):
        while st and arr[i] < arr[st[-1]]:
            # Setting the index of the next smaller element
            # for the top of the stack
            nextS[st.pop()] = i
        st.append(i)
    
    return nextS

# Function to find previous smaller for every element
def prevSmaller(arr):
    n = len(arr)
    
    # Initialize with -1 for the cases when prev smaller
    # does not exist
    prevS = [-1] * n
    st = []
    
    # Traverse all array elements from left to right
    for i in range(n):
        while st and arr[i] < arr[st[-1]]:
            st.pop()
        if st:
            prevS[i] = st[-1]
        st.append(i)
    
    return prevS

# Function to calculate the maximum rectangular
# area in the Histogram
def getMaxArea(arr):
    prevS = prevSmaller(arr)
    nextS = nextSmaller(arr)
    maxArea = 0
    
    # Calculate the area for each arrogram bar
    for i in range(len(arr)):
        width = nextS[i] - prevS[i] - 1
        area = arr[i] * width
        maxArea = max(maxArea, area)
    
    return maxArea

if __name__ == "__main__":
    arr = [60, 20, 50, 40, 10, 50, 60]
    print(getMaxArea(arr))

// C# program to find the largest rectangular area possible 
// in a given histogram 
using System;
using System.Collections.Generic;

class GfG {

    // Function to find next smaller for every element
    static int[] nextSmaller(int[] arr) {
        int n = arr.Length;

        // Initialize with n for the cases when next smaller
        // does not exist
        int[] nextS = new int[n];
        for (int i = 0; i < n; i++) {
            nextS[i] = n;
        }

        Stack<int> st = new Stack<int>();

        // Traverse all array elements from left to right
        for (int i = 0; i < n; i++) {
            while (st.Count > 0 && arr[i] < arr[st.Peek()]) {

                // Setting the index of the next smaller element
                // for the top of the stack
                nextS[st.Pop()] = i;
            }
            st.Push(i);
        }
        return nextS;
    }

    // Function to find previous smaller for every element
    static int[] prevSmaller(int[] arr) {
        int n = arr.Length;

        // Initialize with -1 for the cases when prev smaller
        // does not exist
        int[] prevS = new int[n];
        for (int i = 0; i < n; i++) {
            prevS[i] = -1;
        }

        Stack<int> st = new Stack<int>();

        // Traverse all array elements from left to right
        for (int i = 0; i < n; i++) {
            while (st.Count > 0 && arr[i] < arr[st.Peek()]) {
                st.Pop();
            }
            if (st.Count > 0) {
                prevS[i] = st.Peek();
            }
            st.Push(i);
        }
        return prevS;
    }

    // Function to calculate the maximum rectangular
    // area in the Histogram
    static int getMaxArea(int[] arr) {
        int[] prevS = prevSmaller(arr);
        int[] nextS = nextSmaller(arr);
        int maxArea = 0;

        // Calculate the area for each arrogram bar
        for (int i = 0; i < arr.Length; i++) {
            int width = nextS[i] - prevS[i] - 1;
            int area = arr[i] * width;
            maxArea = Math.Max(maxArea, area);
        }
        return maxArea;
    }

    static void Main() {
        int[] arr = {60, 20, 50, 40, 10, 50, 60};
        Console.WriteLine(getMaxArea(arr));
    }
}

JavaScript

// JavaScript program to find the largest rectangular area possible 
// in a given histogram 

// Function to find next smaller for every element
function nextSmaller(arr){
    const n = arr.length;

    // Initialize with n for the cases when next smaller
    // does not exist
    const nextS = new Array(n).fill(n);
    const stack = [];

    // Traverse all array elements from left to right
    for (let i = 0; i < n; i++) {
        while (stack.length
               && arr[i] < arr[stack[stack.length - 1]]) {
               
            // Setting the index of the next smaller element
            // for the top of the stack
            nextS[stack.pop()] = i;
        }
        stack.push(i);
    }

    return nextS;
}

// Function to find previous smaller for every element
function prevSmaller(arr) {
    const n = arr.length;

    // Initialize with -1 for the cases when prev smaller
    // does not exist
    const prevS = new Array(n).fill(-1);
    const stack = [];

    // Traverse all array elements from left to right
    for (let i = 0; i < n; i++) {
        while (stack.length
               && arr[i] < arr[stack[stack.length - 1]]) {
            stack.pop();
        }
        if (stack.length) {
            prevS[i] = stack[stack.length - 1];
        }
        stack.push(i);
    }

    return prevS;
}

// Function to calculate the maximum rectangular
// area in the Histogram
function getMaxArea(arr) {
    const prevS = prevSmaller(arr);
    const nextS = nextSmaller(arr);
    let maxArea = 0;

    // Calculate the area for each arrogram bar
    for (let i = 0; i < arr.length; i++) {
        const width = nextS[i] - prevS[i] - 1;
        const area = arr[i] * width;
        maxArea = Math.max(maxArea, area);
    }

    return maxArea;
}

// Driver code
const arr = [60, 20, 50, 40, 10, 50, 60];
console.log(getMaxArea(arr));

Output

[Further Optimized] Using Single Stack - O(n) Time and O(n) Space

This approach is mainly an optimization over the previous approach.

When we compute next smaller element, we pop an item from the stack and mark current item as next smaller of it. One important observation here is the item below every item in stack is the previous smaller element. So we do not need to explicitly compute previous smaller.

Below are the detailed steps of implementation.

Create an empty stack.
Start from the first bar, and do the following for every bar arr[i] where 'i' varies from 0 to n-1
1. If the stack is empty or arr[i] is higher than the bar at top of the stack, then push 'i' to stack.
2. If this bar is smaller than the top of the stack, then keep removing the top of the stack while the top of the stack is greater.
3. Let the removed bar be arr[tp]. Calculate the area of the rectangle with arr[tp] as the smallest bar.
4. For arr[tp], the 'left index' is previous (previous to tp) item in stack and 'right index' is 'i' (current index).
If the stack is not empty, then one by one remove all bars from the stack and do step (2.2 and 2.3) for every removed bar

C++

// C++ program to find the largest rectangular area possible 
// in a given histogram 

#include <bits/stdc++.h>
using namespace std;

// Function to calculate the maximum rectangular area
int getMaxArea(vector<int>& arr) {
    int n = arr.size();
    stack<int> s;
    int res = 0;
    int tp, curr;
    for (int i = 0; i < n; i++) {      
         
        while (!s.empty() && arr[s.top()] >= arr[i]) {
          
            // The popped item is to be considered as the 
            // smallest element of the Histogram
            tp = s.top(); 
            s.pop();
          
            // For the popped item previous smaller element is 
            // just below it in the stack (or current stack top)
            // and next smaller element is i
            int width = s.empty() ? i : i - s.top() - 1;
          
            res = max(res,  arr[tp] * width);
        }
        s.push(i);
    }

    // For the remaining items in the stack, next smaller does
    // not exist. Previous smaller is the item just below in
    // stack.
    while (!s.empty()) {
        tp = s.top(); s.pop();
        curr = arr[tp] * (s.empty() ? n : n - s.top() - 1);
        res = max(res, curr);
    }

    return res;
}

int main() {
    vector<int> arr = {60, 20, 50, 40, 10, 50, 60};
    cout << getMaxArea(arr);
    return 0;
}

// C program to find the largest rectangular area possible 
// in a given histogram 

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

// Stack structure
struct Stack {
    int top;
    int capacity;
    int* array;
};

// Function to create a stack
struct Stack* createStack(int capacity) {
    struct Stack* stack = (struct Stack*)
                                malloc(sizeof(struct Stack));
    stack->capacity = capacity;
    stack->top = -1;
    stack->array = (int*)malloc(stack->capacity * sizeof(int));
    return stack;
}

int isEmpty(struct Stack* stack) {
    return stack->top == -1;
}

void push(struct Stack* stack, int item) {
    stack->array[++stack->top] = item;
}

int pop(struct Stack* stack) {
    return stack->array[stack->top--];
}

int peek(struct Stack* stack) {
    return stack->array[stack->top];
}

// Function to calculate the maximum rectangular area
int getMaxArea(int arr[], int n) {
    struct Stack* s = createStack(n);
    int res = 0, tp, curr;
    
    // Traverse all bars of the arrogram
    for (int i = 0; i < n; i++) {  
        
        // Process the stack while the current element 
        // is smaller than the element corresponding to 
        // the top of the stack
        while (!isEmpty(s) && arr[peek(s)] >= arr[i]) {
            tp = pop(s);
            
            // Calculate width and update result
            int width = isEmpty(s) ? i : i - peek(s) - 1;
            res = (res > arr[tp] * width) ? res : arr[tp] * width;
        }
        push(s, i);
    }

    // Process remaining elements in the stack
    while (!isEmpty(s)) {
        tp = pop(s);
        curr = arr[tp] * (isEmpty(s) ? n : n - peek(s) - 1);
        res = (res > curr) ? res : curr;
    }

    return res;
}

int main() {
    int arr[] = {60, 20, 50, 40, 10, 50, 60};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("%d\n", getMaxArea(arr, n));
    return 0;
}

Java

// Java program to find the largest rectangular area possible 
// in a given histogram 

import java.util.Stack;

class GfG {
    
    // Function to calculate the maximum rectangular area
    static int getMaxArea(int[] arr) {
        int n = arr.length;
        Stack<Integer> s = new Stack<>();
        int res = 0, tp, curr;
        
        for (int i = 0; i < n; i++) {  
          
            // Process the stack while the current element 
            // is smaller than the element corresponding to 
            // the top of the stack
            while (!s.isEmpty() && arr[s.peek()] >= arr[i]) {
              
                // The popped item is to be considered as the 
                // smallest element of the Histogram
                tp = s.pop();
                
                // For the popped item, previous smaller element
                // is just below it in the stack (or current stack 
                // top) and next smaller element is i
                int width = s.isEmpty() ? i : i - s.peek() - 1;
                
                // Update the result if needed
                res = Math.max(res, arr[tp] * width);
            }
            s.push(i);
        }

        // For the remaining items in the stack, next smaller does
        // not exist. Previous smaller is the item just below in
        // the stack.
        while (!s.isEmpty()) {
            tp = s.pop();
            curr = arr[tp] * (s.isEmpty() ? n : n - s.peek() - 1);
            res = Math.max(res, curr);
        }

        return res;
    }

    public static void main(String[] args) {
        int[] arr = {60, 20, 50, 40, 10, 50, 60};
        System.out.println(getMaxArea(arr));
    }
}

Python

# Python program to find the largest rectangular area possible 
# in a given histogram 

# Function to calculate the maximum rectangular area
def getMaxArea(arr):
    n = len(arr)
    s = []
    res = 0
    
    for i in range(n):
      
        # Process the stack while the current element 
        # is smaller than the element corresponding to 
        # the top of the stack
        while s and arr[s[-1]] >= arr[i]:
          
            # The popped item is to be considered as the 
            # smallest element of the Histogram
            tp = s.pop()
            
            # For the popped item, the previous smaller 
            # element is just below it in the stack (or 
            # the current stack top) and the next smaller 
            # element is i
            width = i if not s else i - s[-1] - 1
            
            # Update the result if needed
            res = max(res, arr[tp] * width)
        
        s.append(i)
    
    # For the remaining items in the stack, next smaller does
    # not exist. Previous smaller is the item just below in
    # the stack.
    while s:
        tp = s.pop()
        width = n if not s else n - s[-1] - 1
        res = max(res, arr[tp] * width)
    
    return res


if __name__ == "__main__":
    arr = [60, 20, 50, 40, 10, 50, 60]
    print(getMaxArea(arr))

// C# program to find the largest rectangular area possible 
// in a given histogram 

using System;
using System.Collections.Generic;

class GfG {

    // Function to calculate the maximum rectangular area
    static int getMaxArea(int[] arr) {
        int n = arr.Length;
        Stack<int> s = new Stack<int>();
        int res = 0, tp, curr;

        // Traverse all bars of the arrogram
        for (int i = 0; i < n; i++) {  
        
            // Process the stack while the current element 
            // is smaller than the element corresponding to 
            // the top of the stack
            while (s.Count > 0 && arr[s.Peek()] >= arr[i]) {
                tp = s.Pop();
                
                // Calculate width and update result
                int width = s.Count == 0 ? i : i - s.Peek() - 1;
                res = Math.Max(res, arr[tp] * width);
            }
            s.Push(i);
        }

        // Process remaining elements in the stack
        while (s.Count > 0) {
            tp = s.Pop();
            curr = arr[tp] * (s.Count == 0 ? n : n - s.Peek() - 1);
            res = Math.Max(res, curr);
        }

        return res;
    }

    public static void Main() {
        int[] arr = {60, 20, 50, 40, 10, 50, 60};
        Console.WriteLine(getMaxArea(arr));
    }
}

JavaScript

// JavaScript program to find the largest rectangular area possible 
// in a given histogram 

// Function to calculate the maximum rectangular area
function getMaxArea(arr) {
    let n = arr.length;
    let stack = [];
    let res = 0;

    // Traverse all bars of the arrogram
    for (let i = 0; i < n; i++) {

        // Process the stack while the current element
        // is smaller than the element corresponding to
        // the top of the stack
        while (stack.length
               && arr[stack[stack.length - 1]] >= arr[i]) {
            let tp = stack.pop();

            // Calculate width and update result
            let width
                = stack.length === 0 ? i: i 
                            - stack[stack.length - 1] - 1;
            res = Math.max(res, arr[tp] * width);
        }
        stack.push(i);
    }

    // Process remaining elements in the stack
    while (stack.length) {
        let tp = stack.pop();
        let curr = arr[tp] * (stack.length === 0 ? n
                     : n - stack[stack.length - 1] - 1);
        res = Math.max(res, curr);
    }

    return res;
}

// Driver code
let arr = [ 60, 20, 50, 40, 10, 50, 60 ];
console.log(getMaxArea(arr));

Output

[Alternate Approach] Using Divide and Conquer - O(n Log n) Time

The idea is to find the minimum value in the given array. Once we have index of the minimum value, the max area is maximum of following three values.

Maximum area in left side of minimum value (Not including the min value)
Maximum area in right side of minimum value (Not including the min value)
Number of bars multiplied by minimum value.

Please refer Largest Rectangular Area in a histogram Using Divide and Conquer for detailed implementation.

Maximum of minimums of every window size in a given array

kartik

Improve

Article Tags :

Practice Tags :

Largest Rectangular Area in a Histogram

[Naive Approach] By Finding Max Area of Rectangles all Heights - O(n^2) Time and O(1) Space

[Expected Approach] Precomputing (Using Two Stack) - O(n) Time and O(n) Space

[Further Optimized] Using Single Stack - O(n) Time and O(n) Space

[Alternate Approach] Using Divide and Conquer - O(n Log n) Time

Similar Reads

Stack implementation in different language

Some questions related to Stack implementation

Easy problems on Stack

Intermediate problems on Stack

Thank You!

What kind of Experience do you want to share?