NOI 2016 优秀的拆分 (后缀数组+差分)

题目大意：给你一个字符串，求所有子串的所有优秀拆分总和，优秀的拆分被定义为一个字符串可以被拆分成4个子串，形如$AABB$，其中$AA$相同，$BB$相同，$AB$也可以相同

作为一道国赛题，95分竟然就这么给我们了！只是一个$NOIP$难度的哈希套$DP$啊......

95分就是从后往前找，统计$AA$串，每次统计一下从这个位置开始的所有子串和紧随其后的等长串相同的个数$sum$

$hash(i,i+j-1)==hash(i+j,i+2*j-1) sum[i]++$

然后再统计$BB$串，就是加上在这两个串之后的位置的$sum$值，这样就统计出了合法拆分数

$dp[i]+=sum[i+2*j]$

95分就这样到手啦，竟然连自然溢出hash都不卡

 #include <cmath>

 #include <cstdio>

 #include <cstring>

 #include <algorithm>

 #define ll long long

 #define ull unsigned long long

 #define N 2050

 #define seed 233

 #define idx(x) (x-'a'+1)

 using namespace std;

 //re

 int T,len;

 char str[N];

 int dp[N],sum[N];

 ull hsh[N],sp[N];

 ull ghsh(int x,int y) {return hsh[y]-hsh[x-]*sp[y-x+];}

 void clr()

 {

     memset(dp,,sizeof(dp));

     memset(sp,,sizeof(sp));

     memset(sum,,sizeof(sum));

     memset(hsh,,sizeof(hsh));

 }

 int main()

 {

     scanf("%d",&T);

     while(T--)

     {

         clr();

         scanf("%s",str+);

         len=strlen(str+);

         sp[]=;

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

             hsh[i]=hsh[i-]*seed+idx(str[i]),

             sp[i]=sp[i-]*seed;

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

         {

             for(int j=;i+*j-<=len;j++)

             {

                 if(ghsh(i,i+j-)==ghsh(i+j,i+*j-)){

                     dp[i]++;

                     sum[i]+=dp[i+*j];

                 }

             }

         }

         int ans=;

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

             ans+=sum[i];

         printf("%d\n",ans);

     }

     return ;

 }

接下来才是本题的重点！$NOI$岂是你想$AK$就$AK$的！出题人可能是想针对某位巨佬

不看题解这个正解思路真是很难想到......

思路大概是这样的，其实我们每次只需要统计$AA$串的数量就行了，因为$AABB$串的数量等于，在$i-1$位结束的$AA$串的数量乘以在第$i$位开始的$AA$串的数量，用公式表示就是

$\sum_{i=2}^{n} ed[i-1]*st[i]$

接下来就是统计$st$和$ed$了，感觉正解的思路很神

先用后缀数组+$ST$表处理出任意两个位置，作为后缀串开头的$LCP$以及作为前缀串末尾的$LCS$，求$LCS$可以把串反着读再去套$SA$

每次选取一个$A$串的长度$len$，再在原串每隔$len$的位置设一个关键点

然后会发现一个神奇的性质，任意一个长度为$2*len$的串必然经过且仅经过2个关键点！

接下来统计经过所有长度为$2*len$所有$AA$串，比如选定两个关键点$a,b$，且$a+len=b$

如果把$a$的和b$相同的前缀和后缀拼在一起，且拼完之后长度>=len，说明存在至少一个$AA$串

可以把$AA$串想象成一个块，在两个关键点上移动，块的左端点不能大于$a$，块的右端点不能小于$b$，块不能移动到上一个或者下一个关键点的位置，块内必须是$AA$串，这样，块所有能移动的位置-块的长度$len$，就是经过$ab$两个关键点的所有$AA$串数

时间变成 $O(nlogn)$ ，$logn$是调和级数的近似值

