连续区间的最大公约数------线段树+区间合并

原题链接

几天都在苦思冥想找个gcd区间个数到底应该是怎么求的，并且和线段树怎么联系到一起，最后还是参悟了大佬的代码才恍然大悟。
每个节点要保存的东西有一点多。
1：这个节点的范围长度。len
2：这个节点的最大公约数。x
3：这个节点范围区间里，各个区间的最大公约数不是x的个数。cnt
4：这个节点的范围内，从最左边数，到最右边，每一个范围的最大公约数，以及个数。vector<pair<int,int>> l。
5：这个节点的范围内，从最左边数，到最右边，每一个范围的最大公约数，以及个数。vector<pair<int,int>> r（后面节点的公约数一定是前面那个节点的公约数的公约数）。
这里着重说明一下这个l，r是怎么用的比如，10，2，8，4
从左边就是<10,1>，<2,3>
从右边就是<4,2>，<2,2>(前面是最大公约数，后面是个数)

题解：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>
#define ll long long
#define lson k<<1,l,mid
#define rson k<<1|1,mid+1,r
using namespace std;
const int MX=1e5+9;
int gcd(int a,int b){
    return b==0?a:gcd(b,a%b);
}

struct node{
    vector<pair<int,int> > l,r;
    ll cnt;
    int x,len;

    static void Merge(vector<pair<int,int> > &a,const vector<pair<int,int> > &b){   // 引用不可以少，不然会超时
        for( int i=0 ; i<b.size() ; i++ ){   // 前面一个可以是后面一个的倍数，但是后面的不可以是前面的倍数，这是为了保证gcd的不同，
            if( b[i].first%a.back().first==0 )
                a.back().second+=b[i].second;
            else
                a.push_back(make_pair(gcd(a.back().first,b[i].first),b[i].second));//保证后面节点的公约数一定是前面那个节点的公约数的公约数
        }
    }

    static ll solve(const vector<pair<int,int> > &a,const vector<pair<int,int> > &b,const int &x){   
        int sum=0,Size=b.size()-1;   // 这个函数就比较重要
        ll ans=0;
        for( int i=0 ; i<b.size() ; i++ )
            sum+=b[i].second;
        for( int i=0 ; i<a.size() ; i++ ){   //是所有的a公用一个SIZE，因为小区间会影响大区间，所以必须要小区间符合
            while( Size>=0 && gcd(a[i].first,b[Size].first)==x ){   
                sum-=b[Size].second;
                Size--;
            }
            ans+=1ll*a[i].second*sum;   // 凡是可以加的区间内，均不允许有gcd为x的出现，
        }
        return ans;
    }

    node operator +(const node &a)const{   
        node ans;    // node ans的各个项一定要初始化，因为cnt是ll，所以若不初始化，cnt可能不是0
        ans.x=gcd(x,a.x);  
        ans.cnt=0;  
        ans.cnt+=a.x==ans.x?a.cnt:1ll*(a.len+1)*a.len/2;  // 单从左右两子区间开始搜  
        ans.cnt+=x==ans.x?cnt:1ll*(len+1)*len/2;   
        ans.len=len+a.len;        
        Merge(ans.l = l , a.l );   // 该节点的l是左右两子区间的l合并   
        Merge(ans.r = a.r , r );   
        ans.cnt+=solve(r,a.l,ans.x);    // 从左区间的r，右区间的l开始搜  
        return ans;  
    }  
}t[MX<<2];  

void build(int k,int l,int r){
    if( l==r ){
        t[k].l.clear(),t[k].r.clear();
        scanf("%d",&t[k].x);
        t[k].len=1;
        t[k].cnt=0;
        t[k].l.push_back(make_pair(t[k].x,1));
        t[k].r.push_back(make_pair(t[k].x,1));
        return ;
    }
    int mid=(l+r)>>1;
    build(lson);
    build(rson);
    t[k]=t[k<<1]+t[k<<1|1];
}

node que(int k,int l,int r,int L,int R){   // 返回node，极为方便
    if( L<=l && r<=R )
        return t[k];
    int mid=(l+r)>>1;
    if( R<=mid )
        return que(lson,L,R);
    else if( mid<L )
        return que(rson,L,R);
    return que(lson,L,R)+que(rson,L,R);
}

int main(){
    freopen("input.txt","r",stdin);
    int T,n,m,cas=0;
    scanf("%d",&T);
    while( T-- ){
        printf("Case #%d:\n",++cas);
        scanf("%d",&n);
        build(1,1,n);
        scanf("%d",&m);
        while( m-- ){
            int l,r;
            scanf("%d %d",&l,&r);
            node ans=que(1,1,n,l,r);
            printf("%d %lld\n",ans.x,1ll*(ans.len+1)*ans.len/2-ans.cnt);
        }
    }
    return 0;
}