This document summarizes algorithms for solving the lowest common ancestor (LCA) problem and range minimum query (RMQ) problem in trees. It presents a reduction from LCA to RMQ that allows solving LCA in O(n) time using an O(n) time RMQ algorithm. It describes several RMQ algorithms, including a naive O(n^3) time algorithm, an O(n^2) dynamic programming algorithm, and an O(n log n) sparse table algorithm. For the special case where the values in the array differ by at most 1, it presents an O(n) time and O(1) time RMQ algorithm based on partitioning the array into blocks.

1. The LCA Problem Revisited
(Latin American Theoretical Informatics Symposium, 2000)
Michael A. Bender, Martín Farach-Colton
Presented by Minsung Hong, Junyong Choi

2. Lowest Common Ancestor(LCA)
• LCA 𝑇 𝑢, 𝑣 – given nodes 𝑢, 𝑣 in 𝑇, returns
the node furthest from the root that is an
ancestor of both 𝑢 and 𝑣.
𝑧
𝑢
𝑣
LCA 𝑇 𝑢, 𝑣 =𝑧
3

3. Range Minimum Query(RMQ)
• RMQ 𝐴 (𝑖, 𝑗) – given indices 𝑖, 𝑗 of array 𝐴,
returns the index of the smallest element in
the sub-array 𝐴[𝑖. . 𝑗].
A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9]
0
1
2
34 7
19
10
12
13
16
RMQ 𝐴 3,7 = 4
4

4. Complexity Notation
• Notation for the overall complexity of an algorithm
< 𝑓 𝑛 , 𝑔 𝑛 >
– Preprocessing time : 𝑓(𝑛)
– Query time : 𝑔 𝑛
5

5. Previous Work
• < 𝑂 𝑛 , 𝑂 1 > Algorithms for LCA
– Harel and Tarjan, 1984: first optimal
• very complicated and unimplementable
– Shieber and Vishkin, 1988
• simplified but not particularly implementable
– Berkman and Vishkin, 1993
• developed a new way using reduction to RMQ using Euler
tour.
6

6. Contents
• Introduction
• Reduction from LCA to RMQ
• RMQ Algorithms
– < 𝑂 𝑛2 , 𝑂 1 > Algorithm
– < 𝑂 𝑛 log 𝑛 , 𝑂 1 > Sparse Table(ST) Algorithm
• < 𝑂 𝑛 , 𝑂 1 > Algorithm for RMQ in LCA
• Conclusion
7

7. Reduction from LCA to RMQ
• Lemma
If there is an
< 𝑓 𝑛 , 𝑔 𝑛 >
solution for RMQ, then there is an
< 𝑓 2𝑛 − 1 + 𝑂 𝑛 , 𝑔 2𝑛 − 1 + 𝑂 1 >
solution for LCA.
8

8. Reduction from LCA to RMQ
• Observation
The LCA of nodes 𝑢 and 𝑣 is the shallowest node
encountered between the visits to 𝑢 and to 𝑣 during
a depth first search(DFS) traversal of 𝑇.
0
3
12
4
5 6
2
5
1
2
4
3
8 9
3
1
Shallowest node
Euler tour:
7
7
11
10
6
2
3
1
4
1
7
LCA 𝑇 1,5
1
3
=3
5
• Euler tour length 2𝑛 − 1
6
5
3
9

9. Reduction from LCA to RMQ
• Example
1
6
Euler Tour, 𝐸[1. . 2𝑛 − 1]
Level Array, 𝐿[1. . 2𝑛 − 1]
Representative Array, 𝑅[1. . 𝑛]
3
2
5
9
10
4
8
7
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
𝐸 1 6 3 6 5 6 1 2 1 9 10 9 4 7 4 9 8 9 1
𝐿 0 1 2 1 2 1 0 1 0 1 2 1 2 3 2 1 2 1 0
1 2 3 4 5 6 7 8 9 10
𝑅 1 8 3 13 5 2 14 17 10 11
11

