## Lowest common ancestor(LCA) using RMQ

We already have discussed lowest common ancestor and range minimum query. In this post, we will discuss how to use RMQ to find the lowest common ancestor of two given nodes in a binary tree or binary search tree. LCA of two nodes u and v is the node which is furthest from root and u and v are descendant of that node. For example, LCA `node(5)` and `node(9)` in below tree is `node(2)`.

In earlier solutions, we scan the whole binary tree every time we have to find LCA of two nodes. This has a complexity of `O(n)` for each query. If this query if fired frequently, this operation may become a bottleneck of the algorithm. One way to avoid processing all nodes on each query is to preprocess binary tree and store precalculated information to find LCA of any two nodes in constant time.

This pattern is very similar to a range minimum query algorithm. Can we reduce the lowest common ancestor problem to range minimum query problem?

### Reduction of lowest common ancestor problem to RMQ

Let’s revise what is RMQ: Given an array A of length n; RMQ(i,j) – returns the index of the minimum element in the subarray A[i..j].

Let’s find LCA of two nodes 5 and 8 manually in the above binary tree. We notice that LCA(u,v) is a shallowest common node (in terms of distance from root) which is visited when u and v are visited using the depth-first search of the tree. An important thing to note is that we are interested in shallowest, which is minimum depth, the node between u and v. Sounds like RMQ?

Implementation wise, the tree is traversed as Euler tour, which means we visit each node of tree, without lifting the pencil. This is very similar to a preorder traversal of a tree. At most, there can be 2n-1 nodes in Euler tour of a tree with n nodes, store this tour in an array `E[1..2n-1]`.

As algorithm requires the shallowest node, closest to root, so we store the depth of each node while doing Euler tour, so we store the depth of each node in another array D[1..2n-1].

We should maintain the value when the node was visited for the first time. Why?

E[1..2n-1] – Store the nodes visited in a Euler tour of T. Euler[i] stores ith node visited in the tour.
D[1..2n-1] – Stores level of the nodes in tour. D[i] is the level of node at Euler[i]. (level is defined to be the distance from the root).
F[1..n] – F[i] will hold value when node is first visited.

For example of this graph, we start from node(1) and do Euler tour of the binary tree.

Euler tour would be like

Depth array is like

First visit array looks like

To compute LCA(u,v): All nodes in the Euler tour between the first visits to u and v are `E[F[u]...F[v]]` (assume F[u] is less than F[v] else, swap u and v). The shallowest node in this tour is at index `RMQ D(F[u]..F[v])`, since D[i] stores the depth of node at E[i].
RMQ function will return the index of the shallowest node between u and v, thus output node will be `E[RMQ D(F[u], F[v])]` as LCA(u,v)

Let’s take an example, find the lowest common ancestor of `node(5)` and `node(8)`.

First of all, find the first visit to `node(5)` and `node(8)`. It will be F[5] which is 2 and F[8] which is 7.

Now, all the nodes which come between visit of `node(5)` and `node(8)` are in E[2..7], we have to find the shallowest node out these nodes. This can be done by applying RMQ on array D with range 3 to 6.

LCA will be E[RMQ( D(2,7)], in this case, RMQ(D[2..7]) is index 3. E[3] = 2, hence LCA(5,8) is `node(2)`.

#### Lowest common ancestor using RMQ: Implementation

```package com.company.BST;

import java.util.Arrays;

/**
* Created by sangar on 1.1.19.
*/
public class LowestCommonAncestor {

private int[] E;
private int[] D;
private int[] F;

int[][] M;

private int tourCount;

public LowestCommonAncestor(BinarySearchTree tree){
//Create Euler tour, Depth array and First Visited array
E = new int[2*tree.getSize()];
D = new int[2*tree.getSize()];
F = new int[tree.getSize() + 1];

M = new int[2 * tree.getSize()][2 * tree.getSize()];

Arrays.fill(F, -1);
getEulerTour(tree.getRoot(), E, D, F, 0);

preProcess(D);
}

public int findLowestCommonAncestor(int u, int v){
//This means node is not in tree
if(u >= F.length || v >= F.length || F[u] == -1 || F[u] == -1)
return -1 ;

return E[rmq(D, F[u], F[v])];
}

/* This function does all the preprocessing on the tree and
creates all required arrays for the algorithm.
*/
private void getEulerTour(TreeNode node, int[] E, int[] D, int[] F,
int level){
if(node == null) return;

int val = (int)node.getValue();

E[tourCount] = val; // add to tour
D[tourCount] =  level; // store depth

if(F[val] == -1) {
F[(int) node.getValue()] = tourCount;
}
tourCount++;

if(node.getLeft() != null ) {
getEulerTour(node.getLeft(), E, D, F, level + 1);

E[tourCount] = val;
D[tourCount++] = level;
}
if(node.getRight() != null ) {
getEulerTour(node.getRight(), E, D, F, level + 1);

E[tourCount] = val;
D[tourCount++] = level;
}
}

/*
This function preprocess the depth array to quickly find
RMQ which is used to find shallowest node.
*/
void preProcess(int[] D) {

for (int i = 0; i < D.length; i++)
M[i][0] = i;

for (int j = 1; 1 << j <D.length ; j++){
for (int i = 0; i + (1 << j) - 1 < D.length; i++){
if (D[M[i][j - 1]] < D[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];
}
}
}

private int rmq(int a[], int start, int end){
int j = (int)Math.floor(Math.log(end-start+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];
}
}
```

The beauty of this algorithm is that it can be used to find LCA of any tree, not just only binary tree or BST. The complexity of the algorithm to find a lowest common ancestor using range minimum query is `(O(n), O(1))` with an additional space complexity of `O(n)`.

Please share if there is something wrong or missing. If you are preparing for an interview, please signup for free demo class to guide you through the process.

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