Querying maximum number of divisors that a number in a given range has

Segment Tree | Range Minimum Query

Last Updated : 11 Feb, 2025

Try it on GfG Practice

We have introduced a segment tree with a simple example in the previous post. In this post, the Range Minimum Query problem is discussed as another example where a Segment Tree can be used. The following is the problem statement:
We have an array arr[0 . . . n-1]. We should be able to efficiently find the minimum value from index q_s (query start) to q_e (query end) where 0 <= q_s <= q_e <= n-1.

A simple solution is to run a loop from q_s to q_e and find the minimum element in the given range. This solution takes O(n) time in the worst case.
Another solution is to create a 2D array where an entry [i, j] stores the minimum value in range arr[i..j]. The minimum of a given range can now be calculated in O(1) time, but preprocessing takes O(n²) time. Also, this approach needs O(n²) extra space which may become huge for large input arrays.
Segment tree can be used to do preprocessing and query in moderate time. With a segment tree, preprocessing time is O(n) and the time complexity for a range minimum query is O(log n). The extra space required is O(n) to store the segment tree.

Representation of Segment trees

1. Leaf Nodes are the elements of the input array.
2. Each internal node represents minimum of all leaves under it.
An array representation of tree is used to represent Segment Trees. For each node at index i, the left child is at index (2 * i + 1), right child at (2 * i + 2) and the parent is at (i – 1) / 2

Construction of Segment Tree from given array

We start with a segment arr[0 . . . n-1]. and every time we divide the current segment into two halves (if it has not yet become a segment of length 1), and then call the same procedure on both halves, and for each such segment, we store the minimum value in a segment tree node.

All levels of the constructed segment tree will be completely filled except the last level. Also, the tree will be a Full Binary Tree because we always divide segments in two halves at every level. Since the constructed tree is always full binary tree with n leaves, there will be n – 1 internal nodes. So total number of nodes will be 2 * n – 1.
Height of the segment tree will be ?log?n?. Since the tree is represented using array and relation between parent and child indexes must be maintained, size of memory allocated for segment tree will be 2 * 2^?log₂^n? – 1.

Query for minimum value of given range

Once the tree is constructed, how to do range minimum query using the constructed segment tree. Following is algorithm to get the minimum.

// q_s–> query start index, q_e –> query end index
int RMQ(node, q_s, q_e) {
if range of node is within q_sand q_e
return value in node
else if range of node is completely outside q_sand q_e
return INFINITE
else
return min ( RMQ(node’s left child, q_s, q_e), RMQ (node’s right child, q_s, q_e) )
}

C++

// C++ program for range minimum
// query using segment tree 
#include <bits/stdc++.h>
using namespace std;

// A utility function to get minimum of two numbers 
int minVal(int x, int y) { 
    return (x < y)? x: y; 
} 

// A utility function to get the 
// middle index from corner indexes. 
int getMid(int s, int e) { 
    return s + (e -s)/2; 
} 

// A recursive function to get the
// minimum value in a given range of array
// st --> Pointer to segment tree 
// index --> Index of current node in the tree
// ss & se --> Starting and ending indexes 
// qs & qe --> Starting and ending indexes of query range
int RMQUtil(vector<int> &st, int ss, int se, int qs, 
                                int qe, int index) { 

    // If segment of this node is a part of given range
    // then return the min of the segment
    if (qs <= ss && qe >= se) 
        return st[index]; 

    // If segment of this node if outside the range
    if (se < qs || ss > qe) 
        return INT_MAX; 

    // If a part of this segment
    // overlaps with the given range 
    int mid = getMid(ss, se); 
    return minVal(RMQUtil(st, ss, mid, qs, qe, 2*index+1), 
                RMQUtil(st, mid+1, se, qs, qe, 2*index+2)); 
} 

// Return minimum of elements in range
// from index qs to qe
int RMQ(vector<int> &st, int n, int qs, int qe) { 

    // Check for invalid input
    if (qs < 0 || qe > n-1 || qs > qe) { 
        cout<<"Invalid Input"; 
        return -1; 
    } 
    return RMQUtil(st, 0, n-1, qs, qe, 0); 
} 

