Bear and Prime NumbersSX（素数筛选）

C. Bear and Prime Numbers

time limit per test

2 seconds

memory limit per test

512 megabytes

input

standard input

output

standard output

Recently, the bear started studying data structures and faced the following problem.

You are given a sequence of integers x1, x2, ..., xn of length n and m queries, each of them is characterized by two integers li, ri. Let's introduce f(p) to represent the number of such indexes k, that xk is divisible by p. The answer to the query li, ri is the sum: , where S(li, ri) is a set of prime numbers from segment [li, ri] (both borders are included in the segment).

Help the bear cope with the problem.

Input

The first line contains integer n (1 ≤ n ≤ 106). The second line contains n integers x1, x2, ..., xn (2 ≤ xi ≤ 107). The numbers are not necessarily distinct.

The third line contains integer m (1 ≤ m ≤ 50000). Each of the following m lines contains a pair of space-separated integers, li and ri(2 ≤ li ≤ ri ≤ 2·109) — the numbers that characterize the current query.

Output

Print m integers — the answers to the queries on the order the queries appear in the input.

Sample test(s)

input

6
5 5 7 10 14 15
3
2 11
3 12
4 4

output

9
7
0

input

7
2 3 5 7 11 4 8
2
8 10
2 123

output

0
7

Note

Consider the first sample. Overall, the first sample has 3 queries.

1. The first query l = 2, r = 11 comes. You need to count f(2) + f(3) + f(5) + f(7) + f(11) = 2 + 1 + 4 + 2 + 0 = 9.
2. The second query comes l = 3, r = 12. You need to count f(3) + f(5) + f(7) + f(11) = 1 + 4 + 2 + 0 = 7.
3. The third query comes l = 4, r = 4. As this interval has no prime numbers, then the sum equals 0.

 

     题意：

     给出 n （1 <= n <= 10^6），代表有 n 个数，后给出这 n 个数（X1……Xn）(2 ≤ xi ≤ 10^7)。随后给出 que （1 <= que <= 50000 ），代表有 que 个问题，每个 que 都有一个 l 和 r（2 <= l <= r <= 2 X 10^9）。统计在 l 到 r 内的每一个素数 a 能整除 Xi 的个数之和。

 

     思路：

     素数筛选。

     1.注意数据范围，除数和被除数关系，一开始只注意到左右边界最大范围是 2 X 10^9 ，是用范围里面的数去除 Xi ，而 Xi 范围是 2  ≤  xi  ≤  10^7，若范围内的数大于 n ，则无论如何都不能整除的，所以暗含条 件只需要把数组开到10^7。一开始没有注意到这点，于是把问题想得复杂了；

     2.于是用 num 数组统计 n 个数的数量情况，用 vis 进行素数筛选，用 sum 统计每个数能整除 n 内多少个数的情况；

     3.最后注意求和的方法，用容斥定理相减求和更加省时。

 

     AC：

#include<stdio.h>
#define MAX 10000005
int num[MAX],vis[MAX],sum[MAX],n;

void primer()
{
    for(int i = 2;i < MAX;i++)
    {
        if(vis[i]) continue;
        for(int j = i;j < MAX;j += i)
        {
            sum[i] += num[j];
            vis[j] = 1;
        }
    }
}

int main()
{
    int que;
    scanf("%d",&n);
    while(n--)
    {
        int a;
        scanf("%d",&a);
        num[a]++;
    }
    primer();
    for(int i = 2;i < MAX;i++)
        sum[i] += sum[i-1];         //容斥定理求和
    scanf("%d",&que);
    while(que--)
    {
        __int64 l,r;
        scanf("%I64d%I64d",&l,&r);
        if(r >= MAX) r = MAX - 1;
        if(l >= MAX) l = MAX - 1;   //注意，l 和 r 最大也只能是 MAX - 1 
        printf("%d\n",sum[r] - sum[l - 1]);
    }
    return 0;
}