10. Reduction from LCA to RMQ
LCA 𝑇 (10,7)
= 𝐸 12 = 9
1
• Example
6
2
LCA 𝑻 (𝒙, 𝒚) = 𝑬[RMQ 𝑳 𝑹 𝒙 , 𝑹 𝒚 ]
3
5
9
𝐸[11 … 14]
10
4
8
7
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
𝐸 1 6 3 6 5 6 1 2 1 9 10 9 4 7 4 9 8 9 1
𝐿 0 1 2 1 2 1 0 1 0 1 2 1 2 3 2 1 2 1 0
1 2 3 4 5 6 7 8 9 10
𝑅 1 8 3 13 5 2 14 17 10 11
𝑅[10]
𝑅[7]
RMQ 𝐿 11,14 = 12
13

11. Reduction from LCA to RMQ
• Preprocessing Complexity
– Building 3 arrays, 𝐿, 𝑅, 𝐸 : 𝑂(𝑛), during the DFS run.
– Preprocessing 𝐿 for RMQ : 𝑓(2𝑛 − 1)
• Query Complexity
– RMQ query on 𝐿 : 𝑔(2𝑛 − 1)
– Array references : 𝑂(1)
• Overall
< 𝑓 2𝑛 − 1 + 𝑂 𝑛 , 𝑔 2𝑛 − 1 + 𝑂 1 >
14

12. Contents
• Introduction
• Reduction from LCA to RMQ
• RMQ Algorithms
– < 𝑂 𝑛2 , 𝑂 1 > Algorithm
– < 𝑂 𝑛 log 𝑛 , 𝑂 1 > Sparse Table(ST) Algorithm
• < 𝑂 𝑛 , 𝑂 1 > Algorithm for RMQ in LCA
• Conclusion
15

13. Easy RMQ Algorithm
• Given an array 𝐴 of size 𝑛
• Naïve < 𝑂 𝑛3 , 𝑂 1 > Algorithm
– compute the RMQ for every pair of indices and
store in a table.
• < 𝑂 𝑛2 , 𝑂 1 > Algorithm
– To calculate RMQ(i,j), use the already known
value of 𝑅𝑅𝑅 𝑖, 𝑗 − 1 . (Dynamic programming)
16

14. Sparse Table(ST) Algorithm for RMQ
• Preprocess sub-arrays of length 2 𝑘
•
𝑀(𝑖, 𝑗) = index of min value in the sub-array starting
at index 𝑖 having length 2 𝑗
A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9]
10 25
22
7
34
𝑀(3,0) = 3
2
9
12
26
16
𝑀(3,1) = 3
𝑀(3,2) = 5
17

15. Sparse Table(ST) Algorithm for RMQ
• Build table 𝑀
𝑀 𝑖, 𝑗 = argmin 𝑘=𝑖..𝑖+2 𝑗 −1 𝐴𝐴𝐴𝐴𝐴 𝑘
where
1 ≤ 𝑖 ≤ 𝑛, 1 ≤ 𝑗 ≤ log 𝑛
– size: 𝑂 𝑛 log 𝑛
– built in 𝑂 𝑛 log 𝑛 time using dynamic programming
𝑀[𝑖, 𝑗] = �
𝑀 𝑖, 𝑗 − 1 ,
𝑀[𝑖 + 2 𝑗−1 , 𝑗 − 1],
A[0]
10
A[1]
A[2]
25
22
A[3]
7
𝑖𝑖 𝐴 𝑀 𝑖, 𝑗 − 1 ≤ 𝐴 𝑀 𝑖 + 2 𝑗−1 , 𝑗 − 1
𝑜𝑜𝑜𝑜𝑜𝑜𝑜𝑜𝑜
A[4]
A[5]
A[6]
A[7]
A[8]
A[9]
34
9
2
12
26
16
𝑀 3,1 = 3
𝑀 5,1 = 6
𝑀 3,2 = 6
18

