## Saturday, November 12, 2016

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

http://www.geeksforgeeks.org/querying-maximum-number-divisors-number-given-range/
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.
Pre-requisites : Eratosthenes SieveSegment Tree
Below are steps to solve the problem.

1. Firstly, let’s see how many number of divisors does a number n = p1k1 * p2k2 * … * pnkn (where p1, p2, …, pnare 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).
2. 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.
3. 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.
`#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 i`
`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` `(``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 has`
`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[] array`
`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] = 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));`
`}`
http://www.geeksforgeeks.org/querying-maximum-number-divisors-number-given-range/