RangRange Minimum Query and Lowest Common Ancestore Minimum Query and Lowest Common Ancestor
RangRange Minimum Query and Lowest Common Ancestore Minimum Query and Lowest Common Ancestor
RangRange Minimum Query and Lowest Common Ancestore Minimum Query and Lowest Common Ancestor
Common Ancestor
By danielp TopCoder Member
Introduction
The problem of finding the Lowest Common Ancestor (LCA) of a pair of nodes in a
rooted tree has been studied more carefully in the second part of the 20th century
and now is fairly basic in algorithmic graph theory. This problem is interesting not
only for the tricky algorithms that can be used to solve it, but for its numerous
applications in string processing and computational biology, for example, where
LCA is used with suffix trees or other tree-like structures. Harel and Tarjan were the
first to study this problem more attentively and they showed that after linear
preprocessing of the input tree LCA, queries can be answered in constant time.
Their work has since been extended, and this tutorial will present many interesting
approaches that can be used in other kinds of problems as well.
Lets consider a less abstract example of LCA: the tree of life. Its a well-known fact
that the current habitants of Earth evolved from other species. This evolving
structure can be represented as a tree, in which nodes represent species, and the
sons of some node represent the directly evolved species. Now species with similar
characteristics are divided into groups. By finding the LCA of some nodes in this
tree we can actually find the common parent of two species, and we can determine
that the similar characteristics they share are inherited from that parent.
Range Minimum Query (RMQ) is used on arrays to find the position of an element
with the minimum value between two specified indices. We will see later that the
LCA problem can be reduced to a restricted version of an RMQ problem, in which
consecutive array elements differ by exactly 1.
However, RMQs are not only used with LCA. They have an important role in string
preprocessing, where they are used with suffix arrays (a new data structure that
supports string searches almost as fast as suffix trees, but uses less memory and
less coding effort).
In this tutorial we will first talk about RMQ. We will present many approaches that
solve the problem some slower but easier to code, and others faster. In the
second part we will talk about the strong relation between LCA and RMQ. First we
will review two easy approaches for LCA that dont use RMQ; then show that the
RMQ and LCA problems are equivalent; and, at the end, well look at how the RMQ
problem can be reduced to its restricted version, as well as show a fast algorithm
for this particular case.
Notations
Suppose that an algorithm has preprocessing time f(n) and query time g(n). The
notation for the overall complexity for the algorithm is <f(n), g(n)>.
We will note the position of the element with the minimum value in some
array A between indices i and j withRMQ (i, j).
A
The furthest node from the root that is an ancestor of both u and v in some rooted
tree T is LCA (u, v).
T
This trivial algorithm is quite slow and uses O(N ) memory, so it wont work for large
cases.
2
Now lets see how can we compute RMQ (i, j). The idea is to get the overall
minimum from the sqrt(N)sections that lie inside the interval, and from the end and
the beginning of the first and the last sections that intersect the bounds of the
interval. To get RMQ (2,7) in the above example we should
compare A[2],A[M[1]], A[6] and A[7] and get the position of the minimum value.
Its easy to see that this algorithm doesnt make more than 3 * sqrt(N) operations
per query.
A
The main advantages of this approach are that is to quick to code (a plus for
TopCoder-style competitions) and that you can adapt it to the dynamic version of
the problem (where you can change the elements of the array between queries).
Sparse Table (ST) algorithm
A better approach is to preprocess RMQ for sub arrays of length 2 using dynamic
k
programming. We will keep an array M[0, N-1][0, logN] where M[i][j] is the index of
the minimum value in the sub array starting at ihaving length 2 . Here is an
j
example:
For computing M[i][j] we must search for the minimum value in the first and second
half of the interval. Its obvious that the small pieces have 2
recurrence is:
j1
length, so the
The segment tree has the same structure as a heap, so if we have a node
numbered x that is not a leaf the left son of x is 2*x and the right son 2*x+1.
For solving the RMQ problem using segment trees we should use an array M[1, 2 *
2
[logN] + 1
] where M[i] holds the minimum value position in the interval assigned to
node i. At the beginning all elements in M should be -1. The tree should be
initialized with the following function (b and e are the bounds of the current
interval):
void initialize(intnode, int b, int e, int M[MAXIND],
int A[MAXN], int N)
{
if (b == e)
M[node] = b;
else
{
//compute the values in the left and right subtrees
initialize(2 * node, b, (b + e) / 2, M, A, N);
initialize(2 * node + 1, (b + e) / 2 + 1, e, M,
A, N);
//search for the minimum value in the first and
//second half of the interval
if (A[M[2 * node]] <= A[M[2 * node + 1]])
M[node] = M[2 * node];
else
M[node] = M[2 * node + 1];
}
}
The function above reflects the way the tree is constructed. When calculating the
minimum position for some interval we should look at the values of the sons. You
should call the function with node = 1, b = 0 and e = N-1.
We can now start making queries. If we want to find the position of the minimum
value in some interval [i, j]we should use the next easy function:
int query(int node, int b, int e, int M[MAXIND], int
A[MAXN], int i, int j)
{
int p1, p2;
//if the current interval doesn't intersect
//the query interval return -1
if (i > e || j < b)
return -1;
//if the current interval is included in
//the query interval return M[node]
if (b >= i && e <= j)
return M[node];
//compute the minimum position in the
//left and right part of the interval
p1 = query(2 * node, b, (b + e) / 2, M, A, i, j);
p2 = query(2 * node + 1, (b + e) / 2 + 1, e, M, A,
i, j);
//return the position where the overall
//minimum is
if (p1 == -1)
return M[node] = p2;
if (p2 == -1)
return M[node] = p1;
if (A[p1] <= A[p2])
return M[node] = p1;
return M[node] = p2;
}
You should call this function with node = 1, b = 0 and e = N 1, because the
interval assigned to the first node is [0, N-1].
Its easy to see that any query is done in O(log N). Notice that we stop when we
reach completely in/out intervals, so our path in the tree should split only one time.
Using segment trees we get an <O(N), O(logN)> algorithm. Segment trees are very
powerful, not only because they can be used for RMQ. They are a very flexible data
structure, can solve even the dynamic version of RMQ problem, and have
numerous applications in range searching problems.
Lowest Common Ancestor (LCA)
Given a rooted tree T and two nodes u and v, find the furthest node from the root
that is an ancestor for bothu and v. Here is an example (the root of the tree will be
node 1 for all examples in this editorial):
Now, for each node, we should know the ancestor that is situated on the last level
of the upper next section. We will preprocess this values in an array P[1, MAXN].
Here is how P should look like for the tree in the example (for simplity, for every
node i in the first section let P[i] = 1):
Notice that for the nodes situated on the levels that are the first ones in some
sections, P[i] = T[i]. We can preprocess P using a depth first search (T[i] is the
father of node i in the tree, nr is [sqrt(H)] and L[i] is the level of the node i):
void dfs(int node, int T[MAXN], int N, int P[MAXN], int
L[MAXN], int nr)
int k;
//if node is situated in the first
//section then P[node] = 1
//if node is situated at the beginning
//of some section then P[node] = T[node]
}
This function makes at most 2 * sqrt(H) operations. Using this approach we get
an <O(N), O(sqrt(H))>algorithm, where H is the height of the tree. In the worst
case H = N, so the overall complexity is <O(N), O(sqrt(N))>. The main advantage
of this algorithm is quick coding (an average Division 1 coder shouldnt need more
than 15 minutes to code it).
Another easy solution in <O(N logN, O(logN)>
If we need a faster solution for this problem we could use dynamic programming.
First, lets compute a table P[1,N][1,logN] where P[i][j] is the 2 -th ancestor of i. For
j
This takes O(N logN) time and space. Now lets see how we can make queries.
Let L[i] be the level of node i in the tree. We must observe that if p and q are on
the same level in the tree we can compute LCA(p, q) using a meta-binary search.
So, for every power j of 2 (between log(L[p]) and 0, in descending order), if P[p]
[j] != P[q][j] then we know that LCA(p, q) is on a higher level and we will continue
searching for LCA(p = P[p][j], q = P[q][j]). At the end, both p and q will have the
same father, so return T[p]. Lets see what happens if L[p] != L[q]. Assume,
without loss of generality, that L[p] < L[q]. We can use the same meta-binary
search for finding the ancestor of p situated on the same level with q, and then we
can compute the LCA as described below. Here is how the query function should
look:
int query(int N, int P[MAXN][LOGMAXN], int T[MAXN],
int L[MAXN], int p, int q)
{
int tmp, log, i;
//if p is situated on a higher level than q then we swap
them
if (L[p] < L[q])
tmp = p, p = q, q = tmp;
//we compute the value of [log(L[p)]
for (log = 1; 1 << log <= L[p]; log++);
log--;
//we find the ancestor of node p situated on the same
level
//with q using the values in P
for (i = log; i >= 0; i--)
if (L[p] - (1 << i) >= L[q])
p = P[p][i];
if (p == q)
return p;
//we compute LCA(p, q) using the values in P
for (i = log; i >= 0; i--)
if (P[p][i] != -1 && P[p][i] != P[q][i])
p = P[p][i], q = P[q][i];
return T[p];
}
Now, we can see that this function makes at most 2 * log(H) operations, where H is
the height of the tree. In the worst case H = N, so the overall complexity of this
algorithm is <O(N logN), O(logN)>. This solution is easy to code too, and its faster
than the previous one.
Reduction from LCA to RMQ
Now, lets show how we can use RMQ for computing LCA queries. Actually, we will
reduce the LCA problem to RMQ in linear time, so every algorithm that solves the
RMQ problem will solve the LCA problem too. Lets show how this reduction can be
done using an example:
visits of u and v during a depth first search of T. So, we can consider all nodes
between any two indices of u and v in the Euler Tour of the tree and then find the
node situated on the smallest level between them. For this, we must build three
arrays:
E[1, 2*N-1] the nodes visited in an Euler Tour of T; E[i] is the label of i-
of node E[i]
H[1, N] H[i] is the index of the first occurrence of node i in E (any
occurrence would be good, so its not bad if we consider the first one)
Assume that H[u] < H[v] (otherwise you must swap u and v). Its easy to see that
the nodes between the first occurrence of u and the first occurrence of v are E[H[u]
H[v]]. Now, we must find the node situated on the smallest level. For this, we can
use RMQ. So, LCA (u, v) = E[RMQ (H[u], H[v])] (remember that RMQ returns the
index). Here is how E, L and H should look for the example:
T
Here is an example:
Now we only have to compute C(A) in linear time. This can be done using a stack.
At the beginning the stack is empty. We will then insert the elements of A in the
stack. At the i-th step A[i] will be added next to the last element in the stack that
has a smaller or equal value to A[i], and all the greater elements will be removed.
The element that was in the stack on the position of A[i] before the insertion was
done will become the left son of i, and A[i] will become the right son of the smaller
element behind him. At every step the first element in the stack is the root of the
cartesian tree. Its easier to build the tree if the stack will hold the indexes of the
elements, and not their value.
Here is how the stack will look at each step for the example above:
Step
Stack
01
02
34
345
3456
3456
7
38
389
Note that every element in A is only added once and removed at most once, so the
complexity of this algorithm is O(N). Here is how the tree-processing function will
look:
void computeTree(int A[MAXN], int N, int T[MAXN])
int st[MAXN], i, k, top = -1;
block queries can be made. Note that the length of a block is l = [(log N) / 2], which
is quite small. Also, note that A is a binary array. The total number of binary arrays
of size lis 2 =sqrt(N). So, for each binary block of size l we need to lock up in a
l
table P the value for RMQ between every pair of indices. This can be trivially
computed in O(sqrt(N)*l )=O(N) time and space. To index table P, preprocess the
2
type of each block in A and store it in array T[1, N/l]. The block type is a binary
number obtained by replacing -1 with 0 and +1 with 1.
Now, to answer RMQ (i, j) we have two cases:
i and j are in the same block, so we use the value computed in P and T
A