Different GCD Subarray Query HDU - 5869

http://acm.hdu.edu.cn/showproblem.php?pid=5869

查询区间能产生多少不同gcd 其实和查询区间多少不同数非常相似 都是从左往右扫且尽量将每个数出现的位置往右移（从右往左就左移） 类似的题还有hdu5726 5930

还是利用gcd缩小至少而二倍的性质 对每个位置找出以其为右端点的所有不同值的gcd区间 并把每个区间的左端点存下来 然后把所有查询离线处理并按右端点排序 把所有小于当前右端点的位置会产生的gcd区间的左端点都更新到线段树上 如果某gcd值之前已经出现过那就把之前的位置减一 当前加一 这也就是尽量右移

#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;

struct node0
{
    int id;
    int val;
};

struct node1
{
    int l;
    int r;
    int val;
};

struct node2
{
    int id;
    int l;
    int r;
};

vector <node0> pre[100010];
node1 tree[400010];
node2 order[100010];
int ary[100010],pos[1000010],ans[100010];
int n,q;

bool cmp(node2 n1,node2 n2)
{
    return n1.r<n2.r;
}

int getgcd(int a,int b)
{
    int t;
    while(b>0)
    {
        t=b;
        b=a%b;
        a=t;
    }
    return a;
}

void pushupI(int cur)
{
    tree[cur].val=getgcd(tree[2*cur].val,tree[2*cur+1].val);
}

void buildI(int l,int r,int cur)
{
    int m;
    tree[cur].l=l;
    tree[cur].r=r;
    tree[cur].val=0;
    if(l==r)
    {
        tree[cur].val=ary[l];
        return;
    }
    m=(l+r)/2;
    buildI(l,m,2*cur);
    buildI(m+1,r,2*cur+1);
    pushupI(cur);
}

int queryI(int pl,int pr,int gcd,int cur)
{
    int res;
    if(pl<=tree[cur].l&&tree[cur].r<=pr&&tree[cur].val%gcd==0) return 0;
    if(tree[cur].l==tree[cur].r) return tree[cur].l;
    res=0;
    if(pr>=tree[2*cur+1].l) res=queryI(pl,pr,gcd,2*cur+1);
    if(res==0&&pl<=tree[2*cur].r) res=queryI(pl,pr,gcd,2*cur);
    return res;
}

void init()
{
    node0 tmp;
    int i,p,gcd,res;
    /*
    p=tar,gcd=num[tar];
    while(p>=1)
    {
        res=queryI(0,1,p,gcd,1);
        tmp.gcd=gcd,tmp.len=p-res;
        prel.push_back(tmp);
        gcd=getgcd(gcd,num[res]);
        p=res;
    }
    */
    for(i=1;i<=n;i++)
    {
        p=i,gcd=ary[p];
        while(p>=1)
        {
            res=queryI(1,p,gcd,1);
            tmp.id=p,tmp.val=gcd;
            pre[i].push_back(tmp);
            gcd=getgcd(gcd,ary[res]);
            p=res;
        }
    }
}

void pushupII(int cur)
{
    tree[cur].val=tree[2*cur].val+tree[2*cur+1].val;
}

void buildII(int l,int r,int cur)
{
    int m;
    tree[cur].l=l;
    tree[cur].r=r;
    tree[cur].val=0;
    if(l==r) return;
    m=(l+r)/2;
    buildII(l,m,2*cur);
    buildII(m+1,r,2*cur+1);
}

void updateII(int tar,int val,int cur)
{
    if(tree[cur].l==tree[cur].r)
    {
        tree[cur].val+=val;
        return;
    }
    if(tar<=tree[2*cur].r) updateII(tar,val,2*cur);
    else updateII(tar,val,2*cur+1);
    pushupII(cur);
}

int queryII(int pl,int pr,int cur)
{
    int res;
    //printf("*%d %d %d %d %d*\n",pl,pr,tree[cur].l,tree[cur].r,tree[cur].val);
    if(pl<=tree[cur].l&&tree[cur].r<=pr) return tree[cur].val;
    res=0;
    if(pl<=tree[2*cur].r) res+=queryII(pl,pr,2*cur);
    if(pr>=tree[2*cur+1].l) res+=queryII(pl,pr,2*cur+1);
    return res;
}

int main()
{
    node0 tmp;
    int i,j,k;
    while(scanf("%d%d",&n,&q)!=EOF)
    {
        for(i=1;i<=n;i++) scanf("%d",&ary[i]);
        buildI(1,n,1);
        for(i=1;i<=n;i++) pre[i].clear();
        init();
        for(i=1;i<=q;i++)
        {
            order[i].id=i;
            scanf("%d%d",&order[i].l,&order[i].r);
        }
        buildII(1,n,1);
        sort(order+1,order+q+1,cmp);
        memset(pos,-1,sizeof(pos));
        j=1;
        for(i=1;i<=q;i++)
        {
            //printf("***%d***\n",i);
            while(j<=order[i].r)
            {
                //printf("*%d*\n",j);
                for(k=0;k<pre[j].size();k++)
                {
                    //printf("%d %d %d   ",pre[j][k].val,pre[j][k].id,pos[pre[j][k].val]);
                    if(pos[pre[j][k].val]!=-1) updateII(pos[pre[j][k].val],-1,1);
                    updateII(pre[j][k].id,1,1);
                    pos[pre[j][k].val]=pre[j][k].id;
                }
                //printf("\n");
                j++;
            }
            ans[order[i].id]=queryII(order[i].l,order[i].r,1);
        }
        for(i=1;i<=q;i++) printf("%d\n",ans[i]);
    }
    return 0;
}

/*
5 3
1 3 4 6 9
1 2
1 3
1 4
*/