Sieve of Eratosthenes, Dynamic Programming
You are given an integer N. Count the number of prime permutations of size N. A permutation of integers between 1 and N is called a prime permutation of size N if for all i between 1 and N, inclusive, the i-th integer is the X-th smallest integer in the first i integers, where X is 1 or a prime number.
Let pperm* = the number of prime permutations of size i. Let's calculate pperm*. The last number (i.e., the i-th number) has to be the smallest number or the X-th smallest number for some prime number X. Therefore, we have (1 + primes*) choices for the last number, where primes* is the number of prime numbers not greater than i. The rest of the first i - 1 numbers can be permuted in any of the pperm[i-1] ways. In other words,
pperm = 1 pperm* = (1 + primes*) × pperm[i-1]
The answer is pperm[N]. We can precompute the values of pperm* for all i between 1 and 5,000,000, inclusive, and then answer each test case in O(1) time.
First, let's generate prime numbers between 1 and 5,000,000, inclusive. Let isPrime* = whether or not i is prime number. We can use Sieve of Eratosthenes algorithm. If you forgot, the pseudocode is as follows.
maxN = 5000000 isPrime = false for i = 2; i <= maxN; i++: isPrime* = true for i = 2; i × i <= maxN; i++: if isPrime*: for j = i × i; j <= maxN; j = j + i: isPrime[j] = false
After that, build primes array, where primes* is the number of prime numbers not greater than i. We can use a dynamic programming approach: primes* is exactly equal to primes[i-1], plus 1 if i is a prime number.
primes = 0 for i = 1; i <= maxN; i++: primes* = primes[i-1] + (isPrime* ? 1 : 0)
Now, let's solve the original problem. There is one important observation here. Actually, we do not care whether the numbers in the permutation are distinct integers between 1 and N, inclusive. We only care about the relative rank of each number (see the definition of prime permutation). Therefore, the N integers actually can be any N distinct integers.
We will use dynamic programming approach. Let the subproblem be pperm* = the number of prime permutations of i distinct numbers. The base case is pperm = 1, since a single number is always a valid prime permutation.
Let's calculate pperm* for i > 1. Consider the last position (i.e., the i-th position). From the definition of a prime permutation, the number in the last position has be the smallest number, or the X-th smallest number for some prime number X. Therefore, there are (1 + primes*) choices for the number in the last position. After we fix the last number, we have to place the remaining i - 1 numbers in the first i - 1 positions in such a way that the whole permutation is a prime permutation. To accomplish that, by definition, the numbers in the first i - 1 positions have to form a prime permutation as well.
The remaining i - 1 numbers are obviously i - 1 distinct integers. By the previous dynamic programming definition, the number of ways to permute i - 1 distinct numbers to form a prime permutation is pperm[i-1]. Therefore,
pperm* = (1 + primes*) × pperm[i-1]
The answer for a particular N is of course pperm[N].
We have to precompute all values of pperm* for all i between 1 and 5,000,000, inclusive. The time complexity of the precomputation is dominated by the complexity of Sieve of Eratosthenes, O(N log N log log N), where N = 5,000,000 in this problem. After that, we can answer each test case in O(1) lookup time.
Do not forget to perform all calculations modulo 1,000,000,007.
Can be found here
Can be found here