Range LCM Queries - GeeksforGeeks

18 May, 2021
Given an array of integers, evaluate queries of the form LCM(l, r). There might be many queries, hence evaluate the queries efficiently.  
LCM (l, r) denotes the LCM of array elements
           that lie between the index l and r
           (inclusive of both indices) 

Mathematically, 
LCM(l, r) = LCM(arr[l],  arr[l+1] , ......... ,
                                  arr[r-1], arr[r])
Examples:  
Inputs : Array = {5, 7, 5, 2, 10, 12 ,11, 17, 14, 1, 44}
         Queries: LCM(2, 5), LCM(5, 10), LCM(0, 10)
Outputs: 60 15708 78540
Explanation : In the first query LCM(5, 2, 10, 12) = 60, 
              similarly in other queries.
 
A naive solution would be to traverse the array for every query and calculate the answer by using, LCM(a, b) = (a*b) / GCD(a,b)However as the number of queries can be large, this solution would be impractical.An efficient solution would be to use segment tree. Recall that in this case, where no update is required, we can build the tree once and can use that repeatedly to answer the queries. Each node in the tree should store the LCM value for that particular segment and we can use the same formula as above to combine the segments. Hence we can answer each query efficiently!Below is a solution for the same.  
C++
Java
Python3
C#
Javascript
// LCM of given range queries using Segment Tree#include <bits/stdc++.h>using namespace std; #define MAX 1000 // allocate space for treeint tree[4*MAX]; // declaring the array globallyint arr[MAX]; // Function to return gcd of a and bint gcd(int a, int b){    if (a == 0)        return b;    return gcd(b%a, a);} //utility function to find lcmint lcm(int a, int b){    return a*b/gcd(a,b);} // Function to build the segment tree// Node starts beginning index of current subtree.// start and end are indexes in arr[] which is globalvoid build(int node, int start, int end){    // If there is only one element in current subarray    if (start==end)    {        tree[node] = arr[start];        return;    }     int mid = (start+end)/2;     // build left and right segments    build(2*node, start, mid);    build(2*node+1, mid+1, end);     // build the parent    int left_lcm = tree[2*node];    int right_lcm = tree[2*node+1];     tree[node] = lcm(left_lcm, right_lcm);} // Function to make queries for array range )l, r).// Node is index of root of current segment in segment// tree (Note that indexes in segment tree begin with 1// for simplicity).// start and end are indexes of subarray covered by root// of current segment.int query(int node, int start, int end, int l, int r){    // Completely outside the segment, returning    // 1 will not affect the lcm;    if (end<l || start>r)        return 1;     // completely inside the segment    if (l<=start && r>=end)        return tree[node];     // partially inside    int mid = (start+end)/2;    int left_lcm = query(2*node, start, mid, l, r);    int right_lcm = query(2*node+1, mid+1, end, l, r);    return lcm(left_lcm, right_lcm);} //driver function to check the above programint main(){    //initialize the array    arr[0] = 5;    arr[1] = 7;    arr[2] = 5;    arr[3] = 2;    arr[4] = 10;    arr[5] = 12;    arr[6] = 11;    arr[7] = 17;    arr[8] = 14;    arr[9] = 1;    arr[10] = 44;     // build the segment tree    build(1, 0, 10);     // Now we can answer each query efficiently     // Print LCM of (2, 5)    cout << query(1, 0, 10, 2, 5) << endl;     // Print LCM of (5, 10)    cout << query(1, 0, 10, 5, 10) << endl;     // Print LCM of (0, 10)    cout << query(1, 0, 10, 0, 10) << endl;     return 0;}
// LCM of given range queries// using Segment Tree class GFG{     static final int MAX = 1000;     // allocate space for tree    static int tree[] = new int[4 * MAX];     // declaring the array globally    static int arr[] = new int[MAX];     // Function to return gcd of a and b    static int gcd(int a, int b) {        if (a == 0) {            return b;        }        return gcd(b % a, a);    }     // utility function to find lcm    static int lcm(int a, int b)    {        return a * b / gcd(a, b);    }     // Function to build the segment tree    // Node starts beginning index    // of current subtree. start and end    // are indexes in arr[] which is global    static void build(int node, int start, int end)    {                 // If there is only one element        // in current subarray        if (start == end)        {            tree[node] = arr[start];            return;        }         int mid = (start + end) / 2;         // build left and right segments        build(2 * node, start, mid);        build(2 * node + 1, mid + 1, end);         // build the parent        int left_lcm = tree[2 * node];        int right_lcm = tree[2 * node + 1];         tree[node] = lcm(left_lcm, right_lcm);    }     // Function to make queries for    // array range )l, r). Node is index    // of root of current segment in segment    // tree (Note that indexes in segment     // tree begin with 1 for simplicity).    // start and end are indexes of subarray    // covered by root of current segment.    static int query(int node, int start,                    int end, int l, int r)    {                 // Completely outside the segment, returning        // 1 will not affect the lcm;        if (end < l || start > r)        {            return 1;        }         // completely inside the segment        if (l <= start && r >= end)        {            return tree[node];        }         // partially inside        int mid = (start + end) / 2;        int left_lcm = query(2 * node, start, mid, l, r);        int right_lcm = query(2 * node + 1, mid + 1, end, l, r);        return lcm(left_lcm, right_lcm);    }     // Driver code    public static void main(String[] args)    {         //initialize the array        arr[0] = 5;        arr[1] = 7;        arr[2] = 5;        arr[3] = 2;        arr[4] = 10;        arr[5] = 12;        arr[6] = 11;        arr[7] = 17;        arr[8] = 14;        arr[9] = 1;        arr[10] = 44;         // build the segment tree        build(1, 0, 10);         // Now we can answer each query efficiently        // Print LCM of (2, 5)        System.out.println(query(1, 0, 10, 2, 5));         // Print LCM of (5, 10)        System.out.println(query(1, 0, 10, 5, 10));         // Print LCM of (0, 10)        System.out.println(query(1, 0, 10, 0, 10));     }} // This code is contributed by 29AjayKumar
# LCM of given range queries using Segment TreeMAX = 1000 # allocate space for treetree = [0] * (4 * MAX) # declaring the array globallyarr = [0] * MAX # Function to return gcd of a and bdef gcd(a: int, b: int):    if a == 0:        return b    return gcd(b % a, a) # utility function to find lcmdef lcm(a: int, b: int):    return (a * b) // gcd(a, b) # Function to build the segment tree# Node starts beginning index of current subtree.# start and end are indexes in arr[] which is globaldef build(node: int, start: int, end: int):     # If there is only one element    # in current subarray    if start == end:        tree[node] = arr[start]        return     mid = (start + end) // 2     # build left and right segments    build(2 * node, start, mid)    build(2 * node + 1, mid + 1, end)     # build the parent    left_lcm = tree[2 * node]    right_lcm = tree[2 * node + 1]     tree[node] = lcm(left_lcm, right_lcm) # Function to make queries for array range )l, r).# Node is index of root of current segment in segment# tree (Note that indexes in segment tree begin with 1# for simplicity).# start and end are indexes of subarray covered by root# of current segment.def query(node: int, start: int,           end: int, l: int, r: int):     # Completely outside the segment,    # returning 1 will not affect the lcm;    if end < l or start > r:        return 1     # completely inside the segment    if l <= start and r >= end:        return tree[node]     # partially inside    mid = (start + end) // 2    left_lcm = query(2 * node, start, mid, l, r)    right_lcm = query(2 * node + 1,                      mid + 1, end, l, r)    return lcm(left_lcm, right_lcm) # Driver Codeif __name__ == "__main__":     # initialize the array    arr[0] = 5    arr[1] = 7    arr[2] = 5    arr[3] = 2    arr[4] = 10    arr[5] = 12    arr[6] = 11    arr[7] = 17    arr[8] = 14    arr[9] = 1    arr[10] = 44     # build the segment tree    build(1, 0, 10)     # Now we can answer each query efficiently     # Print LCM of (2, 5)    print(query(1, 0, 10, 2, 5))     # Print LCM of (5, 10)    print(query(1, 0, 10, 5, 10))     # Print LCM of (0, 10)    print(query(1, 0, 10, 0, 10)) # This code is contributed by# sanjeev2552
// LCM of given range queries// using Segment Treeusing System;using System.Collections.Generic; class GFG{    static readonly int MAX = 1000;     // allocate space for tree    static int []tree = new int[4 * MAX];     // declaring the array globally    static int []arr = new int[MAX];     // Function to return gcd of a and b    static int gcd(int a, int b)    {        if (a == 0)        {            return b;        }        return gcd(b % a, a);    }     // utility function to find lcm    static int lcm(int a, int b)    {        return a * b / gcd(a, b);    }     // Function to build the segment tree    // Node starts beginning index    // of current subtree. start and end    // are indexes in []arr which is global    static void build(int node, int start, int end)    {                 // If there is only one element        // in current subarray        if (start == end)        {            tree[node] = arr[start];            return;        }         int mid = (start + end) / 2;         // build left and right segments        build(2 * node, start, mid);        build(2 * node + 1, mid + 1, end);         // build the parent        int left_lcm = tree[2 * node];        int right_lcm = tree[2 * node + 1];         tree[node] = lcm(left_lcm, right_lcm);    }     // Function to make queries for    // array range )l, r). Node is index    // of root of current segment in segment    // tree (Note that indexes in segment    // tree begin with 1 for simplicity).    // start and end are indexes of subarray    // covered by root of current segment.    static int query(int node, int start,                     int end, int l, int r)    {                 // Completely outside the segment,        // returning 1 will not affect the lcm;        if (end < l || start > r)        {            return 1;        }         // completely inside the segment        if (l <= start && r >= end)        {            return tree[node];        }         // partially inside        int mid = (start + end) / 2;        int left_lcm = query(2 * node, start, mid, l, r);        int right_lcm = query(2 * node + 1,                              mid + 1, end, l, r);        return lcm(left_lcm, right_lcm);    }     // Driver code    public static void Main(String[] args)    {         // initialize the array        arr[0] = 5;        arr[1] = 7;        arr[2] = 5;        arr[3] = 2;        arr[4] = 10;        arr[5] = 12;        arr[6] = 11;        arr[7] = 17;        arr[8] = 14;        arr[9] = 1;        arr[10] = 44;         // build the segment tree        build(1, 0, 10);         // Now we can answer each query efficiently        // Print LCM of (2, 5)        Console.WriteLine(query(1, 0, 10, 2, 5));         // Print LCM of (5, 10)        Console.WriteLine(query(1, 0, 10, 5, 10));         // Print LCM of (0, 10)        Console.WriteLine(query(1, 0, 10, 0, 10));    }} // This code is contributed by Rajput-Ji
<script>// LCM of given range queries using Segment Treeconst MAX = 1000 // allocate space for treevar tree = new Array(4*MAX); // declaring the array globallyvar arr = new Array(MAX); // Function to return gcd of a and bfunction gcd(a, b){    if (a == 0)        return b;    return gcd(b%a, a);} //utility function to find lcmfunction lcm(a, b){    return Math.floor(a*b/gcd(a,b));} // Function to build the segment tree// Node starts beginning index of current subtree.// start and end are indexes in arr[] which is globalfunction build(node, start, end){    // If there is only one element in current subarray    if (start==end)    {        tree[node] = arr[start];        return;    }     let mid = Math.floor((start+end)/2);     // build left and right segments    build(2*node, start, mid);    build(2*node+1, mid+1, end);     // build the parent    let left_lcm = tree[2*node];    let right_lcm = tree[2*node+1];     tree[node] = lcm(left_lcm, right_lcm);} // Function to make queries for array range )l, r).// Node is index of root of current segment in segment// tree (Note that indexes in segment tree begin with 1// for simplicity).// start and end are indexes of subarray covered by root// of current segment.function query(node, start, end, l, r){    // Completely outside the segment, returning    // 1 will not affect the lcm;    if (end<l || start>r)        return 1;     // completely inside the segment    if (l<=start && r>=end)        return tree[node];     // partially inside    let mid = Math.floor((start+end)/2);    let left_lcm = query(2*node, start, mid, l, r);    let right_lcm = query(2*node+1, mid+1, end, l, r);    return lcm(left_lcm, right_lcm);} //driver function to check the above program    //initialize the array    arr[0] = 5;    arr[1] = 7;    arr[2] = 5;    arr[3] = 2;    arr[4] = 10;    arr[5] = 12;    arr[6] = 11;    arr[7] = 17;    arr[8] = 14;    arr[9] = 1;    arr[10] = 44;     // build the segment tree    build(1, 0, 10);     // Now we can answer each query efficiently     // Print LCM of (2, 5)    document.write(query(1, 0, 10, 2, 5) +"<br>");     // Print LCM of (5, 10)    document.write(query(1, 0, 10, 5, 10) + "<br>");     // Print LCM of (0, 10)    document.write(query(1, 0, 10, 0, 10) + "<br>"); // This code is contributed by Manoj.</script>
Output:  
60
15708
78540
This article is contributed by Ashutosh Kumar. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
29AjayKumar
sanjeev2552
Rajput-Ji
mank1083
array-range-queries
Segment-Tree
Advanced Data Structure
Tree
Tree
Segment-Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Agents in Artificial Intelligence
Decision Tree Introduction with example
Segment Tree | Set 1 (Sum of given range)
AVL Tree | Set 2 (Deletion)
Ordered Set and GNU C++ PBDS
Tree Traversals (Inorder, Preorder and Postorder)
Binary Tree | Set 1 (Introduction)
Level Order Binary Tree Traversal
Binary Tree | Set 3 (Types of Binary Tree)
Inorder Tree Traversal without Recursion