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

06 Apr, 2021
Given Q queries, of type: L R, for each query you must print the maximum number of divisors that a number x (L <= x <= R) has. Examples:  
L = 1 R = 10:
    1 has 1 divisor.
    2 has 2 divisors.
    3 has 2 divisors.
    4 has 3 divisors.
    5 has 2 divisors.
    6 has 4 divisors.
    7 has 2 divisors.
    8 has 4 divisors.
    9 has 3 divisors.
    10 has 4 divisors.

So the answer for above query is 4, as it is the maximum number of 
divisors a number has in [1, 10].
 
Pre-requisites : Eratosthenes Sieve, Segment TreeBelow are steps to solve the problem. 
Firstly, let’s see how many number of divisors does a number n = p1k1 * p2k2 * ... * pnkn (where p1, p2, ..., pn are prime numbers) has; the answer is (k1 + 1)*(k2 + 1)*...*(kn + 1). How? For each prime number in the prime factorization, we can have its ki + 1 possible powers in a divisor (0, 1, 2,..., ki).Now let’s see how can we find the prime factorization of a number, we firstly build an array, smallest_prime[], which stores the smallest prime divisor of i at ith index, we divide a number by its smallest prime divisor to obtain a new number (we also have the smallest prime divisor of this new number stored), we keep doing it until the smallest prime of the number changes, when the smallest prime factor of the new number is different from the previous number’s, we have ki for the ith prime number in the prime factorization of the given number.Finally, we obtain the number of divisors for all the numbers and store these in a segment tree that maintains the maximum numbers in the segments. We respond to each query by querying the segment tree.
Firstly, let’s see how many number of divisors does a number n = p1k1 * p2k2 * ... * pnkn (where p1, p2, ..., pn are prime numbers) has; the answer is (k1 + 1)*(k2 + 1)*...*(kn + 1). How? For each prime number in the prime factorization, we can have its ki + 1 possible powers in a divisor (0, 1, 2,..., ki).
Now let’s see how can we find the prime factorization of a number, we firstly build an array, smallest_prime[], which stores the smallest prime divisor of i at ith index, we divide a number by its smallest prime divisor to obtain a new number (we also have the smallest prime divisor of this new number stored), we keep doing it until the smallest prime of the number changes, when the smallest prime factor of the new number is different from the previous number’s, we have ki for the ith prime number in the prime factorization of the given number.
Finally, we obtain the number of divisors for all the numbers and store these in a segment tree that maintains the maximum numbers in the segments. We respond to each query by querying the segment tree.
 