16. Sparse Table(ST) Algorithm for RMQ
• Compute RMQ 𝑖, 𝑗
– Select two blocks that entirely cover the sub-range 𝑖. . 𝑗
– Let 𝑘 = log 𝑗 − 𝑖 + 1 .
• 2 𝑘 is the largest block that fits [𝑖. . 𝑗])
RMQ(𝑖, 𝑗) = �
𝑴 𝒊, 𝒌 ,
𝑴[𝒋 − 𝟐 𝒌 + 𝟏, 𝒌],
...
𝒊
𝑖𝑖 𝐴 𝑀 𝑖, 𝑘
𝑜𝑜ℎ𝑒𝑒𝑒𝑒𝑒𝑒
2 𝑘 elements
2 𝑘 elements
≤ 𝐴 𝑀 𝑗 − 2 𝑘 + 1, 𝑘
𝒋
...
20

17. Sparse Table(ST) Algorithm for RMQ
• ST algorithm’s time complexity
< 𝑂 𝑛 log 𝑛 , 𝑂 1 >
21

18. ±1 RMQ
• In array 𝐿, adjacent elements differ by +1 or -1.
• For any two adjacent elements in an Euler tour,
one is always the parent of the other, and so their
levels differ by exactly one.
1
2
6
3
5
10
9
4
7
8
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
𝐸 1 6 3 6 5 6 1 2 1 9 10 9 4 7 4 9 8 9 1
𝐿 0 1 2 1 2 1 0 1 0 1 2 1 2 3 2 1 2 1 22 0

19. Contents
• Introduction
• Reduction from LCA to RMQ
• RMQ Algorithms
– < 𝑂 𝑛3 , 𝑂 1 > Algorithm
– < 𝑂 𝑛2 , 𝑂 1 > Algorithm
– < 𝑂 𝑛 log 𝑛 , 𝑂 1 > Sparse Table(ST) Algorithm
• < 𝑂 𝑛 , 𝑂 1 > Algorithm for ±1RMQ
• Conclusion
23

20. < 𝑂 𝑛 , 𝑂 1 > Algorithm for ±1 RMQ
• Partition 𝐴 into
2𝑛
log 𝑛
blocks of size
log 𝑛
2
.
A
2𝑛
log 𝑛
blocks
log 𝑛
2
...
size
...
log 𝑛
2
...
size
...
log 𝑛
2
...
size
24

21. •
•
< 𝑂 𝑛 , 𝑂 1 > Algorithm for ±1 RMQ
𝐴′ 1. .
𝐵 1. .
2𝑛
log 𝑛
2𝑛
log 𝑛
2𝑛
log 𝑛
: 𝐴′ [𝑖] is the minimum element in the 𝑖-th block of 𝐴.
: 𝐵[𝑖] is the index in which value 𝐴′ [𝑖] occurs.
blocks
...
size
log 𝑛
2
𝐴’[0]
...
𝐵[0]
𝐴𝐴[𝑖]
𝐴
...
...
…
𝐵[𝑖]
...
𝐵
2𝑛
log 𝑛
2𝑛
𝐴’
log 𝑛
...
25

22. < 𝑂 𝑛 , 𝑂 1 > Algorithm for ±1 RMQ
• Example: 𝑛 = 16
𝐴[] ∶ 0
1
2
6
7
10 25 22 7 34 9
2
12 26 33 24 43 5
22 7
10 25
1
10 7
4
8
5
𝐴𝐴[] ∶ 0
3
2
9
34 9
7
…
9
10
2𝑛
log 𝑛
…
size:
𝐵[] ∶ 0
0
11 12
13
14
15
11 19 27
= 8 blocks
log 𝑛
2
1
2
3
5
=2
7
…
26

23. < 𝑂 𝑛 , 𝑂 1 > Algorithm for ±1 RMQ
• Build A’, B : 𝑂(𝑛)
• Preprocess 𝐴’ for RMQ using ST algorithm.
– " < 𝑂 𝑛 log 𝑛 , 𝑂 1 > " algorithm
– 𝐴’ size,
𝑛′
=
2𝑛
log 𝑛
– ST’s preprocessing on 𝐴’ = 𝑛′ log 𝑛′
=
2𝑛
2𝑛
log
log 𝑛
log 𝑛
– Total time complexity : < 𝑂 𝑛 , 𝑂 1 >
= 𝑂 𝑛
27

