【字符串】字符串相关
啥都不会，重新学。先把模板摆上来，有时间写写例题。
1. KMP 算法
1.1. 模板
点击查看代码
//核心代码
int main(){
scanf("%s %s",s1+1,s2+1);
n=strlen(s1+1),m=strlen(s2+1);
//---------------------------------
for(int i=2,j=0;i<=m;++i){
while(j&&s2[j+1]!=s2[i])j=kmp[j];
if(s2[j+1]==s2[i])++j;
kmp[i]=j;
}
for(int i=1,j=0;i<=n;++i){
while(j&&s1[i]!=s2[j+1])j=kmp[j];
if(s1[i]==s2[j+1])++j;
if(j==m){printf("%d\n",i-m+1);j=kmp[j];}
}
//---------------------------------
for(int i=1;i<=m;++i)printf("%d ",kmp[i]);
return 0;
}
其中 \(kmp[i]\) 表示模式串 \(t\) 的前缀 \(t[1,i]\) 的最长相等真前缀和真后缀的长度，即有 \(t[1,kmp[i]] = t[i-kmp[i]+1,i]\)，\((kmp[i]<i)\)。其原理就是通过自己匹配自己求出失配位置。
1.2 例题
P3435 [POI2006] OKR-Periods of Words
见“border 理论”。
2. Z 函数（exKMP）
2.1. 模板
点击查看代码
//z 函数构造方法
z[1]=m;
for(int i=2,l=0,r=0;i<=m;++i){
if(i<=r)z[i]=min(z[i-l+1],r-i+1);
while(i+z[i]<=m&&s[i+z[i]]==s[1+z[i]])++z[i];
if(i+z[i]-1>r)l=i,r=i+z[i]-1;
}
其中 \(z[i]\) 表示字符串 \(s\) 与其后缀 \(s[i,n]\) 的 LCP 长度，即有 \(s[1,z[i]]=s[i,i+z[i]-1]\)。
其原理就是通过已匹配段 \([l,r]\) 推出 \(z[i]\)，其中 \(s[1,z[l]]=s[l,r]\)。
对于 \(i>r\)，直接上暴力即可。
对于 \(i\le r\)，显然有 \(s[i-l+1,z[l]]=s[i,r]\)，故令 \(z[i]=\min(z[i-l+1],r-i+1)\)（能保证在匹配段内正确）然后暴力匹配。
3. manacher 算法
3.1. 模板
点击查看代码
// 字符串通过插入分隔字符变成长为奇数
void get(){
s[1]='?';s[cnt=2]='#';register char c=getchar();
while(c<'a'||c>'z')c=getchar();
while(c>='a'&&c<='z')s[++cnt]=c,s[++cnt]='#',c=getchar();s[cnt+1]='!';
}
int main(){
get();
for(int i=2,l=0,r=-1;i<=cnt;++i){
d[i]=i>r?1:min(d[l+r-i],r-i+1);
while(s[i-d[i]]==s[i+d[i]])++d[i];
ans=max(d[i],ans);if(i+d[i]>r)r=i+d[i]-1,l=i-d[i]+1;
}
printf("%d",ans-1);
return 0;
}
其中 \(d[i]\) 表示以 \(i\) 为中心的回文半径长度，即有 \(s[i-d[i]+1,i+d[i]-1]\) 是回文串。
其构造思路跟上面差不多，考虑已匹配段 \([l,r]\)，满足 \(s[l,r]\) 是回文串。
对于 \(i>r\)，直接暴力。
对于 \(i\le r\)，根据回文对称性，有以 \(l+r-i\) 为中心的回文串与 \(i\) 对称，则我们令 \(d[i]=min(d[l+r-i],r-i+1)\)（长度超出匹配段的部分不能保证对称）然后暴力即可。
4. Suffix Array 后缀数组（SA）
4.1 模板
$O(n\log^2n)$ 版本（直接排序）
char s[N];
int w,len,sa[N],rk[N<<1],oldrk[N<<1];//注意开双倍空间
inline bool cmp(int a,int b){
return rk[a]==rk[b]?rk[a+w]<rk[b+w]:rk[a]<rk[b];
}
int main(){
scanf("%s",s+1);len=strlen(s+1);
//------------------------------------------------
for(int i=1;i<=len;++i)sa[i]=i,rk[i]=s[i];
for(w=1;w<len;w<<=1){
sort(sa+1,sa+len+1,cmp);
memcpy(oldrk,rk,sizeof rk);
for(int i=1,p=0;i<=len;++i){
if(oldrk[sa[i]]==oldrk[sa[i-1]]&&oldrk[sa[i]+w]==oldrk[sa[i-1]+w])rk[sa[i]]=p;
else rk[sa[i]]=++p;
}
}
//------------------------------------------------
for(int i=1;i<=len;++i)printf("%d ",sa[i]);
return 0;
}
$O(n\log n)$ 版本（基数排序优化）
const int N=1e6+10;
int n;
char s[N];
int buc[N],rk[N],ork[N],sa[N],id[N],pid[N];
//减少内存访问优化
bool cmp(int a,int b,int w){return ork[a]==ork[b]&&ork[a+w]==ork[b+w];}
int main(){
scanf("%s",s+1);n=strlen(s+1);
//------------------------------------------------
int m=1<<7,num=0;
for(int i=1;i<=n;++i)buc[rk[i]=s[i]]++;
for(int i=1;i<=m;++i)buc[i]+=buc[i-1];
for(int i=n;i;--i)sa[buc[rk[i]]--]=i;//由于要稳定排序故倒序枚举
for(int w=1;;w<<=1,m=num,num=0){
//对第二关键字排序优化
for(int i=n-w+1;i<=n;++i)id[++num]=i;//i+w>n的话一定排在前面（第二关键字为空）
for(int i=1;i<=n;++i)if(sa[i]>w)id[++num]=sa[i]-w;//这里枚举的sa[i]实际上是sa[i+w]即第二关键字
//对第一关键字排序
for(int i=1;i<=m;++i)buc[i]=0;
for(int i=1;i<=n;++i)buc[pid[i]=rk[id[i]]]++;//用pid代替，使访问连续
for(int i=1;i<=m;++i)buc[i]+=buc[i-1];
for(int i=n;i;--i)sa[buc[pid[i]]--]=id[i];//稳定排序，如果第一关键字相同则按照原来排好的第二关键字顺序
swap(rk,ork);num=0;
for(int i=1;i<=n;++i)rk[sa[i]]=cmp(sa[i-1],sa[i],w)?num:++num;//离散化
if(num==n)break;//排好就退出
}
//------------------------------------------------
for(int i=1;i<=n;++i)printf("%d ",sa[i]);
return 0;
}
后缀排序里主要用到两个数组：
-
\(sa_i\) 表示排名为 \(i\) 的后缀编号。
-
\(rk_i\) 表示编号为 \(i\) 的后缀排名。
于是就有 \(sa_{rk_i}=rk_{sa_i}=i\)（禁止套娃）。OI-wiki 里面有个很好的图：
后缀排序的过程运用了倍增的思想：
假设我们当前知道了每个长为 \(2^{w-1}\) 的子串的排名，记为 \(rk_{i,{w-1}}\)。
则我们可以通过 \(rk_{i,w-1}\) 和 \(rk_{i+2^{w-1},w-1}\) 双关键字排序，求出 \(rk_{i,w}\)（若 \(i+2^{w}-1>n\) 则规定 \(rk_{i,w}\) 为负无穷，它一定排在前面）。OI-wiki 又有个很好的图：
直接双关键字排序是 \(O(\log n)\times O(n\log n)=O(n\log^2n)\) 的。注意到 \(rk\) 的值域是 \(O(n)\) 的，可以用基数排序优化至 \(O(\log n)\times O(n)=O(n\log n)\)。
4.2 height 数组
可以说 SA 算法的目的就是求出 height 数组。下面给出几个定义和性质：
定义：
-
\(suf_i\)：后缀 \(s[i,n]\)
-
\(\operatorname{lcp}(i,j)\)：排名为 \(i\) 的后缀与排名为 \(j\) 的后缀的最长公共前缀，即 \(\operatorname{lcp}(suf_{sa_i},suf_{sa_j})\)。
-
\(ht_i\)：\(ht_i=\operatorname{lcp}(i-1,i)\)。
性质：
-
\(\operatorname{lcp}(i,j)=\operatorname{lcp}(j,i)\)
-
\(\operatorname{lcp}(i,i)=\operatorname{len}(suf_{sa_i})=n-sa_i+1\)
-
\(\operatorname{lcp}(i,j)=\min(\operatorname{lcp}(i,k),\operatorname{lcp}(k,j))\)（\(i\le k\le j\)）
这个需要证明一下（写的有点不太严谨感性理解）：
首先根据后缀排序的定义，\(i\) 和 \(j\) 一段相同长度的前缀 \(p_i,p_j\)，总有 \(p_i\le p_j\) （由字典序比较可知），\(k\) 同理。
设 \(\operatorname{lcp}(i,k)\) 为图中橙色一段前缀，\(\operatorname{lcp}(k,j)\) 为图中蓝色一段前缀。
则图中 \(j\) 橙色的一段前缀也一定与 \(i\) 的前缀相等，于是我们证明了 \(\operatorname{lcp}(i,j)\ge\min(\operatorname{lcp}(i,k),\operatorname{lcp}(k,j))\)。
设 \(\operatorname{lcp}(i,j)\) 为图中 \(i,j\) 橙色的一段前缀，对于 \(k\) 的一段相同长度的前缀，总有 \(p_i\le p_k\le p_j\)，又有 \(p_i=p_j=\operatorname{lcp}(i,j)\)，故 \(\operatorname{lcp}(i,j)\le\min(\operatorname{lcp}(i,k),\operatorname{lcp}(k,j))\)。
综上得证。
于是可知，\(\operatorname{lcp}(i,j)=\min\limits_{k=i+1}^j\operatorname{lcp}(k-1,k)=\min\limits_{k=i+1}^jht_k\)。
但是 \(height\) 数组怎么求呢？有一个关键的性质：\(ht_{rk_i}\ge ht_{rk_{i-1}}-1\)，再乱证一下：
假设 \(rk_{i-1}< rk_i\)，令 \(k=sa_{rk_{i-1}-1}\)。
当 \(suf_k\) 与 \(suf_{i-1}\) 的第一个字母不同，则 \(ht_{rk_{i-1}}=0\)，上述结论显然成立。
当 \(suf_k\) 与 \(suf_{i-1}\) 的第一个字母相同，则我们可以去掉它们的第一个字母，那么 \(suf_{k}\) 和 \(suf_{i-1}\) 就变成了 \(suf_{k+1}\) 和 \(suf_{i}\)。
显然 \(\operatorname{lcp}(k+1,i)=ht_{rk_{i-1}}-1\)。又有 \(\operatorname{lcp}(k+1,i)\le \operatorname{lcp}(i-1,i)\)，即 \(ht_{rk_i}\ge ht_{rk_{i-1}}-1\)。
于是我们可以写出下面构造 \(height\) 数组的代码。
点击查看代码
for(int i=1,k=0;i<=n;++i){
if(k)--k;
int j=sa[rk[i]-1];
while(s[i+k]==s[j+k])++k;
ht[rk[i]]=k;
}
注意到 \(k\) 指针最多移动 \(2n\) 次，故时间复杂度 \(O(n)\)。
4.3 例题：
P2178 [NOI2015] 品酒大会
“子串相等”可以转化为“后缀的前缀相等”，于是可以用 height 数组来做。
考虑排序后的后缀，当前要求 \(r\) 相似的子串。我们发现，对于 \(ht_i<r\)，我们可以把 \(i\) 和 \(i-1\) 划分为两个连通块，同一块内的元素都是可以组合的，因为它们的 \(\operatorname{lcp}\) 都不小于 \(r\)。再者我们发现，随着 \(r\) 增大，连通块的个数不断减小，当 \(r=n\) 时，每个元素自成一个连通块。于是我们考虑倒着求答案，每次把 \(ht_i=r\) 的两个联通块合并，这个可以用并查集实现。
注意权值有正有负，要维护块内最大最小次大次小。
点击查看代码
#define pb push_back
typedef long long ll;
typedef pair<ll,ll> pr;
const int N=3e5+10;
const ll inf=1e18;
int n;char s[N];
int sa[N],rk[N],ork[N],buc[N],id[N],pid[N],ht[N];
inline bool cmp(int a,int b,int w){return ork[a]==ork[b]&&ork[a+w]==ork[b+w];}
void build(){
int m=1<<7,p=0;
for(int i=1;i<=n;++i)buc[rk[i]=s[i]]++;
for(int i=1;i<=m;++i)buc[i]+=buc[i-1];
for(int i=n;i;--i)sa[buc[rk[i]]--]=i;
for(int w=1;;w<<=1,m=p,p=0){
for(int i=n-w+1;i<=n;++i)id[++p]=i;
for(int i=1;i<=n;++i)if(sa[i]>w)id[++p]=sa[i]-w;
for(int i=1;i<=m;++i)buc[i]=0;
for(int i=1;i<=n;++i)buc[pid[i]=rk[id[i]]]++;
for(int i=1;i<=m;++i)buc[i]+=buc[i-1];
for(int i=n;i;--i)sa[buc[pid[i]]--]=id[i];
swap(ork,rk);p=0;
for(int i=1;i<=n;++i)rk[sa[i]]=cmp(sa[i],sa[i-1],w)?p:++p;
if(p==n)break;
}
for(int i=1,k=0;i<=n;++i){
if(k)--k;
int j=sa[rk[i]-1];
while(s[i+k]==s[j+k])++k;
ht[rk[i]]=k;
}
}
vector<int> h[N];
ll a[N],fa[N],siz[N],mx1[N],mx2[N],mn1[N],mn2[N];
ll res=0,maxv=-inf;
pr ans[N];
int fnd(int x){return x!=fa[x]?fa[x]=fnd(fa[x]):x;}
inline ll get(int x){return 1ll*x*(x-1)/2;}
pr calc(int v){
for(int x:h[v]){
int l=fnd(x-1),r=fnd(x);
if(siz[l]>siz[r])swap(l,r);
res-=get(siz[l])+get(siz[r]);
siz[r]+=siz[l],fa[l]=r;
res+=get(siz[r]);
if(mx1[l]>=mx1[r]){
mx2[r]=max(mx1[r],mx2[l]);
mx1[r]=mx1[l];
}else if(mx1[l]>mx2[r])mx2[r]=mx1[l];
if(mn1[l]<=mn1[r]){
mn2[r]=min(mn1[r],mn2[l]);
mn1[r]=mn1[l];
}else if(mn1[l]<mn2[r])mn2[r]=mn1[l];
maxv=max(maxv,max(mx1[r]*mx2[r],mn1[r]*mn2[r]));
}
return maxv==-inf?make_pair(0ll,0ll):make_pair(res,maxv);
}
int main(){
scanf("%d%s",&n,s+1);
for(int i=1;i<=n;++i)scanf("%lld",&a[i]);
build();
for(int i=1;i<=n;++i){
fa[i]=i,siz[i]=1;
mx1[i]=mn1[i]=a[sa[i]];
mx2[i]=-inf,mn2[i]=inf;
}
for(int i=2;i<=n;++i)h[ht[i]].pb(i);
for(int i=n-1;~i;--i)ans[i]=calc(i);
for(int i=0;i<n;++i)printf("%lld %lld\n",ans[i].first,ans[i].second);
return 0;
}
P4070 [SDOI2016]生成魔咒
对每个前缀求本质不同子串个数。
先考虑对整个字符串的本质不同子串个数怎么求，有结论 \(\dfrac{n(n+1)}{2}-\sum\limits_{i=2}^{n}ht_i\)，证明一下：
设 \(i=1\) 排在第一位，则显然它的每个前缀在前面都没出现过，贡献为 \(len_{sa_{i}}\)。
对于 \(j=2\)，它在前面出现过的前缀个数即为 \(\operatorname{lcp}(i,j)=ht_{j}\)，即为图中橙色部分，贡献为 \(len_{sa_j}-ht_j\)。
对于 \(k=3\)，它在前面出现过的前缀个数为 \(ht_k\)，即为图中蓝线部分，之后的前缀在前面一定没出现过。考虑反证法：若之后的前缀在前面有出现过（设为图中绿色部分），则有 \(\operatorname{lcp}(i,k)\ge\) 绿色部分长度。但是根据性质 \(3\) 又有 \(\operatorname{lcp}(i,k)\le \operatorname{lcp}(j,k)\)，矛盾，故原命题正确。则贡献为 \(len_{sa_k}-ht_k\)。
以此类推，总贡献为 \(\dfrac{n(n+1)}{2}-\sum\limits_{i=2}^{n}ht_i\)。
再来考虑这道题怎么做，每在后面增加一个字符，则会影响所有后缀。我们不妨把整个串翻转过来，变为在前面加入字符，于是每次操作只会增加一个后缀而不影响其他的后缀，且贡献不变。加字符的操作变成减字符的操作更好做，每次合并 \(ht_{rk_i-1}\) 和 \(ht_{rk_i}\)，根据性质 \(3\) 可求得新的贡献。那么维护一个双链表就可以了。
点击查看代码
const int N=1e5+10;
typedef long long ll;
int n,tot,s[N],tmp[N];
int sa[N],rk[N],ork[N],buc[N],id[N],pid[N],ht[N];
int pre[N],nxt[N];
ll ans[N],sum=0;
inline bool cmp(int a,int b,int w){return ork[a]==ork[b]&&ork[a+w]==ork[b+w];}
void build(){
int m=tot,p=0;
for(int i=1;i<=n;++i)buc[rk[i]=s[i]]++;
for(int i=1;i<=m;++i)buc[i]+=buc[i-1];
for(int i=n;i;--i)sa[buc[rk[i]]--]=i;
for(int w=1;;w<<=1,m=p,p=0){
for(int i=n-w+1;i<=n;++i)id[++p]=i;
for(int i=1;i<=n;++i)if(sa[i]>w)id[++p]=sa[i]-w;
for(int i=1;i<=m;++i)buc[i]=0;
for(int i=1;i<=n;++i)buc[pid[i]=rk[id[i]]]++;
for(int i=1;i<=m;++i)buc[i]+=buc[i-1];
for(int i=n;i;--i)sa[buc[pid[i]]--]=id[i];
swap(ork,rk);p=0;
for(int i=1;i<=n;++i)rk[sa[i]]=cmp(sa[i],sa[i-1],w)?p:++p;
if(p==n)break;
}
for(int i=1,k=0;i<=n;++i){
if(k)--k;
int j=sa[rk[i]-1];
while(s[i+k]==s[j+k])++k;
ht[rk[i]]=k;
}
}
int main(){
read(n);
for(int i=n;i;--i)read(s[i]),tmp[i]=s[i];
sort(tmp+1,tmp+n+1);tot=unique(tmp+1,tmp+n+1)-tmp-1;
for(int i=1;i<=n;++i)s[i]=lower_bound(tmp+1,tmp+tot+1,s[i])-tmp;
build();
for(int i=1;i<=n;++i){
sum+=n-sa[i]+1-ht[i];
pre[i]=i-1,nxt[i]=i+1;
}nxt[0]=1,pre[n+1]=n;ans[n]=sum;
for(int i=1;i<n;++i){
int k=rk[i],j=nxt[k];
sum-=n-i+1-ht[k];sum+=ht[j];
ht[j]=min(ht[k],ht[j]);
pre[j]=pre[k],nxt[pre[k]]=j;
sum-=ht[j];
ans[n-i]=sum;
}
for(int i=1;i<=n;++i)printf("%lld\n",ans[i]);
return 0;
}
CF822E Liar
显然可以贪心，尽量让极长的一段来匹配。注意到 \(x\) 较小，可以 dp。
设 \(f_{i,j}\) 表示从 \(s[1,j]\) 中选取不超过 \(i\) 个子串，最多能匹配到 \(t\) 的第几位。
若当前不选，则转移到 \(f_{i,j+1}\)；若当前选择，则要选择极长的一段，即 \(s\) 和 \(t\) 那一段后缀的 \(\operatorname{lcp}\)，这个可以通过把 \(s,t\) 合并成一个字符串，然后用 st 表维护区间 \(\min\) 即可。设 \(\operatorname{lcp}\) 为 \(L\)，则转移到 \(f_{i,j+L}\)。
点击查看代码
const int N=2e5+10;
int n,lens,lent,tot=0,x;
char s[N];
int sa[N],rk[N],ork[N],buc[N],id[N],pid[N],ht[N];
int lg[N],st[N][18],f[31][N];
inline bool cmp(int a,int b,int w){return ork[a]==ork[b]&&ork[a+w]==ork[b+w];}
void build(){
int m=1<<7,p=0;n=tot;
for(int i=1;i<=n;++i)buc[rk[i]=s[i]]++;
for(int i=1;i<=m;++i)buc[i]+=buc[i-1];
for(int i=n;i;--i)sa[buc[rk[i]]--]=i;
for(int w=1;;w<<=1,m=p,p=0){
for(int i=n-w+1;i<=n;++i)id[++p]=i;
for(int i=1;i<=n;++i)if(sa[i]>w)id[++p]=sa[i]-w;
for(int i=1;i<=m;++i)buc[i]=0;
for(int i=1;i<=n;++i)buc[pid[i]=rk[id[i]]]++;
for(int i=1;i<=m;++i)buc[i]+=buc[i-1];
for(int i=n;i;--i)sa[buc[pid[i]]--]=id[i];
swap(ork,rk),p=0;
for(int i=1;i<=n;++i)rk[sa[i]]=cmp(sa[i],sa[i-1],w)?p:++p;
if(p==n)break;
}
for(int i=1,k=0;i<=n;++i){
if(k)--k;
int j=sa[rk[i]-1];
while(s[i+k]==s[j+k])++k;
ht[rk[i]]=k;
}
for(int i=1;i<=n;++i)st[i][0]=ht[i];
for(int i=2;i<=n;++i)lg[i]=lg[i>>1]+1;
for(int j=1;j<=lg[n];++j){
for(int i=1;i+(1<<j)-1<=n;++i){
st[i][j]=min(st[i][j-1],st[i+(1<<(j-1))][j-1]);
}
}
}
int lcp(int i,int j){
if(i>lens||j>lent)return 0;
i=rk[i],j=rk[j+lens+1];
if(i>j)swap(i,j);++i;
int p=lg[j-i+1];
return min(st[i][p],st[j-(1<<p)+1][p]);
}
int main(){
scanf("%d",&lens);
for(int i=1;i<=lens;++i)scanf(" %c",&s[++tot]);s[++tot]='#';
scanf("%d",&lent);
for(int i=1;i<=lent;++i)scanf(" %c",&s[++tot]);
build();scanf("%d",&x);
for(int i=1;i<=x;++i){
for(int j=0;j<lens;++j){
int L=lcp(j+1,f[i-1][j]+1);
f[i][j+1]=max(f[i][j+1],f[i][j]);
f[i][j+L]=max(f[i][j+L],f[i-1][j]+L);
}
}
if(f[x][lens]==lent)printf("YES\n");
else printf("NO\n");
return 0;
}
P4248 [AHOI2013]差异
原式 = \(\dfrac{n(n-1)(n+1)}{2}-2\times\sum \operatorname{lcp}(T_i,T_j)\)。左半部分可以先不管他，考虑怎么求右半部分，他显然可以化为：
这事实上是个很典的做法：考虑枚举 \(ht_i\) 作为最小值，求出它向左和向右最多能扩展到哪里，计算一下经过它的贡献即可。这个过程可以用单调栈维护。
点击查看代码
const int N=5e5+10;
#define int long long
int n;char s[N];
int sa[N],rk[N],ork[N],buc[N],id[N],pid[N],ht[N];
inline bool cmp(int a,int b,int w){return ork[a]==ork[b]&&ork[a+w]==ork[b+w];}
void build(){
int m=1<<7,p=0;
for(int i=1;i<=n;++i)buc[rk[i]=s[i]]++;
for(int i=1;i<=m;++i)buc[i]+=buc[i-1];
for(int i=n;i;--i)sa[buc[rk[i]]--]=i;
for(int w=1;;w<<=1,m=p,p=0){
for(int i=n-w+1;i<=n;++i)id[++p]=i;
for(int i=1;i<=n;++i)if(sa[i]>w)id[++p]=sa[i]-w;
for(int i=1;i<=m;++i)buc[i]=0;
for(int i=1;i<=n;++i)buc[pid[i]=rk[id[i]]]++;
for(int i=1;i<=m;++i)buc[i]+=buc[i-1];
for(int i=n;i;--i)sa[buc[pid[i]]--]=id[i];
swap(ork,rk);p=0;
for(int i=1;i<=n;++i)rk[sa[i]]=cmp(sa[i],sa[i-1],w)?p:++p;
if(p==n)break;
}
for(int i=1,k=0;i<=n;++i){
if(k)--k;
int j=sa[rk[i]-1];
while(s[i+k]==s[j+k])++k;
ht[rk[i]]=k;
}
}
int stk[N],top=0;
int l[N],r[N];
signed main(){
scanf("%s",s+1);n=strlen(s+1);
build();
int ans=1ll*n*(n-1)*(n+1)/2;
for(int i=1;i<=n;++i){
while(top&&ht[stk[top]]>ht[i])r[stk[top--]]=i;
l[i]=stk[top],stk[++top]=i;
}
while(top)r[stk[top--]]=n+1;
for(int i=2;i<=n;++i)ans-=2ll*(i-l[i])*(r[i]-i)*ht[i];
printf("%lld\n",ans);
return 0;
}
P3975 [TJOI2015]弦论
几道例题里唯一一道自己口胡出来对的题（
对于 \(t=0\) 的询问很 naive，排名为 \(i\) 的串与前面的本质不同子串个数就是 \(len_i-ht_i\)，枚举一下就行了。
对于 \(t=1\) 的询问有点复杂，考虑一个串的排名是啥：
因为不用考虑相同子串，故排名在 \(i\) 前的后缀构成的子串数量就是 \(\sum\limits_{rk_j<rk_i}len_j\)。但是还要考虑排名在它后面的后缀，它们构成的子串字典序比 \(i\) 小的个数就是它和 \(i\) 的 \(\operatorname{lcp}\)。故 \(i\) 的排名就是：
这是显然可以二分的，我们要找的目标后缀就是排名最大且小于 \(k\) 的那个后缀。现在的问题变成要输出的长度为多少，这个简单。设当前枚举的长度为 \(l\)，考虑排名在它后面的与它存在长度为 \(l\) 的公共前缀的后缀个数（即 \(\operatorname{lcp}\ge l\)，记得还要加上自己本身），这也是可二分的，如果加上这个个数后排名大于 \(k\) 则退出即可。
总共复杂度是 \(O(n\log n)\) 的，比 SAM 做法稍劣。
点击查看代码
const int N=5e5+10;
#define int long long
int n,t,k;char s[N];
int sa[N],rk[N],ork[N],buc[N],id[N],pid[N],ht[N];
int st[20][N],lg[N];
inline bool cmp(int a,int b,int w){return ork[a]==ork[b]&&ork[a+w]==ork[b+w];}
void build(){
int m=1<<7,p=0;
for(int i=1;i<=n;++i)buc[rk[i]=s[i]]++;
for(int i=1;i<=m;++i)buc[i]+=buc[i-1];
for(int i=n;i;--i)sa[buc[rk[i]]--]=i;
for(int w=1;;w<<=1,m=p,p=0){
for(int i=n-w+1;i<=n;++i)id[++p]=i;
for(int i=1;i<=n;++i)if(sa[i]>w)id[++p]=sa[i]-w;
for(int i=1;i<=m;++i)buc[i]=0;
for(int i=1;i<=n;++i)buc[pid[i]=rk[id[i]]]++;
for(int i=1;i<=m;++i)buc[i]+=buc[i-1];
for(int i=n;i;--i)sa[buc[pid[i]]--]=id[i];
swap(ork,rk);p=0;
for(int i=1;i<=n;++i)rk[sa[i]]=cmp(sa[i],sa[i-1],w)?p:++p;
if(p==n)break;
}
for(int i=1,k=0;i<=n;++i){
if(k)--k;
int j=sa[rk[i]-1];
while(s[i+k]==s[j+k])++k;
ht[rk[i]]=k;
}
lg[0]=-1;
for(int i=1;i<=n;++i)st[0][i]=ht[i],lg[i]=lg[i>>1]+1;
for(int i=1;i<=lg[n];++i){
for(int j=1;j+(1<<i)-1<=n;++j){
st[i][j]=min(st[i-1][j],st[i-1][j+(1<<(i-1))]);
}
}
}
int query(int l,int r){
int p=lg[r-l+1];
return min(st[p][l],st[p][r-(1<<p)+1]);
}
bool check(int mid){
int sum=0;
for(int i=1;i<mid;++i)sum+=n-sa[i]+1;
for(int i=mid+1;i<=n;++i)sum+=query(mid+1,i);
return sum+1>=k;
}
int fnd(int p,int l,int r,int w){
int mid,res=p;
while(l<=r){
mid=(l+r)>>1;
if(query(p+1,mid)>=w)res=mid,l=mid+1;
else r=mid-1;
}return res-p;
}
signed main(){
scanf("%s%lld%lld",s+1,&t,&k),n=strlen(s+1);
build();
int tot=0;
if(!t){
for(int i=1;i<=n;++i){
int len=n-sa[i]+1-ht[i];
if(tot+len>=k){
int pos=sa[i];k-=tot-ht[i];
while(k--)printf("%c",s[pos++]);
return 0;
}tot+=len;
}printf("-1\n");
}else {
if(k>n*(n+1)/2)return printf("-1\n"),0;
int l=1,r=n,mid;
while(l<r){
int mid=(l+r)>>1;
if(check(mid))r=mid;
else l=mid+1;
}--r;
int len=n-sa[r]+1,tot=0;
for(int i=1;i<r;++i)tot+=n-sa[i]+1;
for(int i=1;i<=len;++i){
int cnt=fnd(r,r+1,n,i);
printf("%c",s[sa[r]+i-1]);tot+=cnt+1;
if(tot>=k)break;
}
}
return 0;
}
5. border 理论
5.1 相关定理
剽窃自/证明见：cmd 传送门
记 \(\rm Bd = border\)。
\(\bullet\color{blue}{\text{ 定理(1):}}\) \(\rm Bd(S)=mxBd(S)+Bd(mxBd(S))\)。
即，\(S\) 的所有 \(\rm Bd\) 等于最大 \(\rm Bd\) 加上最大 \(\rm Bd\) 的所有 \(\rm Bd\)。kmp 里的 fail 数组求的就是最大 \(\rm Bd\)。
\(\bullet\color{blue}{\text{ 定理(2):}}\) 若 \(p,q\) 为 \(S\) 的周期，且 \(p+q\leq n\) ，则 \(\gcd(p,q)\) 也是 \(S\) 的周期。
\(\bullet\color{blue}{\text{ 定理(3):}}\) 若 \(S\) 是 \(T\) 的前缀，且 \(T\) 有周期 \(a\) ， \(S\) 有整周期 \(b\)，满足 \(b|a\)，\(\ |S|\geq a\)，则 \(T\) 也有周期 \(b\)。
\(\bullet\color{blue}{\text{ 定理(4):}}\) 若 \(S\) 如下图匹配，则表示 $S_1∪S_2 $有长度为 \(d\) 的周期，也即有长度为 \(|S|-d\) 的 \(\rm Bd\)。
\(\bullet\color{blue}{\text{ 定理(5):}}\) 若 \(2|S|\geq|T|\)，则 \(S\) 在 \(T\) 中的匹配位置必为等差序列。
\(\bullet\color{blue}{\text{ 定理(6):}}\) \(S\) 的长度大于 \(\dfrac{n}{2}\) 的 \(\rm Bd\) 长度构成一个等差序列。
\(\bullet\color{blue}{\text{ 定理(7):}}\) 一个串 \(S\) 的所有 \(\rm Bd\) 按长度排序后,可以被划分成 \(O(\log n)\) 个等差序列。
5.2 例题
P3435 [POI2006] OKR-Periods of Words
对于满足条件的 \(Q\)，\(Q\) 与 \(a\) 相差的部分就是 \(a\) 的 \(\rm Bd\)，我们要求最大周期长度就是求最小非空 \(\rm Bd\)。
考虑对于每个前缀暴力跳 \(fail\) 数组（kmp 那个），跳到不能再跳的 \(\rm Bd\) 即为所求。考虑优化一下，对于前缀 \(i\)，若它的最小非空 \(\rm Bd\) 存在，我们可以直接将 \(fail[i]\) 设成它，可以缩短路径。
点击查看代码
const int N=1e6+10;
int n;char s[N];
int fail[N];
int main(){
scanf("%d%s",&n,s+1);
for(int i=2,j=0;i<=n;++i){
while(j&&s[i]!=s[j+1])j=fail[j];
fail[i]=s[i]==s[j+1]?++j:j;
}long long ans=0;
for(int i=1;i<=n;++i){
int j=i;while(fail[j])j=fail[j];
ans+=i-j;
if(fail[i])fail[i]=j;
}printf("%lld\n",ans);
return 0;
}
P2375 [NOI2014] 动物园
显然有个暴力的方法：对每个前缀不断跳 \(\rm Bd\)，知道其长度小于等于前缀长度的一半，那么 \(num[i]\) 就等于它还能继续跳的次数，这个可以在建 \(fail\) 时递推出。考虑怎么优化：
类似构建 \(fail\) 数组的过程，我们可以在 \(fail\) 上匹配自身，然后跑上面的暴力。由于我们减少了重复递归，可以证明是均摊 \(O(n)\) 的。
点击查看代码
const int N=1e6+10;
typedef long long ll;
const ll mod=1e9+7;
int n;char s[N];
int fail[N];
ll cnt[N],ans=1;
void solve(){
scanf("%s",s+1);n=strlen(s+1);
memset(fail,0,sizeof fail);cnt[0]=0,cnt[1]=1;
for(int i=2,j=0;i<=n;++i){
while(j&&s[j+1]!=s[i])j=fail[j];
j+=(s[j+1]==s[i]);
fail[i]=j;cnt[i]=cnt[j]+1;
}ans=1;
for(int i=2,j=0;i<=n;++i){
while(j&&s[j+1]!=s[i])j=fail[j];
j+=(s[j+1]==s[i]);
while((j<<1)>i)j=fail[j];
ans=ans*(cnt[j]+1)%mod;
}printf("%d\n",ans);
}