// A recursive function that constructs
// Segment Tree for array[ss..se]. 
int constructSTUtil(vector<int> &arr, int ss, int se,
                            vector<int> &st, int si) {

    // If there is one element in array,
    // store it in current node of 
    // segment tree and return 
    if (ss == se) { 
        st[si] = arr[ss]; 
        return arr[ss]; 
    } 

    // If there are more than one elements, 
    // then recur for left and right subtrees 
    // and store the minimum of two values in this node 
    int mid = getMid(ss, se); 
    st[si] = minVal(constructSTUtil(arr, ss, mid, st, si*2+1), 
                    constructSTUtil(arr, mid+1, se, st, si*2+2)); 
    return st[si]; 
} 

// Function to construct segment tree 
vector<int> constructST(vector<int> &arr, int n) { 

    //Height of segment tree 
    int x = (int)(ceil(log2(n))); 

    // Maximum size of segment tree 
    int max_size = 2*(int)pow(2, x) - 1; 

    vector<int> st(max_size);

    // Fill the allocated memory st 
    constructSTUtil(arr, 0, n-1, st, 0); 

    // Return the constructed segment tree 
    return st; 
} 

int main() {
 
    vector<int> arr = {1, 3, 2, 7, 9, 11}; 
    int n = arr.size();

    // Build segment tree from given array 
    vector<int> st = constructST(arr, n); 

    // Starting index of query range 
    int qs = 1; 
    
    // Ending index of query range 
    int qe = 5; 

    // Print minimum value in arr[qs..qe] 
    cout<<"Minimum of values in range ["<<qs<<", "<<qe<<"] "<<
    "is = "<<RMQ(st, n, qs, qe)<<endl; 

    return 0; 
}

C

// C program for range minimum query 
// using segment tree
#include <stdio.h>
#include <math.h>
#include <limits.h>
#include <stdlib.h>

// A utility function to get minimum of two numbers 
int minVal(int x, int y) { 
    return (x < y)? x: y; 
} 

// A utility function to get the 
// middle index from corner indexes. 
int getMid(int s, int e) { 
    return s + (e -s)/2; 
} 

// A recursive function to get the
// minimum value in a given range of array
// st --> Pointer to segment tree 
// index --> Index of current node in the tree
// ss & se --> Starting and ending indexes 
// qs & qe --> Starting and ending indexes of query range
int RMQUtil(int *st, int ss, int se, 
            int qs, int qe, int index) {

    // If segment of this node is a part of given range
    // then return the min of the segment
    if (qs <= ss && qe >= se) 
        return st[index]; 

    // If segment of this node if outside the range
    if (se < qs || ss > qe) 
        return INT_MAX; 

    // If a part of this segment
    // overlaps with the given range 
    int mid = getMid(ss, se); 
    return minVal(RMQUtil(st, ss, mid, qs, qe, 2*index+1), 
                RMQUtil(st, mid+1, se, qs, qe, 2*index+2));
}

// Return minimum of elements in range
// from index qs to qe
int RMQ(int *st, int n, int qs, int qe) {

    // Check for erroneous input values
    if (qs < 0 || qe > n-1 || qs > qe) {
        printf("Invalid Input");
        return -1;
    }

    return RMQUtil(st, 0, n-1, qs, qe, 0);
}

// A recursive function that constructs
// Segment Tree for array[ss..se]. 
int constructSTUtil(int arr[], int ss, int se, 
                            int *st, int si) {

    // If there is one element in array,
    // store it in current node of 
    // segment tree and return 
    if (ss == se) { 
        st[si] = arr[ss]; 
        return arr[ss]; 
    } 

    // If there are more than one elements, 
    // then recur for left and right subtrees 
    // and store the minimum of two values in this node 
    int mid = getMid(ss, se); 
    st[si] = minVal(constructSTUtil(arr, ss, mid, st, si*2+1), 
                    constructSTUtil(arr, mid+1, se, st, si*2+2)); 
    return st[si]; 
}

// Function to construct segment tree
int *constructST(int arr[], int n) {

    //Height of segment tree
    int x = (int)(ceil(log2(n))); 

    // Maximum size of segment tree
    int max_size = 2*(int)pow(2, x) - 1; 

    int *st = (int*)malloc(max_size * sizeof(int));

    // Fill the allocated memory st
    constructSTUtil(arr, 0, n-1, st, 0);

    // Return the constructed segment tree
    return st;
}