24. < 𝑂 𝑛 , 𝑂 1 > Algorithm for ±1 RMQ
• Compute RMQ 𝑖, 𝑗
– 𝑖 and 𝑗 might be in the same block, in-block RMQ query.
– 𝑖 < 𝑗 on different blocks
𝒊
1
𝒋
2
3
log 𝑛
2
Return the index of the minimum of these 3 values.
• 2: 𝑂(1) time by RMQ on 𝐴’
• 1 & 3 : in-block RMQ queries.
29

25. < 𝑂 𝑛 , 𝑂 1 > Algorithm for ±1 RMQ
• Observation
Let two arrays 𝑋 & 𝑌 such that ∀𝑖, 𝑋 𝑖 = 𝑌 𝑖 + 𝐶
Then ∀𝑖, 𝑗 RMQ 𝑋 𝑖, 𝑗 = RMQ 𝑌 (𝑖, 𝑗)
X[0] X[1] X[2] X[3] X[4] X[5] X[6] X[7] X[8] X[9]
3
4
5
6
5
4
5
6
5
4
Y[0] Y[1] Y[2] Y[3] Y[4] Y[5] Y[6] Y[7] Y[8] Y[9]
𝑁𝑁𝑁𝑁𝑁𝑁𝑁𝑁𝑁𝑁
0
1
2
+1 +1
3
2
1
2
3
2
+1 -1 -1 +1 +1 -1
2
log 𝑛
−1
2
= 𝑂( 𝑛)
• There are 𝑂( 𝑛) normalized blocks.
1
-1
30

26. < 𝑂 𝑛 , 𝑂 1 > Algorithm for ±1 RMQ
• In-block queries
– " < 𝑂 𝑛2 , 𝑂 1 > " RMQ algorithm for each of 𝑂( 𝑛) normalized
blocks.
– Create 𝑂( 𝑛) tables of size 𝑂 log 2 𝑛 .
• table lookup for all queries 𝑖, 𝑗 where 1 ≤ 𝑖, 𝑗 ≤
– Preprocessing time: 𝑂
𝑛 log 2 𝑛 = 𝑂(𝑛).
+1 +1 +1 +1 +1 +1 +1 +1 +1
...
+1 +1 +1 -1 -1 +1 +1 -1 -1
...
-1 -1 -1 -1 -1 -1 -1 -1 -1
log 𝑛
2
𝑇0 𝑖, 𝑗 for ∀𝑖, 𝑗 where 1 ≤ 𝑖, 𝑗 ≤
𝑇𝑖 𝑖, 𝑗 for ∀𝑖, 𝑗 where 1 ≤ 𝑖, 𝑗 ≤
log 𝑛
2
log 𝑛
2
𝑇 𝑚 𝑖, 𝑗 for ∀𝑖, 𝑗 where 1 ≤ 𝑖, 𝑗 ≤
log 𝑛
2
31

27. < 𝑂 𝑛 , 𝑂 1 > Algorithm for ±1 RMQ
• Preprocess
– In-block queries: 𝑂(𝑛).
– For each block in 𝐴, compute which normalized block table
it should use : 𝑂(𝑛)
– Preprocess 𝐴’ using ST : 𝑂(𝑛)
• Query
– Query on 𝐴’ : 𝑂(1)
– Query on in-blocks : 𝑂(1)
• Overall complexity
< 𝑂 𝑛 , 𝑂 1 >
32

28. Conclusion
𝑂 𝑛 reduction using
Cartesian Tree
RMQ
𝑂 𝑛 reduction using
Euler Tour
±1 RMQ
LCA
A
2𝑛
blocks
log 𝑛
Use " < 𝑂 𝑛 log 𝑛 , 𝑂 1 > " algorithm
Use " < 𝑂 𝑛2 , 𝑂 1 > " algorithm
...
…
...
...
…
< 𝐎 𝐧 , 𝐎 𝟏 > Algorithm
...
… …
log 𝑛
2
...
...
+1 +1 +1 -1 -1 +1 +1 -1
-1
33

29. QnA
Thank You.