范围 LCM 查询的 C++ 程序

给定一个整数数组，计算 LCM(l, r) 形式的查询。可能有很多查询，因此可以有效地评估查询。

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])

例子：

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.

一个天真的解决方案是遍历每个查询的数组并使用以下方法计算答案，
LCM(a, b) = (a*b) / GCD(a,b)
但是，由于查询的数量可能很大，因此这种解决方案是不切实际的。
一个有效的解决方案是使用段树。回想一下，在这种不需要更新的情况下，我们可以构建一次树，然后可以重复使用它来回答查询。树中的每个节点都应该存储该特定段的 LCM 值，我们可以使用与上述相同的公式来组合这些段。因此，我们可以有效地回答每个查询！
以下是相同的解决方案。

C++

// LCM of given range queries using Segment Tree
#include 
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 (endr)
        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;
}

输出：

60
15708
78540

有关详细信息，请参阅有关范围 LCM 查询的完整文章！