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++
// LCM of given range queries using Segment Tree #include <bits/stdc++.h> using namespace std; #define MAX 1000 // allocate space for tree int tree[4*MAX]; // declaring the array globally int arr[MAX]; // Function to return gcd of a and b int gcd(int a, int b) { if (a == 0) return b; return gcd(b%a, a); } //utility function to find lcm 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 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. 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 program int 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; } |
chevron_right
filter_none
Java
// 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 |
chevron_right
filter_none
Python3
# LCM of given range queries using Segment Tree MAX = 1000 # allocate space for tree tree = [0] * (4 * MAX) # declaring the array globally arr = [0] * MAX # Function to return gcd of a and b def gcd(a: int, b: int): if a == 0: return b return gcd(b % a, a) # utility function to find lcm def 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 global def 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 Code if __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 |
chevron_right
filter_none
C#
// LCM of given range queries // using Segment Tree using 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 |
chevron_right
filter_none
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 contribute.geeksforgeeks.org or mail your article to contribute@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.
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.
Recommended Posts:
- Array range queries over range queries
- Binary Indexed Tree : Range Update and Range Queries
- Queries for elements having values within the range A to B in the given index range using Segment Tree
- Range Queries to count elements lying in a given Range : MO's Algorithm
- Find two distinct numbers such that their LCM lies in given range
- Min-Max Range Queries in Array
- Binary Indexed Tree : Range Updates and Point Queries
- Range Queries for Frequencies of array elements
- Queries for GCD of all numbers of an array except elements in a given range
- Queries for counts of array elements with values in given range
- Queries on XOR of greatest odd divisor of the range
- Array range queries for elements with frequency same as value
- Range Queries for Longest Correct Bracket Subsequence
- Array range queries for searching an element
- Range product queries in an array
- Number of elements greater than K in the range L to R using Fenwick Tree (Offline queries)
- Queries to find maximum product pair in range with updates
- Find the Initial Array from given array after range sum queries
- Queries to check whether a given digit is present in the given Range
- Range queries to count 1s in a subarray after flip operations
