Maximum number not coprime to V - c++

Question

Given a fixed array A of N integers where N<=100,000 and all elements of array are also less than or equal to 100,000. The numbers in A are not monotonically increasing or contiguous or otherwise conveniently organized.
Now I am given up to 100,000 queries of the form {V, L, R} where in each query I need to find the largest number A[i] with i in the range [L,R] that is not coprime with the given value V. (That is GCD(V,A[i]) is not equal to 1.)
If it's is not possible, then also tell that all numbers in the given range are coprime to V.
A basic approach would be to iterate from each A[i] between L and R and compute GCD with value V and hence find maximum. But is there any better way to do it if the number of queries can be up to 100,000 too. In that case, it's too inefficient to check for each number each time.
Example:
Let us have N=6 and the array be [1,2,3,4,5,4] and let V be 2 and range [L,R] is [2,5].
Then the answer is 4.
Explanation:
GCD(2,2)=2
GCD(2,3)=1
GCD(2,4)=2
GCD(2,5)=1
So maximum is 4 here.

Answer 1

Since you have a large array but only one V, it should be faster to start by factorizing V. After that your coprime test becomes simply finding the remainder modulo each unique factor of V.

Answer 2

Daniel Bernstein's "Factoring into coprimes in essentially linear time" (Journal of Algorithms 54:1, 1-30 (2005)) answers a similar question, and is used to identify bad (repeat factor) RSA moduli by Nadia Heninger's "New research: There's No Need to Panic Over Factorable Keys--Just Mind Your Ps and Qs"`. The problem there is to find common factors between a huge set of very large numbers, without going a pair at a time.

Answer 3

Lets say that
V = p_1*...*p_n
where p_i is a prime number (you can restrict it to distinct primes only). Now the answer is
result = -1
for p_i:
res = floor(R / p_i) * p_i
if res >= L and res > result:
result = res
So if you can factorize V fast then this will be quite efficient.
EDIT I didn't notice that the array does not have to contain all integers. In that case sieve it, i.e. given prime numbers p_1, ..., p_n create a "reversed" sieve (i.e. all multiples of primes in range [L, R]). Then you can just do an intersection of that sieve with your initial array.
EDIT2 To generate the set of all multiples you can use this algorithm:
primes = [p_1, ..., p_n]
multiples = []
for p in primes:
lower = floor(L / p)
upper = floor(R / p)
for i in [lower+1, upper]:
multiples.append(i*p)
The imporatant thing is that it follows from math that V is coprime with every number in range [L, R] which is not in multiples. Now you simply do:
solution = -1
for no in initial_array:
if no in multiples:
solution = max(solution, no)
Note that if you implement result as a set, then if no in result: check is O(1).
EXAMPLE Let's say that V = 6 = 2*3 and initial_array = [7,11,12,17,21] and L=10 and R=22. Let's start with multiples. Following the algorithm we obtain that
multiples = [10, 12, 14, 16, 18, 20, 22, 12, 15, 18, 21]
First 7 are multiples of 2 (in range [10, 22]) and last 4 are multiples of 3 (in range [10, 22]). Since we are dealing with sets (std::set?) then there will be no duplicates (12 and 18):
multiples = [10, 12, 14, 16, 18, 20, 22, 15, 21]
Now go through the initial_array and check what values are in multiples. We obtain that the biggest such number is 21. And indeed 21 is not coprime with 6.

Answer 4

Factor each of A's elements and store, for each possible prime factor, a sorted list of the numbers that contain this factor.
Given a number n contains O(log n) prime factors, this list will use O(N log N) memory.
Then, for each query (V, L, R), search for each prime factor in V, what is the maximum number that contain that factor within [L, R] (this can be done with a simple binary search).