长沙理工校赛I题题解-连续区间的最大公约数

题目来源https://www.nowcoder.com/acm/contest/96/I

解题前们需要先知道几个结论：

首先，gcd是有区单调性的: gcd(L,R)>=gcd(L,R+d)  ,因为每添加一个数，gcd只会变小或者不变。

其次，以L左端点的所有区间的【GCD的种类数】一般不超过15，最多不超过31个，因为gcd每次变小时会除掉当前gcd的一个或多个质因子，所以质因数的个数，决定这个gcd

最多能变小几次，而质因子最多的数就是2^31。

预处理：

在解决问题之前我们先做几个预处理，至于这些预处理有什么用，在解题时会说明。

• :为了快速查询区间gcd我们需要，用ST表先预处理一下数组，使得我们查询任意区间gcd的复杂下降至只需一个gcd(),即O(log(x)).   因为算gcd要一个log的复杂所以总复杂度，近似为 nlog(n)^2
• 对于每个L，二分计算区间内每种gcd的起始右端点，比如区间[8,4,4,2] 的区间，以下标1开始的区间gcd有 8,4,2这3种gcd，对应的右端点分别为[1,2,4]。因为计算gcd要一个log,二分一个log,而gcd种类数是期望好像是只比O(n)稍大(我瞎猜，不会证【1】)。所以总复杂度是接近nlog(n)^2

计算：设gcd[L,R]=g,要计算有多少个子区间为,其实就算算对于每个Li，对应Ri至少要多少才能使得gcd[Li,Ri]=g。 而答案为Σ(R+1-Ri)

如果你对每个LI都计算R的话，再快也是O(区间长度的) ，没前途。这有个更优美的求法，其实对于任意的Li和g,对应的Ri我们都在预处理的时候算好了，

但是按Li查询的复杂度太高了，那么为啥不考虑一下按g查询

所以在预处理阶段，我们按g分组，并在每个组内并按Li排序(其实按Ri还是按Li都是一样的，因为组内有类似尺取的区间单调性，这点自己手动模拟一下就知道了)，

并预处理Ri的前缀和。  接着查询L,R时，在g的组内二分（如果数据是随机的话，暴力也是行的）一下，L<=Li&&Ri<=R 的 区间，利用RI的前缀和一减就可以得分Σ(R+1-Ri)

将映射g到组id，用hash，可O(1).  平均组长log(n).,最坏组长O(n)  .   查询复杂度是 平均时log(log(n))  最快log(n)

加上预处理，最坏复杂度近似为 O(qlogn+nlog(n)^2)

 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 #include<math.h>
 #include<map>
 using namespace std;
 typedef long long ll;
 #define N 280000
 int dp[][];
 int len[];
 int a[];
 struct node
 {
     int l,r;
     long long sum;
 } p;
 vector<node>e[];
 map<int,int>mp;
 inline int cal(int l,int r)
 {
     if(l>r)
         return -;
     int k=len[r-l+];
     return __gcd(dp[l][k],dp[r-(<<k)+][k]);
 }
 inline  int findr(int l,int r,int g)
 {
     int k=len[r-l+],b=l,i;
     for(i=<<k; i; i>>=)
     {
         if(b+i<=r&&cal(l,b+i)>=g)
         {
             b+=i;
         }
     }
     return b;
 }
 inline  int findl(int l,int r,int g)
 {
     int k=len[r-l+],b=r,i;
     for(i=<<k; i; i>>=)
     {
         if(b-i>=l&&cal(l,b-i)<=g)
         {
             b-=i;
         }
     }
     return b;
 }
 int fl(int g,int x)
 {
     int l=,r,m,k;
     k=mp[g];
     r=e[k].size();
     while(l+<r)
     {
         m=(l+r)/;
         if(e[k][m].l<x)
         {
             l=m;
         }
         else
         {
             r=m;
         }
     }
     return l;
 }
 int fr(int g,int x)
 {
     int l=,r,m,k;
     k=mp[g];
     r=e[k].size();
     while(l+<r)
     {
         m=(l+r)/;
         if(e[k][m].r<=x)
         {
             l=m;
         }
         else
         {
             r=m;
         }
     }
     return l;
 }
 long long fun(int l,int r,int g)
 {
     long long ans=;
     long long a,b;
     a=fl(g,l);;
     b=fr(g,r);
     int k=mp[g];
     ans=(b-a)*(r+)-(e[k][b].sum-e[k][a].sum);
     return ans;
 }
 int main()
 {
     int n,m,k,l,r,i,j,g,q,t,cas=;
     len[]=;
     for(i=; i<=; i++)
     {
         len[i]=len[i/]+;
     }
     scanf("%d",&t);
     while(t--)
     {
         scanf("%d",&n);
         memset(dp,,sizeof(dp));
         mp.clear();
         for(i=; i<=n; i++)
         {
             scanf("%d",&a[i]);
             dp[i][]=a[i];
         }
         for(j=; j<=len[n]; j++)
         {
             for(i=; i<=n; i++)
             {
                 dp[i][j]=__gcd(dp[i][j-],dp[i+(<<j-)][j-]);
             }
         }
         int ll;
         for(i=; i<=n; i++)
         {
             g=a[i];
             ll=i;
             while()
             {
                 if(mp.count(g)==)
                 {
                     mp[g]=mp.size();
                     p.l=;
                     p.r=;
                     p.sum=;
                     e[mp[g]].push_back(p);
                 }
                 p.l=i;
                 ll=findr(i,n,g);
                 p.r=findl(i,n,g);
                 e[mp[g]].push_back(p);
                 if(ll>=n)
                     break;
                 g=__gcd(g,a[ll+]);
             }
         }
         for(i=; i<=mp.size(); i++)
         {
             for(j=; j<e[i].size(); j++)
             {
                 e[i][j].sum=e[i][j-].sum+e[i][j].r;
             }

         }
         scanf("%d",&q);
         printf("Case #%d:\n",cas++);
         while(q--)
         {
             scanf("%d%d",&l,&r);
             g=cal(l,r);
             printf("%d %lld\n",g,fun(l,r,g));
         }

         for(i=; i<mp.size(); i++)
         {
             e[i].clear();
         }
     }
     return ;
 }

AC代码