C++
Java
Python 3
C#
Javascript
// A C++ implementation of the above idea to process// queries of finding a number with maximum divisors.#include <bits/stdc++.h>using namespace std; #define maxn 1000005#define INF 99999999 int smallest_prime[maxn];int divisors[maxn];int segmentTree[4 * maxn]; // Finds smallest prime factor of all numbers in// range[1, maxn) and stores them in smallest_prime[],// smallest_prime[i] should contain the smallest prime// that divides ivoid findSmallestPrimeFactors(){    // Initialize the smallest_prime factors of all    // to infinity    for (int i = 0 ; i < maxn ; i ++ )        smallest_prime[i] = INF;     // to be built like eratosthenes sieve    for (long long i = 2; i < maxn; i++)    {        if (smallest_prime[i] == INF)        {            // prime number will have its smallest_prime            // equal to itself            smallest_prime[i] = i;            for (long long j = i * i; j < maxn; j += i)                 // if 'i' is the first prime number reaching 'j'                if (smallest_prime[j] > i)                    smallest_prime[j] = i;        }    }} // number of divisors of n = (p1 ^ k1) * (p2 ^ k2) ... (pn ^ kn)// are equal to (k1+1) * (k2+1) ... (kn+1)// this function finds the number of divisors of all numbers// in range [1, maxn) and stores it in divisors[]// divisors[i] stores the number of divisors i hasvoid buildDivisorsArray(){    for (int i = 1; i < maxn; i++)    {        divisors[i] = 1;        int n = i, p = smallest_prime[i], k = 0;         // we can obtain the prime factorization of the number n        // n = (p1 ^ k1) * (p2 ^ k2) ... (pn ^ kn) using the        // smallest_prime[] array, we keep dividing n by its        // smallest_prime until it becomes 1, whilst we check        // if we have need to set k zero        while (n > 1)        {            n = n / p;            k ++;             if (smallest_prime[n] != p)            {                //use p^k, initialize k to 0                divisors[i] = divisors[i] * (k + 1);                k = 0;            }             p = smallest_prime[n];        }    }} // builds segment tree for divisors[] arrayvoid buildSegtmentTree(int node, int a, int b){    // leaf node    if (a == b)    {        segmentTree[node] = divisors[a];        return ;    }     //build left and right subtree    buildSegtmentTree(2 * node, a, (a + b) / 2);    buildSegtmentTree(2 * node + 1, ((a + b) / 2) + 1, b);     //combine the information from left    //and right subtree at current node    segmentTree[node] = max(segmentTree[2 * node],                            segmentTree[2 *node + 1]);} //returns the maximum number of divisors in [l, r]int query(int node, int a, int b, int l, int r){    // If current node's range is disjoint with query range    if (l > b || a > r)        return -1;     // If the current node stores information for the range    // that is completely inside the query range    if (a >= l && b <= r)        return segmentTree[node];     // Returns maximum number of divisors from left    // or right subtree    return max(query(2 * node, a, (a + b) / 2, l, r),               query(2 * node + 1, ((a + b) / 2) + 1, b,l,r));} // driver codeint main(){    // First find smallest prime divisors for all    // the numbers    findSmallestPrimeFactors();     // Then build the divisors[] array to store    // the number of divisors    buildDivisorsArray();     // Build segment tree for the divisors[] array    buildSegtmentTree(1, 1, maxn - 1);     cout << "Maximum divisors that a number has "         << " in [1, 100] are "         << query(1, 1, maxn - 1, 1, 100) << endl;      cout << "Maximum divisors that a number has"         << " in [10, 48] are "         << query(1, 1, maxn - 1, 10, 48) << endl;      cout << "Maximum divisors that a number has"         << " in [1, 10] are "         << query(1, 1, maxn - 1, 1, 10) << endl;     return 0;}
// Java implementation of the above idea to process// queries of finding a number with maximum divisors.import java.util.*; class GFG{static int maxn = 10005;static int INF = 999999; static int []smallest_prime = new int[maxn];static int []divisors = new int[maxn];static int []segmentTree = new int[4 * maxn]; // Finds smallest prime factor of all numbers// in range[1, maxn) and stores them in// smallest_prime[], smallest_prime[i] should// contain the smallest prime that divides istatic void findSmallestPrimeFactors(){    // Initialize the smallest_prime factors    // of all to infinity    for (int i = 0 ; i < maxn ; i ++ )        smallest_prime[i] = INF;     // to be built like eratosthenes sieve    for (int i = 2; i < maxn; i++)    {        if (smallest_prime[i] == INF)        {            // prime number will have its            // smallest_prime equal to itself            smallest_prime[i] = i;            for (int j = i * i; j < maxn; j += i)                 // if 'i' is the first                // prime number reaching 'j'                if (smallest_prime[j] > i)                    smallest_prime[j] = i;        }    }} // number of divisors of n = (p1 ^ k1) * (p2 ^ k2) ... (pn ^ kn)// are equal to (k1+1) * (k2+1) ... (kn+1)// this function finds the number of divisors of all numbers// in range [1, maxn) and stores it in divisors[]// divisors[i] stores the number of divisors i hasstatic void buildDivisorsArray(){    for (int i = 1; i < maxn; i++)    {        divisors[i] = 1;        int n = i, p = smallest_prime[i], k = 0;         // we can obtain the prime factorization of        // the number n, n = (p1 ^ k1) * (p2 ^ k2) ... (pn ^ kn)        // using the smallest_prime[] array, we keep dividing n        // by its smallest_prime until it becomes 1,        // whilst we check if we have need to set k zero        while (n > 1)        {            n = n / p;            k ++;             if (smallest_prime[n] != p)            {                // use p^k, initialize k to 0                divisors[i] = divisors[i] * (k + 1);                k = 0;            }            p = smallest_prime[n];        }    }} // builds segment tree for divisors[] arraystatic void buildSegtmentTree(int node, int a, int b){    // leaf node    if (a == b)    {        segmentTree[node] = divisors[a];        return ;    }     //build left and right subtree    buildSegtmentTree(2 * node, a, (a + b) / 2);    buildSegtmentTree(2 * node + 1, ((a + b) / 2) + 1, b);     //combine the information from left    //and right subtree at current node    segmentTree[node] = Math.max(segmentTree[2 * node],                                 segmentTree[2 *node + 1]);} // returns the maximum number of divisors in [l, r]static int query(int node, int a, int b, int l, int r){    // If current node's range is disjoint    // with query range    if (l > b || a > r)        return -1;     // If the current node stores information    // for the range that is completely inside    // the query range    if (a >= l && b <= r)        return segmentTree[node];     // Returns maximum number of divisors from left    // or right subtree    return Math.max(query(2 * node, a, (a + b) / 2, l, r),                    query(2 * node + 1,                         ((a + b) / 2) + 1, b, l, r));} // Driver Codepublic static void main(String[] args){         // First find smallest prime divisors    // for all the numbers    findSmallestPrimeFactors();     // Then build the divisors[] array to store    // the number of divisors    buildDivisorsArray();     // Build segment tree for the divisors[] array    buildSegtmentTree(1, 1, maxn - 1);     System.out.println("Maximum divisors that a number " +                       "has in [1, 100] are " +                        query(1, 1, maxn - 1, 1, 100));      System.out.println("Maximum divisors that a number " +                       "has in [10, 48] are " +                        query(1, 1, maxn - 1, 10, 48));      System.out.println("Maximum divisors that a number " +                       "has in [1, 10] are " +                        query(1, 1, maxn - 1, 1, 10));    }} // This code is contributed by PrinciRaj1992
# Python 3 implementation of the above# idea to process queries of finding a# number with maximum divisors.maxn = 1000005INF = 99999999 smallest_prime = [0] * maxndivisors = [0] * maxnsegmentTree = [0] * (4 * maxn) # Finds smallest prime factor of all# numbers in range[1, maxn) and stores# them in smallest_prime[], smallest_prime[i]# should contain the smallest prime that divides idef findSmallestPrimeFactors():     # Initialize the smallest_prime    # factors of all to infinity    for i in range(maxn ):        smallest_prime[i] = INF     # to be built like eratosthenes sieve    for i in range(2, maxn):        if (smallest_prime[i] == INF):                         # prime number will have its            # smallest_prime equal to itself            smallest_prime[i] = i            for j in range(i * i, maxn , i):                 # if 'i' is the first prime                # number reaching 'j'                if (smallest_prime[j] > i):                    smallest_prime[j] = i # number of divisors of n = (p1 ^ k1) *# (p2 ^ k2) ... (pn ^ kn) are equal to# (k1+1) * (k2+1) ... (kn+1). This function# finds the number of divisors of all numbers# in range [1, maxn) and stores it in divisors[]# divisors[i] stores the number of divisors i hasdef buildDivisorsArray():    for i in range(1, maxn):        divisors[i] = 1        n = i        p = smallest_prime[i]        k = 0         # we can obtain the prime factorization        # of the number n n = (p1 ^ k1) * (p2 ^ k2)        # ... (pn ^ kn) using the smallest_prime[]        # array, we keep dividing n by its        # smallest_prime until it becomes 1, whilst        # we check if we have need to set k zero        while (n > 1):            n = n // p            k += 1             if (smallest_prime[n] != p):                                 # use p^k, initialize k to 0                divisors[i] = divisors[i] * (k + 1)                k = 0             p = smallest_prime[n] # builds segment tree for divisors[] arraydef buildSegtmentTree( node, a, b):         # leaf node    if (a == b):        segmentTree[node] = divisors[a]        return     #build left and right subtree    buildSegtmentTree(2 * node, a, (a + b) // 2)    buildSegtmentTree(2 * node + 1,                     ((a + b) // 2) + 1, b)     #combine the information from left    #and right subtree at current node    segmentTree[node] = max(segmentTree[2 * node],                            segmentTree[2 * node + 1]) # returns the maximum number of# divisors in [l, r]def query(node, a, b, l, r):         # If current node's range is disjoint    # with query range    if (l > b or a > r):        return -1     # If the current node stores information    # for the range that is completely inside    # the query range    if (a >= l and b <= r):        return segmentTree[node]     # Returns maximum number of divisors    # from left or right subtree    return max(query(2 * node, a, (a + b) // 2, l, r),               query(2 * node + 1,                    ((a + b) // 2) + 1, b, l, r)) # Driver codeif __name__ == "__main__":         # First find smallest prime divisors    # for all the numbers    findSmallestPrimeFactors()     # Then build the divisors[] array to    # store the number of divisors    buildDivisorsArray()     # Build segment tree for the divisors[] array    buildSegtmentTree(1, 1, maxn - 1)    print("Maximum divisors that a number has ",                            " in [1, 100] are ",                  query(1, 1, maxn - 1, 1, 100))     print("Maximum divisors that a number has",                           " in [10, 48] are ",                 query(1, 1, maxn - 1, 10, 48))      print( "Maximum divisors that a number has",                             " in [1, 10] are ",                   query(1, 1, maxn - 1, 1, 10)) # This code is contributed by ita_c
// C# implementation of the above idea// to process queries of finding a number// with maximum divisors.using System;     class GFG{static int maxn = 10005;static int INF = 999999; static int []smallest_prime = new int[maxn];static int []divisors = new int[maxn];static int []segmentTree = new int[4 * maxn]; // Finds smallest prime factor of all numbers// in range[1, maxn) and stores them in// smallest_prime[], smallest_prime[i] should// contain the smallest prime that divides istatic void findSmallestPrimeFactors(){    // Initialize the smallest_prime    // factors of all to infinity    for (int i = 0 ; i < maxn ; i ++ )        smallest_prime[i] = INF;     // to be built like eratosthenes sieve    for (int i = 2; i < maxn; i++)    {        if (smallest_prime[i] == INF)        {            // prime number will have its            // smallest_prime equal to itself            smallest_prime[i] = i;            for (int j = i * i; j < maxn; j += i)                 // if 'i' is the first                // prime number reaching 'j'                if (smallest_prime[j] > i)                    smallest_prime[j] = i;        }    }} // number of divisors of// n = (p1 ^ k1) * (p2 ^ k2) ... (pn ^ kn)// are equal to (k1+1) * (k2+1) ... (kn+1)// this function finds the number of divisors// of all numbers in range [1, maxn) and stores// it in divisors[] divisors[i] stores the// number of divisors i hasstatic void buildDivisorsArray(){    for (int i = 1; i < maxn; i++)    {        divisors[i] = 1;        int n = i, p = smallest_prime[i], k = 0;         // we can obtain the prime factorization of        // the number n,        // n = (p1 ^ k1) * (p2 ^ k2) ... (pn ^ kn)        // using the smallest_prime[] array,        // we keep dividing n by its smallest_prime        // until it becomes 1, whilst we check if        // we have need to set k zero        while (n > 1)        {            n = n / p;            k ++;             if (smallest_prime[n] != p)            {                // use p^k, initialize k to 0                divisors[i] = divisors[i] * (k + 1);                k = 0;            }            p = smallest_prime[n];        }    }} // builds segment tree for divisors[] arraystatic void buildSegtmentTree(int node,                              int a, int b){    // leaf node    if (a == b)    {        segmentTree[node] = divisors[a];        return;    }     //build left and right subtree    buildSegtmentTree(2 * node, a, (a + b) / 2);    buildSegtmentTree(2 * node + 1,                    ((a + b) / 2) + 1, b);     //combine the information from left    //and right subtree at current node    segmentTree[node] = Math.Max(segmentTree[2 * node],                                 segmentTree[2 *node + 1]);} // returns the maximum number of divisors in [l, r]static int query(int node, int a, int b, int l, int r){    // If current node's range is disjoint    // with query range    if (l > b || a > r)        return -1;     // If the current node stores information    // for the range that is completely inside    // the query range    if (a >= l && b <= r)        return segmentTree[node];     // Returns maximum number of divisors from left    // or right subtree    return Math.Max(query(2 * node, a, (a + b) / 2, l, r),                    query(2 * node + 1,                        ((a + b) / 2) + 1, b, l, r));} // Driver Codepublic static void Main(String[] args){         // First find smallest prime divisors    // for all the numbers    findSmallestPrimeFactors();     // Then build the divisors[] array    // to store the number of divisors    buildDivisorsArray();     // Build segment tree for the divisors[] array    buildSegtmentTree(1, 1, maxn - 1);     Console.WriteLine("Maximum divisors that a number " +                                 "has in [1, 100] are " +                          query(1, 1, maxn - 1, 1, 100));     Console.WriteLine("Maximum divisors that a number " +                                 "has in [10, 48] are " +                          query(1, 1, maxn - 1, 10, 48));     Console.WriteLine("Maximum divisors that a number " +                                  "has in [1, 10] are " +                           query(1, 1, maxn - 1, 1, 10));    }} // This code is contributed by 29AjayKumar
<script> // JavaScript implementation of the above idea to process// queries of finding a number with maximum divisors.         let maxn = 10005;    let INF = 999999;    let smallest_prime = new Array(maxn);    for(let i=0;i<maxn;i++)    {        smallest_prime[i]=0;    }    let divisors = new Array(maxn);    for(let i=0;i<maxn;i++)    {        divisors[i]=0;    }    let segmentTree = new Array(4 * maxn);    for(let i=0;i<4*maxn;i++)    {        segmentTree[i]=0;    }         // Finds smallest prime factor of all numbers    // in range[1, maxn) and stores them in    // smallest_prime[], smallest_prime[i] should    // contain the smallest prime that divides i    function findSmallestPrimeFactors()    {        // Initialize the smallest_prime factors        // of all to infinity        for (let i = 0 ; i < maxn ; i ++ )            smallest_prime[i] = INF;               // to be built like eratosthenes sieve        for (let i = 2; i < maxn; i++)        {            if (smallest_prime[i] == INF)            {                // prime number will have its                // smallest_prime equal to itself                smallest_prime[i] = i;                for (let j = i * i; j < maxn; j += i)                {                         // if 'i' is the first                    // prime number reaching 'j'                    if (smallest_prime[j] > i)                        smallest_prime[j] = i;                }            }        }    }         // number of divisors of n = (p1 ^ k1) * (p2 ^ k2) ... (pn ^ kn)    // are equal to (k1+1) * (k2+1) ... (kn+1)    // this function finds the number of divisors of all numbers    // in range [1, maxn) and stores it in divisors[]    // divisors[i] stores the number of divisors i has    function buildDivisorsArray()    {        for (let i = 1; i < maxn; i++)        {            divisors[i] = 1;            let n = i;            let p = smallest_prime[i]            let k = 0;                   // we can obtain the prime factorization of            // the number n, n = (p1 ^ k1) * (p2 ^ k2) ... (pn ^ kn)            // using the smallest_prime[] array, we keep dividing n            // by its smallest_prime until it becomes 1,            // whilst we check if we have need to set k zero            while (n > 1)            {                n = Math.floor(n / p);                k++;                       if (smallest_prime[n] != p)                {                    // use p^k, initialize k to 0                    divisors[i] = divisors[i] * (k + 1);                    k = 0;                }                p = smallest_prime[n];            }        }    }         // builds segment tree for divisors[] array    function buildSegtmentTree(node,a,b)    {        // leaf node        if (a == b)        {            segmentTree[node] = divisors[a];            return ;        }               //build left and right subtree        buildSegtmentTree(2 * node, a, Math.floor((a + b) / 2));        buildSegtmentTree((2 * node) + 1, Math.floor((a + b) / 2) + 1, b);               //combine the information from left        //and right subtree at current node        segmentTree[node] = Math.max(segmentTree[2 * node],                                     segmentTree[(2 *node) + 1]);    }         // returns the maximum number of divisors in [l, r]    function query(node,a,b,l,r)    {        // If current node's range is disjoint        // with query range        if (l > b || a > r)            return -1;               // If the current node stores information        // for the range that is completely inside        // the query range        if (a >= l && b <= r)            return segmentTree[node];               // Returns maximum number of divisors from left        // or right subtree        return Math.max(query(2 * node, a,        Math.floor((a + b) / 2), l, r),                        query(2 * node + 1,                        Math.floor((a + b) / 2) + 1, b, l, r));    }    // Driver Code         // First find smallest prime divisors    // for all the numbers    findSmallestPrimeFactors();       // Then build the divisors[] array to store    // the number of divisors    buildDivisorsArray();       // Build segment tree for the divisors[] array    buildSegtmentTree(1, 1, maxn - 1);       document.write("Maximum divisors that a number " +    "has in [1, 100] are " + query(1, 1, maxn - 1, 1, 100)+"<br>");          document.write("Maximum divisors that a number " +                       "has in [10, 48] are " +                        query(1, 1, maxn - 1, 10, 48)+"<br>");          document.write("Maximum divisors that a number " +                       "has in [1, 10] are " +                        query(1, 1, maxn - 1, 1, 10)+"<br>");         //  This code is contributed by avanitrachhadiya2155     </script>
Output:  
Maximum divisors that a number has in [1, 100] are 12
Maximum divisors that a number has in [10, 48] are 10
Maximum divisors that a number has in [1, 10] are 4
Time Complexity:  
For sieve: O(maxn * log(log(maxn)) )
For calculating divisors of each number: O(k1 + k2 + ... + kn) < O(log(maxn))
For querying each range: O(log(maxn))
Total: O((maxn + Q) * log(maxn))
This article is contributed by Saumye Malhotra. 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. 
ukasp
princiraj1992
29AjayKumar
avanitrachhadiya2155
divisors
Segment-Tree
sieve
Mathematical
Mathematical
sieve
Segment-Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Merge two sorted arrays
Operators in C / C++
Prime Numbers
Minimum number of jumps to reach end
Find minimum number of coins that make a given value
The Knight's tour problem | Backtracking-1
Algorithm to solve Rubik's Cube
Program for Decimal to Binary Conversion
Modulo 10^9+7 (1000000007)
Modulo Operator (%) in C/C++ with Examples