【CODEFORCES】 F. Ant colony

F. Ant colony

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Mole is hungry again. He found one ant colony, consisting of n ants, ordered in a row. Each ant i (1 ≤ i ≤ n) has a strength si.

In order to make his dinner more interesting, Mole organizes a version of «Hunger Games» for the ants. He chooses two numbers l andr (1 ≤ l ≤ r ≤ n) and each pair of ants with indices between l and r (inclusively) will fight. When two ants i and j fight, ant i gets one battle point only if si divides sj (also, ant j gets one battle point only if sj divides si).

After all fights have been finished, Mole makes the ranking. An ant i, with vi battle points obtained, is going to be freed only if vi = r - l, or in other words only if it took a point in every fight it participated. After that, Mole eats the rest of the ants. Note that there can be many ants freed or even none.

In order to choose the best sequence, Mole gives you t segments [li, ri] and asks for each of them how many ants is he going to eat if those ants fight.

Input

The first line contains one integer n (1 ≤ n ≤ 105), the size of the ant colony.

The second line contains n integers s1, s2, ..., sn (1 ≤ si ≤ 109), the strengths of the ants.

The third line contains one integer t (1 ≤ t ≤ 105), the number of test cases.

Each of the next t lines contains two integers li and ri (1 ≤ li ≤ ri ≤ n), describing one query.

Output

Print to the standard output t lines. The i-th line contains number of ants that Mole eats from the segment [li, ri].

Sample test(s)

input

5
1 3 2 4 2
4
1 5
2 5
3 5
4 5

output

4
4
1
1

Note

In the first test battle points for each ant are v = [4, 0, 2, 0, 2], so ant number 1 is freed. Mole eats the ants 2, 3, 4, 5.

In the second test case battle points are v = [0, 2, 0, 2], so no ant is freed and all of them are eaten by Mole.

In the third test case battle points are v = [2, 0, 2], so ants number 3 and 5 are freed. Mole eats only the ant 4.

In the fourth test case battle points are v = [0, 1], so ant number 5 is freed. Mole eats the ant 4.

题解：这一题其实不难，可以发现如果一个区间内的GCD不等于区间最小值得话，这个区间的所有数都会被吃掉。（因为每个数都不可能被其他的所有数除尽，除非它是这个区间的GCD），而如果这个区间的GCD等于这个区间的最小值的话，这个最小值就会被放掉，然后吃掉剩下的。于是我们就 可以用线段树来维护每个区间的GCD，最小值和最小值个数。查询的时候逐步递进就可以了。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>

using namespace std;

struct tree
{
    int mins,l,r,sum,k;
};

int s[100005],l,r,n,t,x,mins,sum;
struct tree d[300005];

int gcd(int a,int b)
{
    if (b==0) return a;
    else return gcd(b,a%b);
}

void buildtree(int k,int l,int r)
{
    d[k].l=l; d[k].r=r;
    if (l==r)
    {
        d[k].k=s[l];
        d[k].mins=s[l];
        d[k].sum=1;
    }
    else
    {
        buildtree(k*2,l,(l+r)/2);
        buildtree(k*2+1,(l+r)/2+1,r);
        d[k].k=gcd(d[k*2].k,d[k*2+1].k);
        if (d[k*2].mins==d[k*2+1].mins)
        {
            d[k].mins=d[k*2].mins;
            d[k].sum=d[k*2].sum+d[k*2+1].sum;
        }
        else if (d[k*2].mins<d[k*2+1].mins)
        {
            d[k].mins=d[k*2].mins;
            d[k].sum=d[k*2].sum;
        }
        else
        {
            d[k].mins=d[k*2+1].mins;
            d[k].sum=d[k*2+1].sum;
        }
    }
}

void countk(int k,int l,int r)
{
    int t=(d[k].l+d[k].r)/2;
    if (d[k].l==l && d[k].r==r)
    {
        x=gcd(d[k].k,x);
        if (mins==d[k].mins) sum+=d[k].sum;
        else if (mins>d[k].mins)
        {
            mins=d[k].mins;
            sum=d[k].sum;
        }
    }
    else if (r<=t) countk(k*2,l,r);
    else if (l>=t+1) countk(k*2+1,l,r);
    else
    {
        countk(k*2,l,t);
        countk(k*2+1,t+1,r);
    }
}

int main()
{
    scanf("%d",&n);
    for (int i=1;i<=n;i++) scanf("%d",&s[i]);
    scanf("%d",&t);
    buildtree(1,1,n);
    for (int i=1;i<=t;i++)
    {
        scanf("%d%d",&l,&r);
        x=s[l]; sum=0;
        mins=s[l];
        countk(1,l,r);
        if (x==mins) printf("%d\n",r-l+1-sum);
        else printf("%d\n",r-l+1);
    }
    return 0;
}