【倍增】7.11fusion

非常奇妙的倍增题

题目描述

知名科学家小A在2118年在计算机上实现了模拟聚变的过程。我们将她研究的过程简化。核子共有26种，可以用a到z共26个字母表示。核子聚变的过程可以用一个字符串描述。按照顺序从左到右的顺序，假如有两个相同核子相邻，两个核子就会相互吸引发生聚变生成一个序号+1的核子，特殊的，两个z核子相邻会湮灭没有新的核子生成。每当两个核子聚变时，就需要重新从左到右重复找到两个相邻的相同核子直到不存在为止。比如zyzzy->zyy->zz->小A为了做出足够有效的实验，每次会从一个字符串中选定一个子串操作。她想要知道每次实验这个子串中的核子能否最终全部湮灭。

输入格式

第一行一个只有小写字母的字符串。第二行一个数nn表示询问次数接下来nn行每行两个正整数li,rili,ri表示询问区间

输出格式

对每次询问输出一行Yes或No表示答案

样例输入

yzyyyzyzyyyz

1 6

7 12

1 12

6 11

1 1

1 3

4 9

3 8

样例输出

Yes

数据规模与约定

L表示字符串长度对于30%的数据满足L<=100

对于60%的数据满足L<=3000,n<=3000

另存在20%数据满足字符串中只存在y,z

对于100%的数据,L<=500000,n<=1000000

题目分析

摘要

第一眼看上去是个数据结构题……但是很明显这题的状态数非常多，并且区间信息也难以合并，所以所有基于序列长度的维护都是要挂的。

这题妙就是在于它用倍增维护基于结果的区间信息。（听上去很高端的样子实际上是不难理解的）

暴力做法

暴力的O(n^2)做法可以得60pts。具体实现可以用栈也可以用链表。

大概就是这个样子。

 #include<bits/stdc++.h>

 const int maxn = ;

 const long long numz = ;

 long long f[maxn];

 int pre[maxn],nxt[maxn],head,tail;

 char ch[maxn];

 int n,m,a[maxn],tot;

 int lowbit(int x){return x&-x;}

 void add(int x, long long c){for (; x<=n; x+=lowbit(x)) f[x]+=c;}

 long long query(int x)

 {

     long long ret = ;

     for (; x; x-=lowbit(x)) ret += f[x];

     return ret;

 }

 bool check(int l, int r)

 {

     tot = n, head = l, tail = r;

     for (int i=l; i<=r; i++)

         pre[i] = i-, nxt[i] = i+;

     pre[l] = -, nxt[r] = -;

     for (;;)

     {

         bool fl = ;

         if (head==-) return ;

         if (nxt[head]==-) return ;

         for (int now=head; nxt[now]!=-; now=nxt[now])

             if (a[now]==a[nxt[now]]){

                 fl = ;

                 if (a[now]==numz){

                     int ss = pre[now], tt = nxt[nxt[now]];

                     if (head==now){

                         head = tt;

                         if (tt==-) return ;

                         pre[tt] = -;

                     }

                     else{

                         nxt[ss] = tt;

                         if (tt!=-) pre[tt] = ss;

                     }

                 }else{

                     a[++tot] = a[now]*;

                     int ss = pre[now], tt = nxt[nxt[now]];

                     if (head==now){

                         head = tot;

                         if (tt==-) return ;

                         pre[tt] = tot, nxt[tot] = tt;

                     }

                     else{

                         nxt[ss] = tot, pre[tot] = ss, nxt[tot] = tt;

                         if (tt!=-) pre[tt] = tot;

                     }

                 }

                 break;

             }

         if (!fl) return ;

     }

 }

 int main()

 {

     freopen("fusion.in","r",stdin);

     freopen("fusion.out","w",stdout);

     scanf("%s",ch+);

     n = strlen(ch+);

     for (int i=; i<=n; i++)

         a[i] = <<(ch[i]-'a'), add(i, 1ll*a[i]);

     scanf("%d",&m);

     for (int i=; i<=m; i++)

     {

         int l,r;

         scanf("%d%d",&l,&r);

         if ((query(r)-query(l-))%numz==){

             if (check(l, r)) puts("Yes");

             else puts("No");

         }else puts("No");

     }

     return ;

 }

链表模拟

跳一跳？

用nxt[i]表示以i为左端点第一次消完的区间右端点。那么只要预处理出这个nxt[]就可以做到快速查询了————然而查询时也有可能被例如zzzzzzzzz...的数据卡飞，不过对于随机数据已经做得够好了。

先不管zzzzz...的情况，来考虑如何处理nxt[]。

用$t_{i,char}$表示i位置往后第一次遇到char字符的位置，这个是用来处理“聚变”的过程。那么显然这个可以用倍增维护。

处理出$t_{i,char}$之后，nxt[i]就等于$t_{i,z+1}$，这里我们把z聚变后也看做一个虚拟的字符。

再来一个倍增！

既然一维的$nxt[]$会被卡挂，那么同时处理消去好几次后的$nxt[]$（等同于跳了多次）呢？那么nxt[i][j]就表示以i开头消去j次后的位置。

重要的细节

这里有一组数据：xzzxyz

如果只有上面的操作，答案将会是No，因为计算出的结果里第一个x与第二个x是不能接触的。

所以要根据算出的$t_{i,z+1}$更新所有的$t_{i,j}$

 #include<bits/stdc++.h>

 #pragma GCC optimize(2)

 const int maxn = ;

 const int maxLog = ;

 const long long numz = ;

 int n,m,s[maxn];

 int t[maxn][],nxt[maxn][];

 char ch[maxn];

 bool check(int l, int r)

 {

     for (int i=maxLog; i>=; i--)

         if (nxt[l][i]==r+) return ;

         else if (nxt[l][i]<=r) l = nxt[l][i];

     return ;

 }

 void init()

 {

     register int i,j;

     for (i=; i<=n+; i++)

     {

         for (j=; j<=; j++) t[i][j] = n+;

         for (j=; j<=maxLog; j++) nxt[i][j] = n+;

     }

     for (i=n; i>=; i--)

     {

         t[i][s[i]] = i+;

         for (j=s[i]+; j<=; j++) t[i][j] = t[t[i][j-]][j-];

         nxt[i][] = t[i][];

         for (j=; j<=; j++)

             if (t[i][j]==n+)

                 t[i][j] = t[nxt[i][]][j];

         for (j=; j<=maxLog; j++) nxt[i][j] = nxt[nxt[i][j-]][j-];

     }

 }

 int main()

 {

     register int i,l,r;

     freopen("fusion.in","r",stdin);

     freopen("fusion.out","w",stdout);

     scanf("%s",ch+);

     n = strlen(ch+);

     for (i=; i<=n; i++) s[i] = ch[i]-'a';

     scanf("%d",&m);

     init();

     for (i=; i<=m; i++)

     {

         scanf("%d%d",&l,&r);

         if (check(l, r)) puts("Yes");

         else puts("No");

     }

     return ;

 }

END

巴特西