int main() {
    int arr[] = {1, 3, 2, 7, 9, 11};
    int n = sizeof(arr)/sizeof(arr[0]);

    // Build segment tree from given array
    int *st = constructST(arr, n);

    // Starting index of query range
    int qs = 1;  

    // Ending index of query range
    int qe = 5;  

    // Print minimum value in arr[qs..qe]
    printf("Minimum of values in range [%d, %d] is = %d\n",
                           qs, qe, RMQ(st, n, qs, qe));

    return 0;
}

Java

// Java program for range minimum 
// query using segment tree 
import java.util.*;

class GFG {

    // A utility function to get minimum of two numbers
    static int minVal(int x, int y) {
        return (x < y) ? x : y;
    }

    // A utility function to get the 
    // middle index from corner indexes.
    static int getMid(int s, int e) {
        return s + (e - s) / 2;
    }

    // A recursive function to get the
    // minimum value in a given range of array
    static int RMQUtil(int[] st, int ss, int se, 
                        int qs, int qe, int index) {

        // If segment of this node is a part of given range
        // then return the min of the segment
        if (qs <= ss && qe >= se)
            return st[index];

        // If segment of this node is outside the range
        if (se < qs || ss > qe)
            return Integer.MAX_VALUE;

        // If a part of this segment
        // overlaps with the given range
        int mid = getMid(ss, se);
        return minVal(RMQUtil(st, ss, mid, qs, qe, 2 * index + 1),
                      RMQUtil(st, mid + 1, se, qs, qe, 2 * index + 2));
    }

    // Return minimum of elements in range
    // from index qs to qe
    static int RMQ(int[] st, int n, int qs, int qe) {

        // Check for invalid input
        if (qs < 0 || qe > n - 1 || qs > qe) {
            System.out.println("Invalid Input");
            return -1;
        }
        return RMQUtil(st, 0, n - 1, qs, qe, 0);
    }

    // A recursive function that constructs
    // Segment Tree for array[ss..se]. 
    static int constructSTUtil(int[] arr, int ss, 
                        int se, int[] st, int si) {

        // If there is one element in array,
        // store it in current node of 
        // segment tree and return 
        if (ss == se) {
            st[si] = arr[ss];
            return arr[ss];
        }

        // If there are more than one elements, 
        // then recur for left and right subtrees 
        // and store the minimum of two values in this node 
        int mid = getMid(ss, se);
        st[si] = minVal(constructSTUtil(arr, ss, mid, st, si * 2 + 1),
                        constructSTUtil(arr, mid + 1, se, st, si * 2 + 2));
        return st[si];
    }

    // Function to construct segment tree
    static int[] constructST(int[] arr, int n) {

        // Height of segment tree
        int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));

        // Maximum size of segment tree
        int max_size = 2 * (int) Math.pow(2, x) - 1;

        int[] st = new int[max_size];

        // Fill the allocated memory st
        constructSTUtil(arr, 0, n - 1, st, 0);

        // Return the constructed segment tree
        return st;
    }

    public static void main(String[] args) {

        int[] arr = {1, 3, 2, 7, 9, 11};
        int n = arr.length;

        // Build segment tree from given array
        int[] st = constructST(arr, n);

        // Starting index of query range
        int qs = 1;

        // Ending index of query range
        int qe = 5;

        // Print minimum value in arr[qs..qe]
        System.out.println("Minimum of values in range [" + qs + ", " + qe + "] " +
                           "is = " + RMQ(st, n, qs, qe));
    }
}

Python

# A utility function to get minimum of two numbers
def minVal(x, y):
    return x if x < y else y

# A utility function to get the 
# middle index from corner indexes.
def getMid(s, e):
    return s + (e - s) // 2

# A recursive function to get the
# minimum value in a given range of array
def RMQUtil(st, ss, se, qs, qe, index):

    # If segment of this node is a part of given range
    # then return the min of the segment
    if qs <= ss and qe >= se:
        return st[index]

    # If segment of this node is outside the range
    if se < qs or ss > qe:
        return float('inf')

    # If a part of this segment
    # overlaps with the given range
    mid = getMid(ss, se)
    return minVal(RMQUtil(st, ss, mid, qs, qe, 2 * index + 1),
                  RMQUtil(st, mid + 1, se, qs, qe, 2 * index + 2))

