## Range minimum query RMQ

Given an array A[0..n], find the index of the element with the minimum value in a given range. This problem is known as Range Minimum Query or RMQ.
For example, if given array below, find the index of minimum value between index 2 and 7, RMQ answer would be 5, which is the index of element 1.

Going by the brute force, every time a query is fired, we scan the range and find the minimum in a given range in the same way as we do for an entire array. The complexity of each query being answered is `O(n)` wherein the worst-case range is the entire array.

Can we preprocess our data, so that our query operations are less costly? If we do so, there are two parts to the solution now, first preprocessing and the second query. Let’s assume complexity of each step is `f(n)` and `g(n)` respectively, then the complexity of solution can be denoted as `(f(n), g(n))`.

What kind of preprocessing can be done? Basic idea is to calculate the minimum index of all the ranges possible in the array. How many ranges are possible for an array with n elements? It’s `n2` ranges. Why?

So, to store the index of minimum value element of each range, `O(n2)` order space is required and time complexity goes to `O(n3)`. However, complexity of query is `O(1)`. So overall complexity of solution is `( O(n3), O(1) )`.

```#include <stdio.h>

int M[100][100];

int findMinimum(int a[], int start, int end, int size){
if(start >= size || end >= size) return -1;
int min = start;
for(int i=start; i<=end; i++){
if( a[i] < a[min] ){
min = i;
}
}
return min;

}
void preprocess(int a[], int size ){
for(int i=0; i<size; i++){
for(int j=0; j<size; j++){
for(int k=i; k<=j; k++){
M[i][j] = findMinimum(a,i,j,size);
}
}
}
}

int rmq(int start, int end){
return M[start][end];
}

int main(void) {

int a[] = { 2,3,1,5,9,7,10,5,6,3 };
int size = sizeof(a)/sizeof(a[0]);

//Preprocessing step
preprocess(a, size);
printf("\n Minimum index in range is : %d ", rmq(3,9) );
printf("\n Minimum index in range is : %d ", rmq(2,7) );

return 0;
}
```

With application of dynamic programming, the complexity of the preprocessing step can be reduced to `O(n2)`.

```#include <stdio.h>

int M[100][100];

void preprocess(int a[], int size)
{
int i,j;
for (i=0; i<size; i++)
M[i][i] = i;

for (i=0; i<size; i++){
for (j=i+1; j<size; j++){
if (a[M[i][j - 1]] < a[j])
M[i][j] = M[i][j - 1];
else
M[i][j] = j;
}
}
}

int rmq(int start, int end){
return M[start][end];
}

int main(void) {

int a[] = { 2,3,1,5,9,7,10,5,6,3 };
int size = sizeof(a)/sizeof(a[0]);

//Preprocessing step
preprocess(a, size);
printf("\n Minimum index in range is : %d ", rmq(3,9) );
printf("\n Minimum index in range is : %d ", rmq(2,7) );

return 0;
}
```

### Range minimum query with O(n), O(√n) complexity solution

Can we do better for preprocessing step while trading off query step? If we divide the array into smaller chunks and store index of minimum value element in those chunks, will it help? And what should be the size of chunks? How about we divide the array in √n parts, where √n is size of part.

Now, find minimum element index in each of this chunk, and store it. Extra space required is (√n). Finding minimum for each chunk has a complexity of (√n * √n) as O(n).

To find minimum element index in the given range, follow three steps:
1. Find the index of the element with the minimum value in all chunks lying between the start and end of the given range. (Max √n operations if all chunks fall in the range)
2. Find minimum index in chunk where the start of the range lies. ( Max √n comparisons from start of the range to end of the chunk).
3. Find minimum index in chuck where end of the range lies from the start of chunk to end of the range.
4. Compare all these values and return the index of the minimum of them.

No matter, how big or small range is to find the index of an element with the minimum value, the worst case will be `O(√n)` as there are only 3*√n operations.

Let’s take an example and see how it works. Find minimum in range (2,7)