细节比较多需要仔细思考

 #include <cmath>

 #include <cstdio>

 #include <cstring>

 #include <algorithm>

 #define ll long long

 #define N 30100

 #define seed 233

 #define idx(x) (x-'a'+1)

 using namespace std;

 //re

 int T,len;

 int lg[N];

 ll st[N],ed[N],S[N],E[N];

 struct suffix{

     char str[N];

     int sa[N],tr[N],rk[N],hs[N],h[N],f[N][],len;

     bool check(int k,int x,int y){

         if(x+k>len||y+k>len) return ;

         else return (rk[x]==rk[y]&&rk[x+k]==rk[y+k])?:;

     }

     void get_suffix()

     {

         int cnt=,i;len=strlen(str+);

         for(i=;i<=len;i++) hs[str[i]]++;

         for(i=;i<=;i++) if(hs[i]) tr[i]=++cnt;

         for(i=;i<=;i++) hs[i]+=hs[i-];

         for(i=;i<=len;i++) rk[i]=tr[str[i]],sa[hs[str[i]]--]=i;

         for(int k=;cnt<len;k<<=)

         {

             for(i=;i<=cnt;i++) hs[i]=;

             for(i=;i<=len;i++) hs[rk[i]]++;

             for(i=;i<=cnt;i++) hs[i]+=hs[i-];

             for(i=len;i>=;i--) if(sa[i]>k) tr[sa[i]-k]=hs[rk[sa[i]-k]]--;

             for(i=;i<=k;i++) tr[len-i+]=hs[rk[len-i+]]--;

             for(i=;i<=len;i++) sa[tr[i]]=i;

             for(i=,cnt=;i<=len;i++) tr[sa[i]]=check(k,sa[i],sa[i-])?cnt:++cnt;

             for(i=;i<=len;i++) rk[i]=tr[i];

         }

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

         {

             if(rk[i]==) continue;

             for(int j=max(,h[rk[i-]]-);;j++)

                 if(str[i+j-]==str[sa[rk[i]-]+j-]) h[rk[i]]=j;

                 else break;

         }

     }

     void get_ST()

     {

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

             f[i][]=h[i];

         for(int k=;(<<k)<=len;k++)

             for(int i=;i+(<<k)-<=len;i++)

                 f[i][k]=min(f[i][k-],f[i+(<<(k-))][k-]);

     }

     int query(int x,int y)

         {int L=y-x+;

         return min(f[x][lg[L]],f[y-(<<lg[L])+][lg[L]]);}

 }p,s;

 void clr()

 {

     memset(S,,sizeof(S)),memset(st,,sizeof(st));

     memset(E,,sizeof(E)),memset(ed,,sizeof(ed));

     memset(&p,,sizeof(p)),memset(&s,,sizeof(s));

 }

 int main()

 {

     scanf("%d",&T);

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

         lg[i]=lg[i>>]+;

     while(T--)

     {

         clr();

         scanf("%s",s.str+);

         int len=strlen(s.str+);

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

             p.str[i]=s.str[len-i+];

         s.get_suffix();

         s.get_ST();

         p.get_suffix();

         p.get_ST();

         int sx,sy,px,py,ss,sp,l,r;

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

         {

             for(int j=i+;j<=len;j+=i)

             {

                 sx=s.rk[j-i+],sy=s.rk[j+];

                 if(sx>sy) swap(sx,sy);

                 px=p.rk[len-(j-i)+],py=p.rk[len-j+];

                 if(px>py) swap(px,py);

                 ss=s.query(sx+,sy);

                 sp=p.query(px+,py);

                 if(ss+sp<i||sp==) continue;

                 l=max(j-i-i+,j-i-sp+);

                 r=min(j+i-,j+ss);

                 S[l]++,S[r-*i+]--;

                 E[l+*i-]++,E[r+]--;

             }

         }

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

             st[i]=st[i-]+S[i],ed[i]=ed[i-]+E[i];

         ll ans=;

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

             ans+=ed[i-]*st[i];

         printf("%lld\n",ans);

     }

     return ;

 }

巴特西

NOI 2016 优秀的拆分 (后缀数组+差分)

最新文章

热门文章