Given an array `A[0..N-1]`

.
For each query of the form `[L, R]`

we want to find the minimum in the array `A`

starting from position `L`

and ending with position `R`

.
We will assume that the array `A`

doesn't change in the process, i.e. this article describes a solution to the static RMQ problem

Here is a description of an asymptotically optimal solution. It stands apart from other solutions for the RMQ problem, since it is very different from them: it reduces the RMQ problem to the LCA problem, and then uses the Farach-Colton and Bender algorithm, which reduces the LCA problem back to a specialized RMQ problem and solves that.

We construct a **Cartesian tree** from the array `A`

.
A Cartesian tree of an array `A`

is a binary tree with the min-heap property (the value of parent node has to be smaller or equal than the value of its children) such that the in-order traversal of the tree visits the nodes in the same order as they are in the array `A`

.

In other words, a Cartesian tree is a recursive data structure.
The array `A`

will be partitioned into 3 parts: the prefix of the array up to the minimum, the minimum, and the remaining suffix.
The root of the tree will be a node corresponding to the minimum element of the array `A`

, the left subtree will be the Cartesian tree of the prefix, and the right subtree will be a Cartesian tree of the suffix.

In the following image you can see one array of length 10 and the corresponding Cartesian tree.

The range minimum query `[l, r]`

is equivalent to the lowest common ancestor query `[l', r']`

, where `l'`

is the node corresponding to the element `A[l]`

and `r'`

the node corresponding to the element `A[r]`

.
Indeed the node corresponding to the smallest element in the range has to be an ancestor of all nodes in the range, therefor also from `l'`

and `r'`

.
This automatically follows from the min-heap property.
And is also has to be the lowest ancestor, because otherwise `l'`

and `r'`

would be both in the left or in the right subtree, which generates a contradiction since in such a case the minimum wouldn't even be in the range.

In the following image you can see the LCA queries for the RMQ queries `[1, 3]`

and `[5, 9]`

.
In the first query the LCA of the nodes `A[1]`

and `A[3]`

is the node corresponding to `A[2]`

which has the value 2, and in the second query the LCA of `A[5]`

and `A[9]`

is the node corresponding to `A[8]`

which has the value 3.

Such a tree can be built in \(O(N)\) time and the Farach-Colton and Benders algorithm can preprocess the tree in \(O(N)\) and find the LCA in \(O(1)\).

We will build the Cartesian tree by adding the elements one after another.
In each step we maintain a valid Cartesian tree of all the processed elements.
It is easy to see, that adding an element `s[i]`

can only change the nodes in the most right path - starting at the root and repeatedly taking the right child - of the tree.
The subtree of the node with the smallest, but greater or equal than `s[i]`

, value becomes the left subtree of `s[i]`

, and the tree with root `s[i]`

will become the new right subtree of the node with the biggest, but smaller than `s[i]`

value.

This can be implemented by using a stack to store the indices of the most right nodes.

```
vector<int> parent(n, -1);
stack<int> s;
for (int i = 0; i < n; i++) {
int last = -1;
while (!s.empty() && A[s.top()] >= A[i]) {
last = s.top();
s.pop();
}
if (!s.empty())
parent[i] = s.top();
if (last >= 0)
parent[last] = i;
s.push(i);
}
```