Given an array arr[] of integers of size N and an array of Q queries, query[], where each query is of type [L, R] denoting the range from index L to index R, the task is to find the LCM of all the numbers of the range for all the queries.
Examples:
Input: arr[] = {5, 7, 5, 2, 10, 12 ,11, 17, 14, 1, 44}
query[] = {{2, 5}, {5, 10}, {0, 10}}
Output: 60,15708, 78540
Explanation: In the first query LCM(5, 2, 10, 12) = 60
In the second query LCM(12, 11, 17, 14, 1, 44) = 15708
In the last query LCM(5, 7, 5, 2, 10, 12, 11, 17, 14, 1, 44) = 78540
Input: arr[] = {2, 4, 8, 16}, query[] = {{2, 3}, {0, 1}}
Output: 16, 4
Naive Approach: The approach is based on the following mathematical idea:
Mathematically, LCM(l, r) = LCM(arr[l], arr[l+1] , . . . ,arr[r-1], arr[r]) and
LCM(a, b) = (a*b) / GCD(a,b)
So traverse the array for every query and calculate the answer by using the above formula for LCM.
Time Complexity: O(N * Q)
Auxiliary Space: O(1)
As the number of queries can be large, the naive solution would be impractical. This time can be reduced
There is no update operation in this problem. So we can initially build a segment tree and use that to answer the queries in logarithmic time.
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.
Follow the steps mentioned below to implement the idea:
- Build a segment tree from the given array.
- Traverse through the queries. For each query:
- Find that particular range in the segment tree.
- Use the above mentioned formula to combine the segments and calculate the LCM for that range.
- Print the answer for that segment.
Below is the implementation of the above approach.
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;
}
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
Python
# 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
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
JavaScript
<script>
// LCM of given range queries using Segment Tree
const MAX = 1000
// allocate space for tree
var tree = new Array(4*MAX);
// declaring the array globally
var arr = new Array(MAX);
// Function to return gcd of a and b
function gcd(a, b)
{
if (a == 0)
return b;
return gcd(b%a, a);
}
//utility function to find lcm
function 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 global
function 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>
Time Complexity: O(Log N * Log n) where N is the number of elements in the array. The other log n denotes the time required for finding the LCM. This time complexity is for each query. The total time complexity is O(N + Q*Log N*log n), this is because O(N) time is required to build the tree and then to answer the queries.
Auxiliary Space: O(N), where N is the number of elements in the array. This space is required for storing the segment tree.
Related Topic: Segment Tree
Approach#2: Using math
We first define a helper function lcm() to calculate the least common multiple of two numbers. Then, for each query, we iterate through the subarray of arr defined by the query range and calculate the LCM using the lcm() function. The LCM value is stored in a list, which is returned as the final result.
Algorithm
1. Define a helper function lcm(a, b) to calculate the least common multiple of two numbers.
2. Define a function range_lcm_queries(arr, queries) that takes an array arr and a list of query ranges queries as input.
3. Create an empty list results to store the LCM values for each query.
4. For each query in queries, extract the left and right indices l and r.
5. Set lcm_val to the value of arr[l].
6. For each index i in the range l+1 to r, update lcm_val to be the LCM of lcm_val and arr[i] using the lcm() function.
7. Append lcm_val to the results list.
8. Return the results list.
C++
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int lcm(int a, int b) {
return a * b / gcd(a, b);
}
vector<int> rangeLcmQueries(vector<int>& arr, vector<pair<int, int>>& queries) {
vector<int> results;
for (const auto& query : queries) {
int l = query.first;
int r = query.second;
int lcmVal = arr[l];
for (int i = l + 1; i <= r; i++) {
lcmVal = lcm(lcmVal, arr[i]);
}
results.push_back(lcmVal);
}
return results;
}
int main() {
vector<int> arr = {5, 7, 5, 2, 10, 12, 11, 17, 14, 1, 44};
vector<pair<int, int>> queries = {{2, 5}, {5, 10}, {0, 10}};
vector<int> results = rangeLcmQueries(arr, queries);
for (const auto& result : results) {
cout << result << " ";
}
cout << endl;
return 0;
}
Java
/*package whatever //do not write package name here */
import java.util.ArrayList;
import java.util.List;
public class GFG {
public static int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
public static int lcm(int a, int b) {
return a * b / gcd(a, b);
}
public static List<Integer> rangeLcmQueries(List<Integer> arr, List<int[]> queries) {
List<Integer> results = new ArrayList<>();
for (int[] query : queries) {
int l = query[0];
int r = query[1];
int lcmVal = arr.get(l);
for (int i = l + 1; i <= r; i++) {
lcmVal = lcm(lcmVal, arr.get(i));
}
results.add(lcmVal);
}
return results;
}
public static void main(String[] args) {
List<Integer> arr = List.of(5, 7, 5, 2, 10, 12, 11, 17, 14, 1, 44);
List<int[]> queries = List.of(new int[]{2, 5}, new int[]{5, 10}, new int[]{0, 10});
List<Integer> results = rangeLcmQueries(arr, queries);
for (int result : results) {
System.out.print(result + " ");
}
System.out.println();
}
}
Python
from math import gcd
def lcm(a, b):
return a*b // gcd(a, b)
def range_lcm_queries(arr, queries):
results = []
for query in queries:
l, r = query
lcm_val = arr[l]
for i in range(l+1, r+1):
lcm_val = lcm(lcm_val, arr[i])
results.append(lcm_val)
return results
# example usage
arr = [5, 7, 5, 2, 10, 12 ,11, 17, 14, 1, 44]
queries = [(2, 5), (5, 10), (0, 10)]
print(range_lcm_queries(arr, queries)) # output: [60, 15708, 78540]
C#
using System;
using System.Collections.Generic;
class GFG
{
// Function to calculate the greatest common divisor (GCD)
// using Euclidean algorithm
static int GCD(int a, int b)
{
if (b == 0)
return a;
return GCD(b, a % b);
}
// Function to calculate the least common multiple (LCM)
// using GCD
static int LCM(int a, int b)
{
return a * b / GCD(a, b);
}
static List<int> RangeLcmQueries(List<int> arr, List<Tuple<int, int>> queries)
{
List<int> results = new List<int>();
foreach (var query in queries)
{
int l = query.Item1;
int r = query.Item2;
int lcmVal = arr[l];
for (int i = l + 1; i <= r; i++)
{
lcmVal = LCM(lcmVal, arr[i]);
}
results.Add(lcmVal);
}
return results;
}
static void Main()
{
List<int> arr = new List<int> { 5, 7, 5, 2, 10, 12, 11, 17, 14, 1, 44 };
List<Tuple<int, int>> queries = new List<Tuple<int, int>> {
Tuple.Create(2, 5),
Tuple.Create(5, 10),
Tuple.Create(0, 10)
};
List<int> results = RangeLcmQueries(arr, queries);
foreach (var result in results)
{
Console.Write(result + " ");
}
Console.WriteLine();
}
}
JavaScript
// JavaScript Program for the above approach
// function to find out gcd
function gcd(a, b) {
if (b === 0) {
return a;
}
return gcd(b, a % b);
}
// function to find out lcm
function lcm(a, b) {
return (a * b) / gcd(a, b);
}
function rangeLcmQueries(arr, queries) {
const results = [];
for (const query of queries) {
const l = query[0];
const r = query[1];
let lcmVal = arr[l];
for (let i = l + 1; i <= r; i++) {
lcmVal = lcm(lcmVal, arr[i]);
}
results.push(lcmVal);
}
return results;
}
// Driver code to test above function
const arr = [5, 7, 5, 2, 10, 12, 11, 17, 14, 1, 44];
const queries = [[2, 5], [5, 10], [0, 10]];
const results = rangeLcmQueries(arr, queries);
for (const result of results) {
console.log(result + " ");
}
console.log();
// THIS CODE IS CONTRIBUTED BY PIYUSH AGARWAL
Time Complexity: O(log(min(a,b))). For each query range, we iterate through a subarray of size O(n), where n is the length of arr. Therefore, the time complexity of the overall function is O(qn log(min(a_i))) where q is the number of queries and a_i is the i-th element of arr.
Space Complexity: O(1) since we are only storing a few integers at a time. The space used by the input arr and queries is not considered.
Similar Reads
Segment Tree Segment Tree is a data structure that allows efficient querying and updating of intervals or segments of an array. It is particularly useful for problems involving range queries, such as finding the sum, minimum, maximum, or any other operation over a specific range of elements in an array. The tree
3 min read
Segment tree meaning in DSA A segment tree is a data structure used to effectively query and update ranges of array members. It's typically implemented as a binary tree, with each node representing a segment or range of array elements. Segment tree Characteristics of Segment Tree:A segment tree is a binary tree with a leaf nod
2 min read
Introduction to Segment Trees - Data Structure and Algorithm Tutorials A Segment Tree is used to store information about array intervals in its nodes.It allows efficient range queries over array intervals.Along with queries, it allows efficient updates of array items.For example, we can perform a range summation of an array between the range L to R in O(Log n) while al
15+ min read
Persistent Segment Tree | Set 1 (Introduction) Prerequisite : Segment Tree Persistency in Data Structure Segment Tree is itself a great data structure that comes into play in many cases. In this post we will introduce the concept of Persistency in this data structure. Persistency, simply means to retain the changes. But obviously, retaining the
15+ min read
Segment tree | Efficient implementation Let us consider the following problem to understand Segment Trees without recursion.We have an array arr[0 . . . n-1]. We should be able to, Find the sum of elements from index l to r where 0 <= l <= r <= n-1Change the value of a specified element of the array to a new value x. We need to d
12 min read
Iterative Segment Tree (Range Maximum Query with Node Update) Given an array arr[0 . . . n-1]. The task is to perform the following operation: Find the maximum of elements from index l to r where 0 <= l <= r <= n-1.Change value of a specified element of the array to a new value x. Given i and x, change A[i] to x, 0 <= i <= n-1. Examples: Input:
14 min read
Range Sum and Update in Array : Segment Tree using Stack Given an array arr[] of N integers. The task is to do the following operations: Add a value X to all the element from index A to B where 0 ? A ? B ? N-1.Find the sum of the element from index L to R where 0 ? L ? R ? N-1 before and after the update given to the array above.Example: Input: arr[] = {1
15+ min read
Dynamic Segment Trees : Online Queries for Range Sum with Point Updates Prerequisites: Segment TreeGiven a number N which represents the size of the array initialized to 0 and Q queries to process where there are two types of queries: 1 P V: Put the value V at position P.2 L R: Output the sum of values from L to R. The task is to answer these queries. Constraints: 1 ? N
15+ min read
Applications, Advantages and Disadvantages of Segment Tree First, let us understand why we need it prior to landing on the introduction so as to get why this concept was introduced. Suppose we are given an array and we need to find out the subarray Purpose of Segment Trees: A segment tree is a data structure that deals with a range of queries over an array.
4 min read
Lazy Propagation
Lazy Propagation in Segment TreeSegment tree is introduced in previous post with an example of range sum problem. We have used the same "Sum of given Range" problem to explain Lazy propagation  How does update work in Simple Segment Tree? In the previous post, update function was called to update only a single value in array. Ple
15+ min read
Lazy Propagation in Segment Tree | Set 2Given an array arr[] of size N. There are two types of operations: Update(l, r, x) : Increment the a[i] (l <= i <= r) with value x.Query(l, r) : Find the maximum value in the array in a range l to r (both are included).Examples: Input: arr[] = {1, 2, 3, 4, 5} Update(0, 3, 4) Query(1, 4) Output
15+ min read
Flipping Sign Problem | Lazy Propagation Segment TreeGiven an array of size N. There can be multiple queries of the following types. update(l, r) : On update, flip( multiply a[i] by -1) the value of a[i] where l <= i <= r . In simple terms, change the sign of a[i] for the given range.query(l, r): On query, print the sum of the array in given ran
15+ min read