Skip to content

Maximum of minimums of every window size in a given array

Largest Rectangular Area in a Histogram

Last Updated : 18 Feb, 2025

Try it on GfG Practice

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;  }

C

// 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#

// 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

// 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#

// 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

// 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#

// 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 :

Similar Reads

Stack Data Structure

A Stack is a linear data structure that follows a particular order in which the operations are performed. The order may be LIFO(Last In First Out) or FILO(First In Last Out). LIFO implies that the element that is inserted last, comes out first and FILO implies that the element that is inserted first

What is Stack Data Structure? A Complete Tutorial

Stack is a linear data structure that follows LIFO (Last In First Out) Principle, the last element inserted is the first to be popped out. It means both insertion and deletion operations happen at one end only. LIFO(Last In First Out) PrincipleHere are some real world examples of LIFO Consider a sta

Applications, Advantages and Disadvantages of Stack

A stack is a linear data structure in which the insertion of a new element and removal of an existing element takes place at the same end represented as the top of the stack. Applications of Stacks:Function calls: Stacks are used to keep track of the return addresses of function calls, allowing the

Implement a stack using singly linked list

To implement a stack using a singly linked list, we need to ensure that all operations follow the LIFO (Last In, First Out) principle. This means that the most recently added element is always the first one to be removed. In this approach, we use a singly linked list, where each node contains data a

Introduction to Monotonic Stack - Data Structure and Algorithm Tutorials

A monotonic stack is a special data structure used in algorithmic problem-solving. Monotonic Stack maintaining elements in either increasing or decreasing order. It is commonly used to efficiently solve problems such as finding the next greater or smaller element in an array etc. Table of Content Wh

Difference Between Stack and Queue Data Structures

In computer science, data structures are fundamental concepts that are crucial for organizing and storing data efficiently. Among the various data structures, stacks and queues are two of the most basic yet essential structures used in programming and algorithm design. Despite their simplicity, they