All nearest smaller values - Revision history

172.69.33.199: /* Algorithm */ Corrected psuedocode to save index and not value of NSV of A_i

2018-01-02T14:12:59Z

‎Algorithm: Corrected psuedocode to save index and not value of NSV of A_i

172.68.51.18: ASNV -> ANSV

2017-06-05T21:44:23Z

ASNV -> ANSV

Ashutosh1598: The index i needs to be pushed onto the stack in the pseudocode.

2017-05-16T19:52:53Z

The index i needs to be pushed onto the stack in the pseudocode.

Brian: whoops

2011-11-21T03:07:45Z

whoops

Brian: Created page with "In a list of numbers $A$ , the ''nearest smaller value'' (NSV) to an entry $A_i$ is the last entry preceding it with a smaller value, if any; that is, the en..."

2011-11-21T03:07:13Z

Created page with "In a list of numbers <math>A</math>, the ''nearest smaller value'' (NSV) to an entry <math>A_i</math> is the last entry preceding it with a smaller value, if any; that is, the en..."

New page

In a list of numbers <math>A</math>, the ''nearest smaller value'' (NSV) to an entry <math>A_i</math> is the last entry preceding it with a smaller value, if any; that is, the entry <math>A_j</math> with greatest <math>j < i</math> such that <math>A_j < A_i</math>. The '''all nearest smaller values''' (ANSV) problem is that of computing the NSV for each number in the list.

==Algorithm==
It is obvious that, upon seeing the list for the first time, we cannot guarantee being able to find the NSV to a given entry in less than linear time, because it could be any of the preceding entries in the list, and thus, in the worst case, we must examine all of them. If we do a linear scan on each element, we get a trivial <math>O(n^2)</math> time solution to ANSV.

However, it turns out that there is a simple linear time (<math>O(n)</math>) solution to ANSV, which is clearly asymptotically optimal, since the size of the output is <math>\Theta(n)</math> anyway. To understand this algorithm, we make a series of observations and refinements:
# If <math>k < j < i</math>, then it is only possible for <math>A_k</math> to be a NSV for <math>A_i</math> if <math>A_k < A_j</math>; otherwise <math>A_j</math> will always be both smaller and "nearer".
# Thus, if we scan the list from left to right, and compute the NSV for each element as we visit it, and we encounter <math>A_j</math> such that <math>A_j \leq A_k</math> for some <math>A_k</math> already seen, then we can pretend that <math>A_k</math> doesn't exist anymore.
# Given this fact, the only entries we've seen so far that we need to keep track of are the ones that are less than all following entries seen so far.
# This means that the list of "retained" entries is monotonically increasing.
# Once we get to <math>A_i</math>, we can compute its NSV by looking backward though the list of retained previous entries, selecting the first one we find that is less than <math>A_i</math>. Also, all the retained entries skipped along the way—the ones that are greater than or equal to <math>A_i</math>—can now be discarded.
In these five points the essence of the algorithm is contained. We can use a [[stack]] to store the list of previously seen values that are being retained, because we only add to and remove from it at the end. As an implementation detail, in step 5, it is useful to have a sentinel, so that we don't try to pop off an empty stack (when <math>A_i</math> has no preceding smaller value).

'''Pseudocode:'''
<pre>input array A[1..n]
let A[0] ← -∞
let S be an empty stack
push(S,0)
for i ∈ [1..n]
while A[top(S)] ≥ A[i]
pop(S)
let NSV[i] ← A[top(S)]
</pre>
After this code has completed, <code>NSV[i]</code> will contain the ''index'' of the NSV of <math>A_i</math> (not the NSV itself).

==Applications==
A theoretically important application of ASNV is the construction of the [[Cartesian tree]] for a given list of numbers; a node's parent in a Cartesian tree is either its NSV or its NSV in the reversed array (that is, the nearest smaller value on the right rather than on the left), whichever one is larger. (Proof is given in the other article.)

Running ANSV twice, once on an array and once on its reverse, can be used to find, for each element <math>A_i</math>, the range <math>[j,k]</math> such that <math>A_m \geq A_i</math> for each <math>m \in [j,k]</math>. Geometrically, if the array is taken to represent a histogram in which <math>A_i</math> is the height of the ''i''<sup>th</sup> bar, then this range gives how large a rectangle can be that just touches the top of the ''i''<sup>th</sup> bar while staying contained within the histogram. This can then trivially be used to find the largest rectangle contained entirely within the histogram.

This gives an easy linear-time solution to the problem of finding the largest empty axis-aligned rectangle in a rectangular grid (in which each square is either completely full or completely empty): sweep from top to bottom; keep track of how far up one can go along each column until encountering an obstacle, starting from the current row; and find the largest rectangle contained within the corresponding histogram constructed at each row.

==Problems==
* {{Problem|ccc11s2p6|CCC '11 Stage 2: Biggest (Zero Carbon) Footprint}}
* {{SPOJ|HISTOGRA|Largest rectangle in a histogram}}
* {{SPOJ|CTGAME|City Game}}
* USACO: Rectangular Barn

{{Category:Pages needing code}}

@@ Line 20: / Line 20: @@
      while A[top(S)] &ge; A[i]
          pop(S)
-     let NSV[i] &larr; A[top(S)]
+     let NSV[i] &larr; top(S)
      push(S,i)
 </pre>

← Older revision		Revision as of 03:07, 21 November 2011
Line 37:		Line 37:
	* USACO: Rectangular Barn		* USACO: Rectangular Barn

−	{{Category:Pages needing code}}	+	[[Category:Pages needing code]]

@@ Line 26: / Line 26: @@
 ==Applications==
-A theoretically important application of ASNV is the construction of the [[Cartesian tree]] for a given list of numbers; a node's parent in a Cartesian tree is either its NSV or its NSV in the reversed array (that is, the nearest smaller value on the right rather than on the left), whichever one is larger. (Proof is given in the other article.)
+A theoretically important application of ANSV is the construction of the [[Cartesian tree]] for a given list of numbers; a node's parent in a Cartesian tree is either its NSV or its NSV in the reversed array (that is, the nearest smaller value on the right rather than on the left), whichever one is larger. (Proof is given in the other article.)
 Running ANSV twice, once on an array and once on its reverse, can be used to find, for each element <math>A_i</math>, the range <math>[j,k]</math> such that <math>A_m \geq A_i</math> for each <math>m \in [j,k]</math>. Geometrically, if the array is taken to represent a histogram in which <math>A_i</math> is the height of the ''i''<sup>th</sup> bar, then this range gives how large a rectangle can be that just touches the top of the ''i''<sup>th</sup> bar while staying contained within the histogram. This can then trivially be used to find the largest rectangle contained entirely within the histogram.