小乐乐学数学 哈理工第八届程序设计竞赛同步赛（高年级）H 树状数组 + 离线 + 互质区间

链接：https://ac.nowcoder.com/acm/contest/301/H
来源：牛客网

题目描述

小乐乐上了一节数学课，数学老师讲的很好，小乐乐听的也如痴如醉。
小乐乐听了老师的讲解，知道了什么是素数，现在他想做几个习题。
现在题目来了：
首先我们先定义孤独的数：在一个区间中的一个数字x,如果他与这个区间中的任何数都互质，那么他就是孤独的数。
我们给定一个序列，然后接下来会有多次询问，对于每次询问，给定两个整数l, r,我想知道对于(a[l], a[l + 1], ...., a[r])区间来说中有多少孤独的数。

输入描述:

多组样例输入。

对于每一组来说，给定两个整数n和m(1 <= n, m <= 100000),代表序列的长度和询问的次数,

接下来一行有一个长度为n的整数数组a，对于第i个整数a[i], (1 <= a[i] <= 100000)。

接下开m行，每行两个整数l, r(1 <= l <= r <= n),代表区间的左端点位置和有端点位置。

输出描述:

对于每个询问，输出一行，只有一个整数，代表询问的区间中，孤独的数的数量为多少。

 

示例1

输入

复制

5 2
1 2 3 4 5
1 5
3 4

输出

复制

3
2

说明

对于第一次询问来说，1, 3, 5是孤独的数。

对于第二次询问来说，3，4是孤独的数。

题解：我们先处理每个数对应的可行区间 (l0,r0)，如果一个个求的话肯定会T，那么我们就离线处理，对于每个数的可行区间按照 l 排序，对于查询的(l, r) ,按l排个序，处理一个数时，树状数组保存一下，在 l 上加，r+1上减，每处理一个可行的数，记录一下，求下一个区间的时候。如果有数不在该区间内去掉就可以了，详见代码

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 0x3f3f3f3f
#define lowbit(x) x&(-x)
const int N=100000+10;
const int mod=1000000007;
struct node
{
    int l,r,id;
    int ans;
    bool operator <(const node &x)const
    {
        return id>x.id;
    }
}p[N], b[N];
int n,m;
int prime[N],len,ok[N],pre[N],sum[N],a[N];
void init()
{
    for(int i=2;i<=100000;i++)
    {
        if(ok[i]==0) prime[len++]=i;
        for(int j=0;j<len&&(ll)i*prime[j]<=100000;j++)
        {
            ok[prime[j]*i]=1;
            if(i%prime[j]==0) break;
        }
    }
}
bool cmp(node x,node y)
{
    return x.l<y.l;
}
bool cmp1(node x,node y)
{
    return x.id<y.id;
}
void update(int x,int val)
{
    while(x<N)
    {
        sum[x]+=val;
        x+=lowbit(x);
    }
}
int query(int x)
{
    int res=0;
    while(x)
    {
        res+=sum[x];
        x-=lowbit(x);
    }
    return res;
}
int main()
{
    init();
    while(~scanf("%d%d",&n,&m))
    {
        memset(pre,0,sizeof(pre));
        memset(sum,0,sizeof(sum));
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            int mm=a[i];
            p[i].l=1;
            p[i].r=n;
            p[i].id=i;
            for(int j=0;j<len&&((ll)prime[j]*prime[j]<=mm);j++)
            {
                if(mm%prime[j]==0)
                {
                    p[i].l=max(p[i].l,pre[prime[j]]+1);
                    p[pre[prime[j]]].r=min(p[pre[prime[j]]].r,i-1);
                    pre[prime[j] ]=i;
                    while(mm%prime[j]==0) mm/=prime[j];
                }
            }
            if(mm!=1)
            {
                p[i].l=max(p[i].l,pre[mm]+1);
                p[pre[mm]].r=min(p[pre[mm]].r,i-1);
                pre[mm]=i;
            }
        }
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d",&b[i].l,&b[i].r);
            b[i].id=i;
        }
        sort(b+1,b+1+m,cmp);
        sort(p+1,p+1+n,cmp);
        priority_queue<node> q;
        node tmp;
        int j=1;
        for(int i=1;i<=m;i++)
        {
         //
            while(!q.empty()&&q.top().id<b[i].l)
            {
                tmp=q.top();q.pop();
                update(tmp.id,-1);
                update(tmp.r+1,1);
            }

            while(j<=n&&p[j].l<=b[i].l)   // 注意这两个while不能颠倒 因为刚处理的数也不一定在该区间内，数据水了，颠倒也能过
            {

                update(p[j].id,1);
                update(p[j].r+1,-1);
                tmp=p[j];
                q.push(tmp);
                j++;
            }
            b[i].ans=query(b[i].r);
        }
        sort(b+1,b+1+m,cmp1);
        for(int i=1;i<=m;i++)printf("%d\n",b[i].ans);
    }
    return 0;
}