Maximize the rectangular area under Histogram

Question

I have a histogram with integer heights and constant width 1. I want to maximize the rectangular area under a histogram. e.g.:

 _
| |
| |_ 
|   |
|   |_
|           


        

Answer 1

The stack solution is one of the most clever solutions I've seen till date. And it can be a little hard to understand why that works.

I've taken a jab at explaining the same in some detail here.

Summary points from the post:-

• General way our brain thinks is :-
  • Create every situation and try to find the value of the contraint that is needed to solve the problem.
  • And we happily convert that to code as :- find the value of contraint(min) for each situation(pair(i,j))

The clever solutions tries to flip the problem.For each constraint/min value of tha area, what is the best possible left and right extremes ?

• So if we traverse over each possible min in the array. What are the left and right extremes for each value ?

  • Little thought says, the first left most value less than the current min and similarly the first rightmost value that is lesser than the current min.

• So now we need to see if we can find a clever way to find the first left and right values lesser than the current value.

• To think: If we have traversed the array partially say till min_i, how can the solution to min_i+1 be built?

• We need the first value less than min_i to its left.

• Inverting the statement : we need to ignore all values to the left of min_i that are greater than min_i. We stop when we find the first value smaller than min_i (i) . The troughs in the curve hence become useless once we have crossed it. In histogram , (2 4 3) => if 3 is min_i, 4 being larger is not of interest.
• Corrollary: in a range (i,j). j being the min value we are considering.. all values between j and its left value i are useless. Even for further calculations.
• Any histogram on the right with a min value larger than j, will be binded at j. The values of interest on the left form a monotonically increasing sequence with j being the largest value. (Values of interest here being possible values that may be of interest for the later array)
• Since, we are travelling from left to right, for each min value/ current value - we do not know whether the right side of the array will have an element smaller than it.
  • So we have to keep it in memory until we get to know this value is useless. (since a smaller value is found)

• All this leads to a usage of our very own stack structure.

  • We keep on stack until we don't know its useless.
  • We remove from stack once we know the thing is crap.

• So for each min value to find its left smaller value, we do the following:-

  1. pop the elements larger to it (useless values)
  2. The first element smaller than the value is the left extreme. The i to our min.
• We can do the same thing from the right side of the array and we will get j to our min.

It's quite hard to explain this, but if this is making sense then I'd suggest read the complete article here since it has more insights and details.