# Return minimum of elements in range
# from index qs to qe
def RMQ(st, n, qs, qe):

    # Check for invalid input
    if qs < 0 or qe > n - 1 or qs > qe:
        print("Invalid Input")
        return -1
    return RMQUtil(st, 0, n - 1, qs, qe, 0)

# A recursive function that constructs
# Segment Tree for array[ss..se]. 
def constructSTUtil(arr, ss, se, st, si):

    # If there is one element in array,
    # store it in current node of 
    # segment tree and return 
    if ss == se:
        st[si] = arr[ss]
        return arr[ss]

    # If there are more than one elements, 
    # then recur for left and right subtrees 
    # and store the minimum of two values in this node 
    mid = getMid(ss, se)
    st[si] = minVal(constructSTUtil(arr, ss, mid, st, si * 2 + 1),
                    constructSTUtil(arr, mid + 1, se, st, si * 2 + 2))
    return st[si]

# Function to construct segment tree
def constructST(arr, n):

    # Height of segment tree
    x = (n - 1).bit_length()

    # Maximum size of segment tree
    max_size = 2 * (2**x) - 1

    st = [0] * max_size

    # Fill the allocated memory st
    constructSTUtil(arr, 0, n - 1, st, 0)

    # Return the constructed segment tree
    return st

if __name__ == "__main__" : 
    arr = [1, 3, 2, 7, 9, 11]
    n = len(arr)

    # Build segment tree from given array
    st = constructST(arr, n)

    # Starting index of query range
    qs = 1

    # Ending index of query range
    qe = 5

    # Print minimum value in arr[qs..qe]
    print(f"Minimum of values in range [{qs}, {qe}] is = {RMQ(st, n, qs, qe)}")

C#

// C# program for range minimum 
// query using segment tree
using System;
using System.Collections.Generic;

class GFG {
    
    // A utility function to get minimum of two numbers
    static int minVal(int x, int y) {
        return (x < y) ? x : y;
    }

    // A utility function to get the 
    // middle index from corner indexes.
    static int getMid(int s, int e) {
        return s + (e - s) / 2;
    }

    // A recursive function to get the
    // minimum value in a given range of array
    static int RMQUtil(int[] st, int ss, int se, 
                        int qs, int qe, int index) {
                            
        // If segment of this node is a part of given range
        // then return the min of the segment
        if (qs <= ss && qe >= se)
            return st[index];

        // If segment of this node is outside the range
        if (se < qs || ss > qe)
            return int.MaxValue;

        // If a part of this segment
        // overlaps with the given range
        int mid = getMid(ss, se);
        return minVal(RMQUtil(st, ss, mid, qs, qe, 2 * index + 1),
                      RMQUtil(st, mid + 1, se, qs, qe, 2 * index + 2));
    }

    // Return minimum of elements in range
    // from index qs to qe
    static int RMQ(int[] st, int n, int qs, int qe) {
        
        // Check for invalid input
        if (qs < 0 || qe > n - 1 || qs > qe) {
            Console.WriteLine("Invalid Input");
            return -1;
        }
        return RMQUtil(st, 0, n - 1, qs, qe, 0);
    }

    // A recursive function that constructs
    // Segment Tree for array[ss..se]. 
    static int constructSTUtil(int[] arr, int ss, 
                        int se, int[] st, int si) {
                            
        // If there is one element in array,
        // store it in current node of 
        // segment tree and return 
        if (ss == se) {
            st[si] = arr[ss];
            return arr[ss];
        }

        // If there are more than one elements, 
        // then recur for left and right subtrees 
        // and store the minimum of two values in this node 
        int mid = getMid(ss, se);
        st[si] = minVal(constructSTUtil(arr, ss, mid, st, si * 2 + 1),
                        constructSTUtil(arr, mid + 1, se, st, si * 2 + 2));
        return st[si];
    }

    // Function to construct segment tree
    static int[] constructST(int[] arr, int n) {
        
        // Height of segment tree
        int x = (int)Math.Ceiling(Math.Log(n) / Math.Log(2));

        // Maximum size of segment tree
        int max_size = 2 * (int)Math.Pow(2, x) - 1;

        int[] st = new int[max_size];

        // Fill the allocated memory st
        constructSTUtil(arr, 0, n - 1, st, 0);

        // Return the constructed segment tree
        return st;
    }

