luogu P4108 [HEOI2015]公约数数列——solution

-by luogu

---

---

不会啊....

然后%了一发题解，

关键是

考虑序列{$a_n$}的前缀gcd序列，

它是单调不升的，且最多只会改变$log_2N$次，因为每变一次至少除2

于是，当我们询问x时：

对每一段满足前缀gcd不变的部分；

可以用map之类的直接查询这个区间中前缀xor值等于$x\over gcd$的最小下标；

但我们还有单点修改，

考虑分块，——随便分个根号块就好

对每块

维护块从左端到右端元素的xor和，

维护块中左端到右端元素的gcd值，

对每个元素

维护从他所在块的左端点到他自己的xor和与gcd值；

这样修改只影响一块之内的所有元素的相关值和这一块的相关值；

对每块开个map

把左端到每个元素的xor值插到对应块的map中去；

当我们查询x时

枚举每块，

如果到这块之前的前缀gcd等于加入这块之后的前缀gcd（设为gcd），则意味着这块之内（从左端到右端）的所有点的前缀gcd都相等，（前缀gcd单调不升）

这样的话，我们设到这块之前的xor为$XOR_{0,L-1}$我们只需在这块的map中查是否有某个$XOR_{l~i}$值满足$gcd*(XOR_{0,L-1}xorXOR_{l,i})=x$即可，其效率为map的效率,$O(log_2\sqrt{N})$乘上块数即为$O(\sqrt{N}log_2\sqrt{N})$

反之，则暴力枚举这块中的每个元素即可，这种情况不超过log次，其总效率为$O(\sqrt{N}log_2{N})$

至于修改，则直接把对这块所维护的信息重新维护即可即可，块大小为$\sqrt{N}$乘上map的效率为$O(\sqrt{N}log_2\sqrt{N})$

于是其总复杂度为$O(q\sqrt{N}log_2N)$

代码：

 #include<map>
 #include<cmath>
 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<algorithm>
 #define LL long long
 using namespace std;
 map <int ,int >MP[];
 int a[];
 int b_size,b_num;
 int L[];
 int b_gcd[],b_xor[];
 int a_gcd[],a_xor[];
 int n,q;
 char s[];
 int GCD(int ,int );
 void modify();
 void query();
 int main()
 {
     int i,j,k;
     scanf("%d",&n);
     b_size=sqrt(n);
     for(i=;i<=n;i++)
         scanf("%d",&a[i]);
     for(b_num=i=;i<=n;b_num++,i+=b_size){
         L[b_num]=i;
         a_xor[i]=a_gcd[i]=a[i];
         MP[b_num].insert(pair<int ,int >(a_xor[i],i));
         for(j=i+;j<i+b_size&&j<=n;j++){
             a_xor[j]=a_xor[j-]^a[j];
             a_gcd[j]=GCD(a_gcd[j-],a[j]);
             MP[b_num].insert(pair<int ,int >(a_xor[j],j));
         }
         b_xor[b_num]=a_xor[j-],b_gcd[b_num]=a_gcd[j-];
     }
     scanf("%d",&q);
     for(i=;i<=q;i++){
         scanf("%s",s);
         if(s[]=='M')
             modify();
         else
             query();
     }
 }
 int GCD(int a,int b){
     if(!b)return a;
     return GCD(b,a%b);
 }
 void modify(){
     int id,x,i,j,k;
     scanf("%d%d",&id,&x),id++;
     for(i=j=;j<=n;j+=b_size,i++)
         if(j+b_size>id)
             break;
     MP[i].clear();
     a[id]=x;
     a_xor[(i-)*b_size+]=a_gcd[(i-)*b_size+]=a[(i-)*b_size+];
     MP[i].insert(pair<int ,int >(a_xor[(i-)*b_size+],(i-)*b_size+));
     for(j=(i-)*b_size+;j<=i*b_size&&j<=n;j++){
         a_xor[j]=a_xor[j-]^a[j];
         a_gcd[j]=GCD(a_gcd[j-],a[j]);
         MP[i].insert(pair<int ,int >(a_xor[j],j));
     }
     b_xor[i]=a_xor[j-],b_gcd[i]=a_gcd[j-];
 }
 void query(){
     LL x,xx;
     map <int ,int >::iterator iter;
     int i,j,k,lasxor=,nowgcd=,lasgcd=;
     scanf("%lld",&x);
     for(i=;i<=b_num;i++){
         nowgcd=GCD(b_gcd[i],lasgcd);
         if(nowgcd==lasgcd){
             if(x%lasgcd){
                 lasgcd=nowgcd,lasxor^=b_xor[i];
                 continue;
             }
             xx=x/lasgcd;
             xx^=lasxor;
             if(xx>0x7fffffff){
                 lasgcd=nowgcd,lasxor^=b_xor[i];
                 continue;
             }
             k=xx;
             if(MP[i].count(k)==){
                 iter=MP[i].find(k);
                 printf("%d\n",iter->second-);
                 return ;
             }
         }
         else{
             for(j=(i-)*b_size+;j<=n&&j<=i*b_size;j++)
                 if(1ll*(lasxor^a_xor[j])*GCD(lasgcd,a_gcd[j])==x){
                     printf("%d\n",j-);
                     return ;
                 }
         }
         lasgcd=nowgcd,lasxor^=b_xor[i];
     }
     printf("no\n");
 }

分块还差得远呢