【HDU5381_多校第八场B】【莫队算法】区间GCD之和_分段预处理

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<ctype.h>
#include<math.h>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<functional>
#include<string>
#include<algorithm>
#include<time.h>
#include<bitset>
void fre(){freopen("c://test//input.in","r",stdin);freopen("c://test//output.out","w",stdout);}
#define MS(x,y) memset(x,y,sizeof(x))
#define MC(x,y) memcpy(x,y,sizeof(x))
#define MP(x,y) make_pair(x,y)
#define ls o<<1
#define rs o<<1|1
typedef long long LL;
typedef unsigned int UI;
typedef int Int;
template <class T> inline void gmax(T &a,T b){if(b>a)a=b;}
template <class T> inline void gmin(T &a,T b){if(b<a)a=b;}
using namespace std;
const int N=1e4+10,M=0,L=0,Z=1e9+7,maxint=2147483647,ms31=522133279,ms63=1061109567,ms127=2139062143;
int casenum,casei;
int n,m;
struct A
{
    int l,r,id,o;
    bool operator < (const A& b)const
    {
        if(id!=b.id)return id<b.id;
        return r<b.r;
    }
}a[N];
vector<pair<int,int> >lft[N],rgt[N];
int v[N];
LL ans[N];
int gcd(int x,int y)
{
    return y==0?x:gcd(y,x%y);
}
void STinit()
{
    //lft[i]表示以i为左端点，向右扩展出的gcd差异区间段
    lft[n].clear();lft[n].push_back(MP(n,v[n]));
    for(int i=n-1;i>=1;i--)
    {
        lft[i].clear();
        int g=v[i];
        int l=i;
        for(auto& it:lft[i+1])
        {
            int tmp=gcd(g,it.second);
            if(tmp!=g)lft[i].push_back(MP(l,g));
            g=tmp;
            l=it.first;
        }
        lft[i].push_back(MP(l,g));
    }
    //rgt[i]表示以i为右端点，向左扩展出的gcd差异区间段
    rgt[1].clear();rgt[1].push_back(MP(1,v[1]));
    for(int i=2;i<=n;i++)
    {
        rgt[i].clear();
        int g=v[i];
        int r=i;
        for(auto& it:rgt[i-1])
        {
            int tmp=gcd(g,it.second);
            if(tmp!=g)rgt[i].push_back(MP(r,g));
            g=tmp;
            r=it.first;
        }
        rgt[i].push_back(MP(r,g));
    }
}
LL LFT(int l,int r)//左界扩充，计算左界为l，右界为[l,r]的gcd之和
{
    LL L=l-1;
    LL tmp=0;
    for(auto& it:lft[l])
    {
        LL d=min(it.first,r);
        tmp+=(d-L)*it.second;
        if(d==r)return tmp;
        L=d;
    }
}
LL RGT(int l,int r)//右界扩充，计算右界为r，左界为[l,r]的gcd之和
{
    int R=r+1;
    LL tmp=0;
    for(auto& it:rgt[r])
    {
        LL d=max(it.first,l);
        tmp+=(R-d)*it.second;
        if(d==l)return tmp;
        R=d;
    }
}
int main()
{
    scanf("%d",&casenum);
    for(casei=1;casei<=casenum;casei++)
    {
        scanf("%d",&n);
        int len=sqrt(n);
        for(int i=1;i<=n;i++)scanf("%d",&v[i]);
        STinit();
        scanf("%d",&m);
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d",&a[i].l,&a[i].r);
            a[i].id=a[i].l/len;
            a[i].o=i;
        }
        sort(a+1,a+m+1);
        int l=a[1].l;
        int r=a[1].l-1;
        LL ANS=0;
        for(int i=1;i<=m;i++)
        {
            while(l>a[i].l)ANS+=LFT(--l,r);//左界左移
            while(r<a[i].r)ANS+=RGT(l,++r);//右界右移
            while(l<a[i].l)ANS-=LFT(l++,r);//左界右移
            while(r>a[i].r)ANS-=RGT(l,r--);//右界左移
            ans[a[i].o]=ANS;
        }
        for(int i=1;i<=m;i++)printf("%lld\n",ans[i]);
    }
    return 0;
}
/*
【题意】
给你一个长度为n（1e4）的数列a[]，
并且有m（1e4）个询问，每个询问问你，f(l,r)是多少。
其中，f(l,r)定义为[l,r]范围内所有子区间的区间gcd之和。

【类型】
莫队算法

【分析】
这道题的询问虽然多，但是却可以离线处理。区间gcd有什么性质呢？
1，下降得很快。
2，满足叠加原理。

我们发现对于一个l，使得区间gcd不同的ri最多只有log(v[l])/log(2)级别。
于是，我们可以先预处理出，以i为左界或右界的gcd区间段，然后就可以对于左右区间的端点，动态±1来更新所有子区间的gcd之和

如何预处理呢？
第一种方法是类似于ST-RMQ的倍增预处理+二分，时间复杂度是logn(gcd个数)*logn(二分)*logn(求gcd)
第二种方法是一种在算法中很常用的递推性算法：
比如我们现在已经知道了，以i-1为右界的gcd区间段，现在我们要求出以i为右界的gcd区间段。
初始有gcd[i,i]=v[i]，因为gcd满足叠加性原则，所以我们要做的是把i-1的所有gcd区间段叠加上去。
如果gcd不变，继续循环下去；如果gcd改变，push之前的gcd段。这样时间复杂度降为logn(gcd个数)*logn(求gcd)

然后套一个莫队就可以AC啦

【时间复杂度&&优化】
O(nlognlogn)

http://www.cnblogs.com/CSU3901130321/p/4733701.html
这里还有线段树解法，以后有空可以学习下。

【trick】

【数据】
Sample Input
2
5
1 2 3 4 5
3
1 3
2 3
1 4
4
4 2 6 9
3
1 3
2 4
2 3

Sample Output
9
6
16
18
23
10

*/