    static void Main() {
        int[] arr = {1, 3, 2, 7, 9, 11};
        int n = arr.Length;

        // Build segment tree from given array
        int[] st = constructST(arr, n);

        // Starting index of query range
        int qs = 1;

        // Ending index of query range
        int qe = 5;

        // Print minimum value in arr[qs..qe]
        Console.WriteLine("Minimum of values in range [" + qs + ", " + qe + "] " +
                          "is = " + RMQ(st, n, qs, qe));
    }
}

JavaScript

// A utility function to get minimum of two numbers
function minVal(x, y) {
    return (x < y) ? x : y;
}

// A utility function to get the 
// middle index from corner indexes.
function getMid(s, e) {
    return s + Math.floor((e - s) / 2);
}

// A recursive function to get the
// minimum value in a given range of array
function RMQUtil(st, ss, se, qs, qe, index) {

    // If segment of this node is a part of given range
    // then return the min of the segment
    if (qs <= ss && qe >= se)
        return st[index];

    // If segment of this node is outside the range
    if (se < qs || ss > qe)
        return Number.MAX_SAFE_INTEGER;

    // If a part of this segment
    // overlaps with the given range
    let mid = getMid(ss, se);
    return minVal(RMQUtil(st, ss, mid, qs, qe, 2 * index + 1),
                  RMQUtil(st, mid + 1, se, qs, qe, 2 * index + 2));
}

// Return minimum of elements in range
// from index qs to qe
function RMQ(st, n, qs, qe) {

    // Check for invalid input
    if (qs < 0 || qe > n - 1 || qs > qe) {
        console.log("Invalid Input");
        return -1;
    }
    return RMQUtil(st, 0, n - 1, qs, qe, 0);
}

// A recursive function that constructs
// Segment Tree for array[ss..se]. 
function constructSTUtil(arr, ss, se, st, si) {

    // If there is one element in array,
    // store it in current node of 
    // segment tree and return 
    if (ss === se) {
        st[si] = arr[ss];
        return arr[ss];
    }

    // If there are more than one elements, 
    // then recur for left and right subtrees 
    // and store the minimum of two values in this node 
    let mid = getMid(ss, se);
    st[si] = minVal(constructSTUtil(arr, ss, mid, st, si * 2 + 1),
                    constructSTUtil(arr, mid + 1, se, st, si * 2 + 2));
    return st[si];
}

// Function to construct segment tree
function constructST(arr, n) {

    // Height of segment tree
    let x = Math.ceil(Math.log2(n));

    // Maximum size of segment tree
    let max_size = 2 * Math.pow(2, x) - 1;

    let st = new Array(max_size).fill(0);

    // Fill the allocated memory st
    constructSTUtil(arr, 0, n - 1, st, 0);

    // Return the constructed segment tree
    return st;
}

// Main function
function main() {
    let arr = [1, 3, 2, 7, 9, 11];
    let n = arr.length;

    // Build segment tree from given array
    let st = constructST(arr, n);

    // Starting index of query range
    let qs = 1;

    // Ending index of query range
    let qe = 5;

    // Print minimum value in arr[qs..qe]
    console.log(`Minimum of values in range [${qs}, ${qe}] is = ${RMQ(st, n, qs, qe)}`);
}

main();

Output:

 Minimum of values in range [1, 5] is = 2

Time Complexity:

Tree Construction: Time Complexity for tree construction is O(n). There are total 2n-1 nodes, and value of every node is calculated only once in tree construction.
Query: Time complexity for each query is O(log n). To query a range minimum, we process at most two nodes at every level and number of levels is O(log n).

Auxiliary Space: O(n), since n extra space has been taken.

Further read
https://www.geeksforgeeks.org/range-minimum-query-for-static-array/

Querying maximum number of divisors that a number in a given range has

kartik

News

Improve

Article Tags :

Practice Tags :

Similar Reads

Segment Tree is a data structures 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 tre

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. Characteristics of Segment Tree:A segment tree is a binary tree with a leaf node for each el

Introduction to Segment Trees - Data Structure and Algorithm Tutorials

A Segment Tree is used to stores 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

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

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

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:

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

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

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.