To get `RMQ(2,7)`, what are the chunks with are lying within range? There is only one: chunk 1. Minimum index of chunk 1 is M[1] which is 5, so, minimum element in those chunks is A[5].

Find the index of the minimum value in chunk 0 where start of the range lies (starting from start of the range which 2). There is only one element, which is index 2, so element to compare is A[2].

Find minimum from the start of chunk where the end of the range lies. So, we will be comparing A[6] and A[7].

At the end, compare A[5] (minimum of all chunks between start and end of range ), A[2] (minimum in chunk where the start of the range lies) and A[6], A[7] (minimum in chunk where end of the range lies) and we have the answer as 5 as A[5] is the minimum of all these values.

Aggregating all things, we found a way to optimize solution of range minimum query with complexity as `((o(n), O(√n))`.

### RMQ using sparse table

Method 3 uses only O(√n) space, however, query time complexity is also `O(√n)`. To reduce query time at the expense of space, there is another method called as sparse table method. This method uses features of method 2 (dynamic programming) and features of method 3 (find minimums of chunks).

In this approach, split input array into chunks of size 2j where j varies from 0 to log n and n is number of elements in array. There will be `n log n` such chunks and hence the space complexity becomes `O(n log n)`.

After splitting, find the index of the minimum element in each chunk and store it in a lookup table.

M[i][j] stores minimum in range from i with size 2j.

For example, M[0][3] stores index of the minimum value between 0 and 7 (23 = 8 elements).

Now problem is how to create this lookup table? This table can be created using dynamic programming from bottom up. Specifically, we find index of the minimum value in a block of size `2j` by comparing the two minima of its two constituent blocks of size `2j-1`. More formally,

```M[i,j] = M[i, j-1] if A[M[i, j-1]] >= A[M[i+2^j-1, j-1]]
M[i,j] = M[i+2^j-1, j-1] otherwise.
```

How to find the index of the minimum value in a given range? Idea is to find two subranges which cover the entire range and then find the minimum of minimums of these two ranges.
For example, find RMQ(i,j). If 2k be size of largest block that fits into the range from i to j, then `k = log(j – i + 1)`

Now, we have two parts to look in from i to i+2k + 1 (already computed as M[i,k] ) and from j-2k+1 (already computed as M[j-2k+1, k]).

Formally,

```    RMQ(i,j) =  M[i][k] if A[ M[i][k] ] >= A[M[j-2^k+1, k]]
RMQ(i,j) =  M[j-2^k+1, k]
```

#### RMQ implementatio using sparse table

```#include <stdio.h>
#include <math.h>

int M[100][100];

void preprocess(int a[], int size)
{
int i, j;

for (i = 0; i < size; i++)
M[i][0] = i;

for (j = 1; 1 << j <size ; j++){
for (i = 0; i + (1 << j) - 1 < size; i++){
if (a[M[i][j - 1]] < a[M[i + (1 << (j - 1))][j - 1]])
M[i][j] = M[i][j - 1];
else
M[i][j] = M[i + (1 << (j - 1))][j - 1];
}
}
}

int rmq(int a[], int start, int end){
int j = floor(log(start-end+1));

if ( a[M[start][j]] <= a[M[end-(1<<j)+1][j]] )
return M[start][j];
else
return M[end-(1<<j)+1][j];
}

int main(void) {

int a[] = { 2,3,1,5,9,7,10,5,6,3 };
int size = sizeof(a)/sizeof(a[0]);

//Preprocessing step
preprocess(a, size);
printf("\n Minimum index in range is : %d ", rmq(a,3,9) );
printf("\n Minimum index in range is : %d ", rmq(a,2,7) );

return 0;
}
```

These two blocks entirely cover the range and since only once comparison required, the complexity of lookup will be `O(1)`.

In this post, we discussed various ways to implement range minimum query based on space and time complexity tradeoff. In future posts, we will discuss applications of RMQ such as segmented trees and least common ancestor problem.

Please share if something is wrong or missing, we would love to hear from you.