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.
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 Tree
Below 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.
# Python 3 implementation of the above
# idea to process queries of finding a
# number with maximum divisors.
maxn = 1000005
INF = 99999999
smallest_prime =  * maxn
divisors =  * maxn
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 i
# 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 has
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 array
def buildSegtmentTree( node, a, b):
# leaf node
if (a == b):
segmentTree[node] = divisors[a]
#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):
# If the current node stores information
# for the range that is completely inside
# the query range
if (a >= l and b <= r):
# 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 code
if __name__ == "__main__":
# First find smallest prime divisors
# for all the numbers
# Then build the divisors array to
# store the number of divisors
# 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
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
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))
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.