后缀数组题目选讲

Codeforces 1654F Minimal String Xoration
Luogu P6095 [JSOI2015] 串分割
P7769 「CGOI-1」大师选徒
Luogu P7361「JZOI-1」拜神
Codeforces 822E Liar
P5284 [十二省联考 2019] 字符串问题
P5341 [TJOI2019] 甲苯先生和大中锋的字符串
P6793 [SNOI2020] 字符串
Luogu P5161 WD与数列
P4094 [HEOI2016/TJOI2016]字符串
P5353 树上后缀排序
SP687 REPEATS - Repeats
CF1073G Yet Another LCP Problem
[ICPC2020 Nanjing R] Baby's First Suffix Array Problem

Codeforces 1654F Minimal String Xoration

设 $T_k$ 表示 $s_{0\oplus k}s_{1\oplus k}s_{2 \oplus_k}\cdots s_{(2^{n}-1)\oplus k}$ 。设 $R(k,t)$ 表示 $T_k$ 的前 $2^t$ 位， $f(k,t)$ 表示 $R(k,t)$ 在所有 $R(,t)$ 的排名。

注意到 $R(k,t+1) = R(k,t) + R(k \oplus 2^{t},t)$ ，因此可以和 SA 一样倍增排序。

# include <bits/stdc++.h>
const int N=300010,INF=0x3f3f3f3f;
inline int read(void){
	int res,f=1;
	char c;
	while((c=getchar())<'0'||c>'9')
		if(c=='-') f=-1;
	res=c-48;
	while((c=getchar())>='0'&&c<='9')
		res=res*10+c-48;
	return res*f;
}
char s[N];
struct Node{
	int fir,sec,id;
	bool operator < (const Node &rhs) const{
		return (fir!=rhs.fir)?(fir<rhs.fir):(sec<rhs.sec);
	}
	bool operator != (const Node &rhs) const{
		return (*this<rhs)||(rhs<*this);
	}
}g[N];
int rk[N];
int n;
int main(void){
	n=1<<read();
	scanf("%s",s);		
	for(int i=0;i<n;++i) g[i]=(Node){s[i],0,i};
	std::sort(g,g+n);
	for(int i=0,cc=0;i<n;++i){
		if(i==0||g[i]!=g[i-1]) rk[g[i].id]=++cc;
		else rk[g[i].id]=cc;
	}
	for(int w=1;w<n;w<<=1){
		for(int i=0;i<n;++i) g[i]=(Node){rk[i],rk[i^w],i};
		std::sort(g,g+n);
		for(int i=0,cc=0;i<n;++i){
			if(i==0||g[i]!=g[i-1]) rk[g[i].id]=++cc;
			else rk[g[i].id]=cc;
		}
	}
	for(int v=0;v<n;++v) if(rk[v]==1){
		for(int i=0;i<n;++i) putchar(s[i^v]);
		exit(0);
	}
	return 0;
}

Luogu P6095 [JSOI2015] 串分割

设给定的数串为 $s$ ，长度为 $n$ ，则答案的位数必然为 $l = \left \lceil \frac{n}{k} \right \rceil$ 。因此，考虑找出所有可能出现的长度为 $l$ 的子串，并二分检查。

具体地，设当前检查的答案为 $s'$ ，考虑枚举循环移位的起点，并依次检查。不难想到贪心：如果当前可以匹配 $l$ 位（接下来 $l$ 位的字典序不比 $s'$ 大），那么就匹配 $l$ 位，否则匹配 $l-1$ 位。这个策略是可行的，因为如果在可以匹配 $l$ 位时只匹配了小于 $l$ 位，则下一次至多也只能匹配 $l$ 位，这样一定不如直接匹配 $l$ 位，下一次匹配 $l-1$ 位。

最后，还是因为每一次至多只匹配 $l$ 位，因此循环移位起点在大于 $l$ 的位置是没有用的（相当于把最前面的一段放到最后去了），不影响检查是否通过。因此我们只枚举起点在 $[1,l]$ 的循环移位，循环内每次检查是 $O(n/l)$ 的，因此一次检查是 $O(n)$ 的。

实现的时候可以直接二分答案在后缀数组上的排名，判断能否匹配 $l$ 位的依据变为起点在后缀数组中的排名是否不超过当前二分的值。如果我们二分的答案刚好是起点对应后缀的前缀，此时会误判为不能匹配。但这是不影响的，因为起点对应后缀也在后缀数组中，当我们二分到其排名时就能够正常判断了。

# include <bits/stdc++.h>

const int N=400010,INF=0x3f3f3f3f;

inline int read(void){
	int res,f=1;
	char c;
	while((c=getchar())<'0'||c>'9')
		if(c=='-') f=-1;
	res=c-48;
	while((c=getchar())>='0'&&c<='9')
		res=res*10+c-48;
	return res*f;
}

int n,k;
int s[N];

namespace SA{
	int sa[N],rk[N],ork[N],buc[N],id[N];
	int mx=128;
	
	inline void clear(void){
		mx=128;
		memset(buc,0,sizeof(buc));
		return;
	}

	
	inline void init(void){
		clear();
		for(int i=1;i<=n;++i) ++buc[rk[i]=s[i]];
		for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
		for(int i=1;i<=n;++i) sa[buc[rk[i]]--]=i;
		
		for(int w=1,cc=0;;mx=cc,cc=0,w<<=1){
			for(int i=n-w+1;i<=n;++i) id[++cc]=i;
			for(int i=1;i<=n;++i) if(sa[i]>w) id[++cc]=sa[i]-w;
			
			memset(buc,0,sizeof(buc));
			memcpy(ork,rk,sizeof(ork));
			cc=0;
			
			for(int i=1;i<=n;++i) ++buc[ork[i]];
			for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
			for(int i=n;i;--i) sa[buc[ork[id[i]]]--]=id[i];
			
			for(int i=1;i<=n;++i)
				rk[sa[i]]=((ork[sa[i]]==ork[sa[i-1]]&&ork[sa[i]+w]==ork[sa[i-1]+w])?cc:++cc);
			if(cc==n) break;
		}
		return;
	}
}
using namespace SA;
int len;

inline bool chk(int x){
	bool ok=false;
	for(int i=1;i<=len;++i){
		int mat=0;
		for(int j=1;j<=k;++j){
			int p=(i+mat-1)%(n/2)+1;
			if(rk[p]<=x) mat+=len;
			else mat+=len-1;
		}
		ok|=(mat>=(n/2));
	}
	return ok;
}

int main(void){
	n=read(),k=read();
	for(int i=1;i<=n;++i) scanf("%1d",&s[i]),s[i+n]=s[i];
	len=(n+k-1)/k;
	n*=2,init();
	
	int l=1,r=n,ans=n+1;
	while(l<=r){
		int mid=(l+r)>>1;
		if(chk(mid)) ans=mid,r=mid-1;
		else l=mid+1;
	}
	for(int i=1;i<=len;++i) printf("%d",s[sa[ans]+i-1]);

	return 0;
}

P7769 「CGOI-1」大师选徒

两个长度为 $n_0$ 的序列 $A,B$ 关于 $s$ 满足条件可以转化为：

$A_1 + B_1 = s$
$\forall 1 \leq i < n_0,A_{i+1} - A_i = -(B_{i+1} - B_i)$

将 $a$ 序列的向前差分数组 $d$ 以及 $-d$ （ $d$ 中元素变为其相反数）拼接到一起，求出其后缀数组。询问时，找到 $d_l$ 所在位置 $pos$ ，二分求出后缀数组上与后缀 $pos$ LCP 大于等于 $r-l$ 的区间。如果这个区间中，有来源于 $-d$ 的位置，并且该位置在 $a$ 数组上对应的值恰为 $a_l - s$ ，那么就找到了一组合法解。给每个 $a_i$ 开一个 vector，对于后缀数组中每个来源于 $-d$ 的位置，将其位置 push 进对应的 vector 中。查询时二分即可。

注意判掉平凡的无解情况。

# include <bits/stdc++.h>

const int N=800010,INF=0x3f3f3f3f;

inline int read(void){
	int res,f=1;
	char c;
	while((c=getchar())<'0'||c>'9')
		if(c=='-') f=-1;
	res=c-48;
	while((c=getchar())>='0'&&c<='9')
		res=res*10+c-48;
	return res*f;
}

int n,q;
char s[N];

int buc[N],sa[N],rk[N],ht[N],id[N],ork[N],mx;
int ans[N];

int mn[N][20];
int a[N],d[N];

std::vector <int> bc[N];

inline void init_sa(int n){
	mx=n+2;
	std::fill(buc+1,buc+1+mx,0);
	for(int i=1;i<=n;++i) ++buc[rk[i]=d[i]+(::n+1)];
	for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
	for(int i=1;i<=n;++i) sa[buc[rk[i]]--]=i;
	for(int w=1,cc=0;w<=n;w<<=1,mx=cc,cc=0){
		for(int i=n-w+1;i<=n;++i) id[++cc]=i;
		for(int i=1;i<=n;++i) if(sa[i]>w) id[++cc]=sa[i]-w;
		memset(buc,0,(mx+1)*4);
		memcpy(ork,rk,sizeof(ork));
		for(int i=1;i<=n;++i) ++buc[ork[i]];
		for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
		for(int i=n;i;--i) sa[buc[ork[id[i]]]--]=id[i];
		cc=0;
		for(int i=1;i<=n;++i)
			rk[sa[i]]=(ork[sa[i]]==ork[sa[i-1]]&&ork[sa[i]+w]==ork[sa[i-1]+w])?cc:++cc;
		if(cc==n) break;
	}
	for(int i=1,k=0;i<=n;++i){
		if(k) --k;
		while(d[i+k]==d[sa[rk[i]-1]+k]) ++k;
		ht[rk[i]]=mn[rk[i]][0]=k;
	}
	for(int j=1;(1<<j)<=n;++j) for(int i=1;i+(1<<j)-1<=n;++i) 
		mn[i][j]=std::min(mn[i][j-1],mn[i+(1<<(j-1))][j-1]);
	for(int i=1;i<=n;++i){
		if(sa[i]>::n) bc[a[sa[i]-::n]].push_back(i);
	}
	return;
}
inline int lcp(int i,int j){
	if(i>j) std::swap(i,j);
	if(i==j) return 2*n-sa[i]+1;
	int l=std::__lg(j-(i++));
	int ans=std::min(mn[i][l],mn[j-(1<<l)+1][l]);
	return ans;
}

inline int getpre(int x,int len){
	int l=1,r=x,ans=x;
	while(l<=r){
		int mid=(l+r)>>1;
		if(lcp(mid,x)>=len) ans=mid,r=mid-1;
		else l=mid+1;
	}
	return ans;
}
inline int getnex(int x,int len){
	int l=x,r=2*n,ans=x;
	while(l<=r){
		int mid=(l+r)>>1;
		if(lcp(mid,x)>=len) ans=mid,l=mid+1;
		else r=mid-1;
	}
	return ans;
}

int main(void){
	n=read(),q=read();
	for(int i=1;i<=n;++i) a[i]=read();
	for(int i=1;i<=n;++i) d[i]=a[i+1]-a[i],d[i+n]=-d[i];
	init_sa(2*n);
	
	while(q--){
		int s=read(),l=read(),r=read();
		int len=r-l,dt=s-a[l];
		if(dt<=0||dt>n||!bc[dt].size()){
			puts("No");
			continue;
		}
		if(l==r){
			puts("Yes");
			continue;
		}
		int L=getpre(rk[l],len),R=getnex(rk[l],len);
		auto itl=std::lower_bound(bc[dt].begin(),bc[dt].end(),L),
			 itr=std::upper_bound(bc[dt].begin(),bc[dt].end(),R);
		puts(itl==itr?"No":"Yes");
	}

	return 0;
}

Luogu P7361「JZOI-1」拜神

类似品酒大会的思路。枚举长度 $L=n-1,\cdots,0$ ，并对于每个 $p$ ，维护出位置 $p$ 左侧最靠右的位置 $le(p)$ 使得后缀 $p$ 和后缀 $le(p)$ 的 LCP 大于等于 $L$ 。这可以使用并查集 + 启发式合并来实现。具体地，将集合 $S$ 和 $T$ 合并时，设我们把所有 $v \in S$ 插入到 $T$ 中，那么每插入一个 $v$ ，就在原来的 $T$ 中二分找到 $v$ 的前驱 $pre$ 和后继 $nex$ ，并修改 $le(v) = pre,le(nex) = v$ 。那么对于长度 $L$ 而言，只要询问区间 $[l,r]$ 中存在一个大于等于 $l$ 的数， $L$ 就合法。

使用可持久化线段树维护出对于每个 $L$ 的 $le$ 数组。查询时二分即可。

# include <bits/stdc++.h>

const int N=50010,INF=0x3f3f3f3f;

inline int read(void){
	int res,f=1;
	char c;
	while((c=getchar())<'0'||c>'9')
		if(c=='-') f=-1;
	res=c-48;
	while((c=getchar())>='0'&&c<='9')
		res=res*10+c-48;
	return res*f;
}

int n,q;
char s[N];

int buc[N],sa[N],rk[N],ht[N],id[N],ork[N],mx;
int ans[N];

inline void init_sa(void){
	mx=128;
	std::fill(buc+1,buc+1+mx,0);
	for(int i=1;i<=n;++i) ++buc[rk[i]=s[i]];
	for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
	for(int i=1;i<=n;++i) sa[buc[rk[i]]--]=i;
	for(int w=1,cc=0;w<=n;w<<=1,mx=cc,cc=0){
		for(int i=n-w+1;i<=n;++i) id[++cc]=i;
		for(int i=1;i<=n;++i) if(sa[i]>w) id[++cc]=sa[i]-w;
		memset(buc,0,(mx+1)*4);
		memcpy(ork,rk,sizeof(ork));
		for(int i=1;i<=n;++i) ++buc[ork[i]];
		for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
		for(int i=n;i;--i) sa[buc[ork[id[i]]]--]=id[i];
		cc=0;
		for(int i=1;i<=n;++i)
			rk[sa[i]]=(ork[sa[i]]==ork[sa[i-1]]&&ork[sa[i]+w]==ork[sa[i-1]+w])?cc:++cc;
		if(cc==n) break;
	}
	for(int i=1,k=0;i<=n;++i){
		if(k) --k;
		while(s[i+k]==s[sa[rk[i]-1]+k]) ++k;
		ht[rk[i]]=k;
	}
	return;
}

struct Node{
	int x,w;
	bool operator < (const Node &rhs) const{
		return w>rhs.w;
	}
};
std::vector <Node> S;

namespace SGT{
	struct Node{
		int mx,lc,rc;
		Node(){mx=INF,lc=rc=0;}
	}tr[N*500];
	int cnt;
	
	inline int& lc(int x){
		return tr[x].lc;
	}
	inline int& rc(int x){
		return tr[x].rc;
	}
	inline void psup(int k){
		return tr[k].mx=std::min(tr[lc(k)].mx,tr[rc(k)].mx),void();
	}
	void update(int &k,int lst,int l,int r,int x,int v){
		k=++cnt,tr[k]=tr[lst];
		if(l==r) return tr[k].mx=v,void();
		int mid=(l+r)>>1;
		if(x<=mid) update(lc(k),lc(lst),l,mid,x,v);
		else update(rc(k),rc(lst),mid+1,r,x,v);
		psup(k);
		return;
	}
	int query(int k,int l,int r,int L,int R){
		if(!k) return INF;
		if(L<=l&&r<=R) return tr[k].mx;
		int mid=(l+r)>>1,ans=INF;
		if(L<=mid) ans=query(lc(k),l,mid,L,R);
		if(mid<R) ans=std::min(ans,query(rc(k),mid+1,r,L,R));
		return ans;
	}
}

std::set <int> st[N];
int f[N];

inline int find(int x){
	return (f[x]==x)?x:f[x]=find(f[x]);
}
int rt[N];

inline void merge(int u,int v,int ver){	
	u=find(u),v=find(v);
	if(u==v) return;
	if(st[u].size()>st[v].size()) std::swap(u,v);
	while(st[u].size()){
		int w=*st[u].begin();
		auto it=st[v].lower_bound(w);
		if(it!=st[v].end()) SGT::update(rt[ver],rt[ver],1,n,w,*it);
		if(it!=st[v].begin()) --it,SGT::update(rt[ver],rt[ver],1,n,*it,w);
		st[u].erase(w),st[v].insert(w);
	}
	f[u]=v;
	return;
}

int main(void){	
	n=read(),q=read();
	scanf("%s",s+1);
	init_sa();
	
	for(int i=2;i<=n;++i) S.emplace_back((Node){i,ht[i]});
	std::sort(S.begin(),S.end());
	auto it=S.begin();
	
	for(int i=1;i<=n;++i) f[i]=i,st[i].insert(i);

	for(int L=n-1;L>=0;--L){
		rt[L]=rt[L+1];
		while(it!=S.end()&&(*it).w==L){
			int p=(*it).x;
			merge(sa[p-1],sa[p],L);
			++it;
		}
	}
	
	while(q--){
		int L=read(),R=read();
		int l=1,r=R-L+1,ans=0;
		while(l<=r){
			int mid=(l+r)>>1;			
			if(SGT::query(rt[mid],1,n,L,R-mid)<=R-mid+1) ans=mid,l=mid+1;
			else r=mid-1;
		}
		printf("%d\n",ans);
	}
	
	return 0;
}

Codeforces 822E Liar

设 $f(i,j)$ 表示只用 $s[1,i]$ 的字符，用了 $j$ 段，最多能匹配到 $t$ 的哪里。

我们发现，如果我们新开了一段，能匹配就匹配显然是不劣的，于是记 $f(i,j) = x,\text{lcp}(t[x+1,|t|],s[i+1,|s|]) = k$ ，则 $f(i,j)$ 向 $f(i+k,j+1)$ 转移。同时也可以不选，于是 $f(i,j)$ 也可以向 $f(i+1,j)$ 转移。

# include <bits/stdc++.h>

const int N=200010,INF=0x3f3f3f3f;

inline int read(void){
	int res,f=1;
	char c;
	while((c=getchar())<'0'||c>'9')
		if(c=='-') f=-1;
	res=c-48;
	while((c=getchar())>='0'&&c<='9')
		res=res*10+c-48;
	return res*f;
}

int n,m,lim;

char S[N],T[N];
char s[N];
int len;
int f[N][35];

int ork[N],rk[N],buc[N],sa[N],id[N],mx=128;
int ht[N];

int mn[N][20];

inline void init(void){
	for(int i=1;i<=len;++i) ++buc[rk[i]=s[i]];
	for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
	for(int i=1;i<=len;++i) sa[buc[rk[i]]--]=i;
	
	for(int w=1,cc=0;w<=len;w<<=1,mx=cc,cc=0){
		for(int i=len-w+1;i<=len;++i) id[++cc]=i;
		for(int i=1;i<=len;++i) if(sa[i]>w) id[++cc]=sa[i]-w;
		
		memset(buc,0,sizeof(buc)),memcpy(ork,rk,sizeof(ork)),cc=0;
		for(int i=1;i<=len;++i) ++buc[ork[i]];
		for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
		for(int i=len;i;--i) sa[buc[ork[id[i]]]--]=id[i];
		
		for(int i=1;i<=len;++i)
			rk[sa[i]]=((ork[sa[i]]==ork[sa[i-1]]&&ork[sa[i]+w]==ork[sa[i-1]+w])?cc:(++cc));
		
		if(cc==len) break;
	}
	
	for(int i=1,k=0;i<=len;++i){
		if(k) --k;
		while(s[i+k]==s[sa[rk[i]-1]+k]) ++k;
		ht[rk[i]]=mn[rk[i]][0]=k;
	}
	for(int k=1;(1<<k)<=len;++k) for(int i=1;i<=len;++i)
		mn[i][k]=std::min(mn[i][k-1],mn[i+(1<<(k-1))][k-1]);
	return;
}
inline int lcp(int i,int j){
	assert(i!=j),i=rk[i],j=rk[j];
	if(i>j) std::swap(i,j);
	int k=std::__lg(j-(i++));
	return std::min(mn[i][k],mn[j-(1<<k)+1][k]);
}

int main(void){
	n=read(),scanf("%s",S+1),m=read(),scanf("%s",T+1),lim=read();
	for(int i=1;i<=n;++i) s[++len]=S[i];
	s[++len]='@';
	for(int i=1;i<=m;++i) s[++len]=T[i];
	init();
	for(int i=0;i<n;++i) for(int k=0;k<=lim;++k){
		f[i+1][k]=std::max(f[i+1][k],f[i][k]);
		int lp=lcp(i+1,(n+1)+f[i][k]+1);
		f[i+lp][k+1]=std::max(f[i+lp][k+1],f[i][k]+lp);
	}
	int ans=0;
	for(int i=0;i<=lim;++i) ans=std::max(f[n][i],ans);
	printf(ans==m?"YES":"NO");
	return 0;
}

P5284 [十二省联考 2019] 字符串问题

最后的要求形似一条从 $A$ 串到 $A$ 串的路径。

考虑对于一对支配关系 $A_i,B_j$ ，哪些 $A_k = S(l_k,r_k)$ 可以通过这对支配关系接到 $A_i$ 后面。设 $B_j = S(l_j,r_j)$ ，那么 $\text{lcp}(S[l_j,|S|],S[l_k,|S|]) \geq |B_j|$ 必须成立，同时 $|A_k| \geq |B_j|$ 也要成立。

对于第一个条件，可以二分找到后缀数组上的合法区间，只有 $l_k$ 在这个区间中时， $A_k$ 才可能合法。对于第二个条件，似乎没有什么头绪。考虑使用主席树优化建图。具体地，从大到小枚举 $L$ ，将 $L = |A_k|$ 的 $A_k$ 插入到 $sa[l_k]$ 这个位置上，并令虚点连向 $A_k$ 的边权值为 $|A_k|$ 。对于所有 $L = |B_j|$ 的 $B_j$ ，让 $B_j$ 和主席树上对应区间连边。主席树上的边权值均为 $0$ 。

最后，对于每对支配关系 $A_i,B_j$ ，将 $A_i,B_j$ 连边。

答案为图中最长路。不难发现，图上没有零权环，因此有环必为正权环，此时答案为 $+\infty$ 。使用 Tarjan 判环即可。

若无环则拓扑排序求出 DAG 上最长路，即可求得答案。

P5341 [TJOI2019] 甲苯先生和大中锋的字符串

我们可以对于每种长度，求出有多少个该长度的子串出现了恰 $k$ 次。枚举后缀数组上每个区间 $[i,i+k-1]$ ，并钦定子串的 $k$ 次出现均出现在该区间中，在此条件下，计算有多少子串出现了 $k$ 次。

事实上，该子串长度必然不会超过该区间后缀的 LCP 长度，否则其出现了小于 $k$ 次。同时，该子串的长度必然大于 $\max(\text{height}(i),\text{height}(i+k))$ ，否则该子串出现了大于 $k$ 次。

单调队列维护出区间 LCP 长度（一段 height 的最小值），差分统计答案即可。

# include <bits/stdc++.h>

const int N=100010,INF=0x3f3f3f3f;

inline int read(void){
	int res,f=1;
	char c;
	while((c=getchar())<'0'||c>'9')
		if(c=='-') f=-1;
	res=c-48;
	while((c=getchar())>='0'&&c<='9')
		res=res*10+c-48;
	return res*f;
}

int n,k;

int T;

char s[N];

namespace sa{
	int sa[N],rk[N],ork[N],ht[N],buc[N],id[N];
	int mx=128;
	
	inline void clear(void){
		mx=128;
		memset(buc,0,sizeof(buc));
		return;
	}
	
	inline void init(void){
		clear();
		for(int i=1;i<=n;++i) ++buc[rk[i]=s[i]];
		for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
		for(int i=1;i<=n;++i) sa[buc[rk[i]]--]=i;
		
		for(int w=1,cc=0;;mx=cc,cc=0,w<<=1){
			for(int i=n-w+1;i<=n;++i) id[++cc]=i;
			for(int i=1;i<=n;++i) if(sa[i]>w) id[++cc]=sa[i]-w;
			
			memset(buc,0,sizeof(buc));
			memcpy(ork,rk,sizeof(ork));
			cc=0;
			
			for(int i=1;i<=n;++i) ++buc[ork[i]];
			for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
			for(int i=n;i;--i) sa[buc[ork[id[i]]]--]=id[i];
			
			for(int i=1;i<=n;++i)
				rk[sa[i]]=((ork[sa[i]]==ork[sa[i-1]]&&ork[sa[i]+w]==ork[sa[i-1]+w])?cc:++cc);
			if(cc==n) break;
		}
		
		for(int i=1,k=0;i<=n;++i){
			if(k) --k;
			while(s[i+k]==s[sa[rk[i]-1]+k]) ++k;
			ht[rk[i]]=k;
		}
		return;
	}
	
	int q[N],hd,tl;
	
	inline void ins(int x){
		while(hd<=tl&&ht[q[tl]]>=ht[x]) --tl;
		q[++tl]=x;
		return;
	}
	inline void chk(int x){ // L moved from x to x+1
		while(hd<=tl&&q[hd]<=x+1) ++hd;
		return;
	}
	
	int d[N];
	
	inline void solve(void){
		init(),hd=1,tl=0,ht[n+1]=0;	
		memset(d,0,sizeof(d));
		for(int i=1;i<k;++i) ins(i+1);
		for(int i=1;i+k-1<=n;++i){
			int r=(k==1)?n-sa[i]+1:ht[q[hd]];
			int l=std::max(ht[i],ht[i+k]);
			if(l<r) ++d[l+1],--d[r+1];
			chk(i),ins(i+k);
		}
		int mx=0;
		for(int i=1;i<=n;++i) d[i]+=d[i-1],(d[i]>=d[mx]?mx=i:mx=mx);
		printf("%d\n",(d[mx]==0)?-1:mx);
		return;
	}
}

int main(void){
	T=read();
	
	while(T--){
		scanf("%s",s+1),n=strlen(s+1),k=read();
		if(n<k){
			puts("-1");
			continue;
		}
		sa::solve(); 
		
	}
	return 0;
}

P6793 [SNOI2020] 字符串

现在找出一组 $A,B$ 集合中串的配对，考虑如何计算代价。代价即总长度减去每对匹配串的 LCP 长度之和的两倍。

一种直观的想法是品酒大会，倒序枚举 LCP 长度，然后合并后缀数组上的区间，每次匹配两个连通块中还未匹配的串。事实上这就是对的，因为如果现在不匹配以后再匹配的话权值一定更小。

# include <bits/stdc++.h>

const int N=500010,INF=0x3f3f3f3f;

inline int read(void){
	int res,f=1;
	char c;
	while((c=getchar())<'0'||c>'9')
		if(c=='-') f=-1;
	res=c-48;
	while((c=getchar())>='0'&&c<='9')
		res=res*10+c-48;
	return res*f;
}

int n,k;
char s[N],A[N],B[N];

int buc[N],sa[N],rk[N],ht[N],id[N],ork[N],mx;
long long ans;

inline void init_sa(int n){
	mx=128;
	std::fill(buc+1,buc+1+mx,0);
	for(int i=1;i<=n;++i) ++buc[rk[i]=s[i]];
	for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
	for(int i=1;i<=n;++i) sa[buc[rk[i]]--]=i;
	for(int w=1,cc=0;w<=n;w<<=1,mx=cc,cc=0){
		for(int i=n-w+1;i<=n;++i) id[++cc]=i;
		for(int i=1;i<=n;++i) if(sa[i]>w) id[++cc]=sa[i]-w;
		memset(buc,0,(mx+1)*4);
		memcpy(ork,rk,sizeof(ork));
		for(int i=1;i<=n;++i) ++buc[ork[i]];
		for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
		for(int i=n;i;--i) sa[buc[ork[id[i]]]--]=id[i];
		cc=0;
		for(int i=1;i<=n;++i)
			rk[sa[i]]=(ork[sa[i]]==ork[sa[i-1]]&&ork[sa[i]+w]==ork[sa[i-1]+w])?cc:++cc;
		if(cc==n) break;
	}
	for(int i=1,k=0;i<=n;++i){
		if(k) --k;
		while(s[i+k]==s[sa[rk[i]-1]+k]) ++k;
		ht[rk[i]]=k;
	}
	return;
}

struct Node{
	int x,w;
	bool operator < (const Node &rhs) const{
		return w>rhs.w;
	}
};
std::vector <Node> S;

std::set <int> st[N];
int f[N];

inline int find(int x){
	return (f[x]==x)?x:f[x]=find(f[x]);
}
int ca[N],cb[N];

inline void merge(int u,int v,int ver){	
	u=find(u),v=find(v);
	if(u==v) return;
	f[u]=v;
	int l=std::min(ca[u],cb[v]),r=std::min(cb[u],ca[v]);	
	ans+=1ll*ver*(l+r),ca[u]-=l,cb[v]-=l,cb[u]-=r,ca[v]-=r,ca[v]+=ca[u],cb[v]+=cb[u];	
	return;
}

int main(void){	
	n=read(),k=read();
	scanf("%s",A+1),scanf("%s",B+1);
	for(int i=1;i<=n;++i) s[i]=A[i],s[i+(n+1)]=B[i];
	s[n+1]='#',init_sa(2*n+1);
	
	for(int i=2;i<=2*n+1;++i) S.emplace_back((Node){i,ht[i]});
	std::sort(S.begin(),S.end());
	auto it=S.begin();
	
	for(int i=1;i<=2*n+1;++i) f[i]=i;
	for(int i=1;i<=n-k+1;++i) ca[i]=1,cb[i+(n+1)]=1;

	for(int L=n;L>=0;--L){
		while(it!=S.end()&&(*it).w==L){
			int p=(*it).x;
			merge(sa[p-1],sa[p],std::min(L,k));
			++it;
		}
	}
	printf("%lld",1ll*(n-k+1)*k-ans);
	return 0;
}

Luogu P5161 WD与数列

长度为 $1$ 的贡献有 $\frac{n(n+1)}{2}$ 。考虑长度大于 $1$ 的串，要求即为差分序列相等。

那么，对于差分序列的两个后缀 $i,j$ ，它们对答案的贡献真的是 $|\text{lcp}(\text{suf}(i),\text{suf}(j))|$ 吗？很显然并不是，因为子串不能相交或相邻，因此对答案的贡献还要对 $|i-j|-1$ 取 min。

那么我们可以使用品酒大会的方法（三回啊三回）干掉 $\text{lcp}$ 的限制。设我们在 $\text{lcp} = x$ 的时候合并了后缀集合 $S$ 和后缀集合 $T$ ，若 $|S| > |T|$ 则交换 $S,T$ ，保证启发式合并的复杂度。枚举计算 $v \in S$ 计算 $v$ 和 $T$ 集合的贡献。对于 $T$ 集合中的元素 $w \in T$ ，如果 $|v - w| - 1 \leq x$ ，则贡献为 $|v - w| - 1$ ，否则为 $x$ 。据此可以解出四个区间（实际上只需要线段树查询 $2$ 次），计算每个区间内的元素数量 / 元素和，可以采用线段树合并完成。

# include <bits/stdc++.h>

const int N=300010,INF=0x3f3f3f3f;

inline int read(void){
	int res,f=1;
	char c;
	while((c=getchar())<'0'||c>'9')
		if(c=='-') f=-1;
	res=c-48;
	while((c=getchar())>='0'&&c<='9')
		res=res*10+c-48;
	return res*f;
}

typedef long long ll;

int n,q;
char s[N];

int buc[N],sa[N],rk[N],ht[N],id[N],ork[N],mx;
int d[N];

ll ans;

inline void init_sa(int n){
	mx=n;
	std::fill(buc+1,buc+1+mx,0);
	for(int i=1;i<=n;++i) ++buc[rk[i]=d[i]];
	for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
	for(int i=1;i<=n;++i) sa[buc[rk[i]]--]=i;
	for(int w=1,cc=0;w<=n;w<<=1,mx=cc,cc=0){
		for(int i=n-w+1;i<=n;++i) id[++cc]=i;
		for(int i=1;i<=n;++i) if(sa[i]>w) id[++cc]=sa[i]-w;
		memset(buc,0,(mx+1)*4);
		memcpy(ork,rk,sizeof(ork));
		for(int i=1;i<=n;++i) ++buc[ork[i]];
		for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
		for(int i=n;i;--i) sa[buc[ork[id[i]]]--]=id[i];
		cc=0;
		for(int i=1;i<=n;++i)
			rk[sa[i]]=(ork[sa[i]]==ork[sa[i-1]]&&ork[sa[i]+w]==ork[sa[i-1]+w])?cc:++cc;
		if(cc==n) break;
	}
	for(int i=1,k=0;i<=n;++i){
		if(k) --k;
		while(d[i+k]==d[sa[rk[i]-1]+k]) ++k;
		ht[rk[i]]=k;
	}
	return;
}

struct Node{
	int x,w;
	bool operator < (const Node &rhs) const{
		return w>rhs.w;
	}
};
std::vector <Node> S;

namespace SGT{
	struct Node{
		int lc,rc,cnt;
		ll sum;
		Node(){cnt=sum=lc=rc=0;}
	}tr[N*21];
	int cnt;
	
	inline int& lc(int x){
		return tr[x].lc;
	}
	inline int& rc(int x){
		return tr[x].rc;
	}
	inline void psup(Node &cur,const Node &lc,const Node &rc){
		cur.cnt=lc.cnt+rc.cnt,cur.sum=lc.sum+rc.sum;
		return;
	}
	void ins(int &k,int l,int r,int x){
		if(!k) k=++cnt;
		if(l==r) return tr[k].sum=x,tr[k].cnt=1,void();
		int mid=(l+r)>>1;
		if(x<=mid) ins(lc(k),l,mid,x);
		else ins(rc(k),mid+1,r,x);
		psup(tr[k],tr[lc(k)],tr[rc(k)]);
		return;
	}
	void merge(int &cur,int u,int v,int l,int r){
		if(!u||!v) return cur=u|v,void();
		if(l==r) return tr[cur].sum=tr[u].sum+tr[v].sum,tr[cur].cnt=tr[u].cnt+tr[v].cnt,void();
		int mid=(l+r)>>1;
		merge(lc(cur),lc(u),lc(v),l,mid);
		merge(rc(cur),rc(u),rc(v),mid+1,r);
		psup(tr[cur],tr[lc(cur)],tr[rc(cur)]);
		return;
	}
	Node query(int k,int l,int r,int L,int R){
		if(L>R||!k) return Node();
		if(L<=l&&r<=R) return tr[k];
		int mid=(l+r)>>1;
		Node res,lh,rh;
		if(L<=mid) lh=query(lc(k),l,mid,L,R);
		if(mid<R) rh=query(rc(k),mid+1,r,L,R);
		psup(res,lh,rh);
		return res;
	}
	void dfs(int k,int l,int r){
		if(l==r) return printf("(%d,%lld)",tr[k].cnt,tr[k].sum),void();
		int mid=(l+r)>>1;
		dfs(lc(k),l,mid),dfs(rc(k),mid+1,r);
		return;
	}
}

std::vector <int> st[N];
int f[N];

inline int find(int x){
	return (f[x]==x)?x:f[x]=find(f[x]);
}
int rt[N];

inline void merge(int u,int v,int ver){
	u=find(u),v=find(v);
	if(u==v) return;
	if(st[u].size()>st[v].size()) std::swap(u,v);
	
	ans+=1ll*st[u].size()*st[v].size()*ver;
	
	for(auto x:st[u]){
		int l=std::max(1,x-ver),r=x-1;
		SGT::Node res=SGT::query(rt[v],1,n,l,r);
		ans-=1ll*(ver+1-x)*res.cnt+res.sum;
		l=x+1,r=std::min(x+ver,n);
		res=SGT::query(rt[v],1,n,l,r);		
		ans-=1ll*(ver+1+x)*res.cnt-res.sum;
	}
	for(auto x:st[u]) st[v].push_back(x);
	std::vector <int> ().swap(st[u]);
	f[u]=v;
	SGT::merge(rt[v],rt[v],rt[u],1,n);
//	SGT::dfs(rt[v],1,n);
	return;
}
int tp[N];
std::map <int,int> mp;

int main(void){	
//	freopen("in.txt","r",stdin);
	
	n=read(),ans=1ll*n*(n-1)/2;
	for(int i=1;i<=n;++i) tp[i]=read();
	for(int i=1;i<n;++i) d[i]=tp[i+1]-tp[i],mp[d[i]]=1;
	int mpc=0;
	for(auto &cur:mp) cur.second=++mpc;
	for(int i=1;i<n;++i) d[i]=mp[d[i]];
	init_sa(n-1);
	for(int i=2;i<n;++i) S.emplace_back((Node){i,ht[i]});
	std::sort(S.begin(),S.end());
	auto it=S.begin();
	for(int i=1;i<n;++i) f[i]=i,st[i].push_back(i),SGT::ins(rt[i],1,n,i);
	for(int L=n-2;L>=0;--L){
		while(it!=S.end()&&(*it).w==L){
			int p=(*it).x;
			merge(sa[p-1],sa[p],L);
			++it;
		}
	}
	
	printf("%lld",ans);
	
	return 0;
}

P4094 [HEOI2016/TJOI2016]字符串

考虑 $s[x,b](a \leq x \leq b)$ 和 $s[c,d]$ 的 LCP 长度，等于 $\min\{\text{lcp}(s[x,n],s[c,n]),d-c+1,b-x+1\}$ 。

其中 $d-c+1$ 是常数，可以最后考虑。重点求 $\min\{\text{lcp}(s[x,n],s[c,n]),b-x+1\}$ 的最大值。

二分答案 $l$ 。二分找到 $\text{lcp}(s[x,n],s[c,n]) \geq l$ 的区间，那么这段区间中大于等于 $b-x+1$ 的数才能成为答案。主席树查询即可。

P5353 树上后缀排序

题目等价于这样一件事情：取出节点 $x$ 到根的字符组成的序列 $S_x$ ，以及根到 $x$ 的节点编号组成的序列 $I_x$ 。比较 $x,y$ 时，先比较 $S_x,S_y$ 的字典序大小，随后比较 $I_x,I_y$ 的字典序大小。

为了应对关键字 $I_x$ ，我们在倍增排序时引入不可重排名 $rrk$ ：在两个串目前相等时不再让它们的排名相等，而直接令 $rrk[sa[i]] = i$ 。

现在，考虑在倍增排序时使用三个关键字：靠下半段的可重排名，靠上半段的不可重排名，靠下半段的不可重排名。

第一个是为了区分 $S_x$ 靠下半段的字典序，第二个同时区分了 $S_x$ 靠上半段的字典序和 $I_x$ 靠上半段的字典序。如果比完了这个都仍然相等，那么两个串就相等了，第三关键字的作用就是区分 $I_x$ 靠下半段的字典序。

# include <bits/stdc++.h>

const int N=500010,INF=0x3f3f3f3f;

inline int read(void){
	int res,f=1;
	char c;
	while((c=getchar())<'0'||c>'9')
		if(c=='-') f=-1;
	res=c-48;
	while((c=getchar())>='0'&&c<='9')
		res=res*10+c-48;
	return res*f;
}

typedef long long ll;

int n,q;
char s[N];

int buc[N],sa[N],rk[N],ht[N],id[N],ork[N],mx,rrk[N],bk[N];

ll ans;
int f[N][20];

inline void radix_sort(int *res,int *rk,int *id,int mx){
	std::fill(buc,buc+1+mx,0);
	for(int i=1;i<=n;++i) ++buc[rk[i]];
	for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
	for(int i=n;i;--i) res[buc[rk[id[i]]]--]=id[i];
	return;
}

inline bool equal(int x,int y,int t){
	return ork[x]==ork[y]&&ork[f[x][t]]==ork[f[y][t]];
}

inline void init_sa(int n){
	for(int i=1;i<=n;++i) rk[i]=s[i],id[i]=i;
	radix_sort(sa,rk,id,128);
	for(int i=1,cc=0;i<=n;++i){
		rk[sa[i]]=(s[sa[i]]==s[sa[i-1]]?cc:++cc);
		rrk[sa[i]]=i;
	}

	for(int w=1,t=0;w<=n;w<<=1,++t){
		for(int i=1;i<=n;++i) bk[i]=rrk[f[i][t]];
		radix_sort(ork,bk,sa,n);
		radix_sort(sa,rk,ork,n);
		std::swap(rk,ork);
		
		for(int i=1,cc=0;i<=n;++i){
			rk[sa[i]]=equal(sa[i],sa[i-1],t)?cc:++cc;
			rrk[sa[i]]=i;
			if(cc==n) return;
		}
	}
	return;
}

int main(void){
	n=read();
	for(int i=2;i<=n;++i){
		f[i][0]=read();
		for(int k=1;k<=19;++k) f[i][k]=f[f[i][k-1]][k-1];
	}
	scanf("%s",s+1);
	init_sa(n);
	for(int i=1;i<=n;++i) printf("%d ",sa[i]);
	
	return 0;
}

SP687 REPEATS - Repeats

沿用优秀的拆分一题的想法，枚举循环节长度 $L$ ，每隔 $L$ 撒一个关键点。设相邻两个关键点为 $a,b$ 。如果确有一个重复子串的相邻两次出现经过 $a,b$ 两个关键点，那么 $\text{lcp}(a,b)+\text{lcs}(a,b) - 1 \geq L$ 必须成立。反之，如果这条件成立，则我们在原字符串中找到了两个相等且间隔 $L$ 的子串，它们构成它们并的 border，从而它们的并有周期 $L$ 。因此 $(\text{lcp}(a,b)+\text{lcs}(a,b) - 1)/L$ 下取整可以作为一个备选答案。

# include <bits/stdc++.h>

const int N=50010,INF=0x3f3f3f3f;

char s[N],fs[N],logt[N];
int n;

struct SuffixArray{
	int sa[N],rank[N],len,num,t[N],cnt,fir[N],sec[N],height[N],minx[N][20];
	inline void clear(void){
    	memset(sa,0,sizeof(sa)),memset(fir,0,sizeof(fir)),memset(sec,0,sizeof(sec));
	}
	inline void build(char *s,int n){
		clear();
		len=n,num=128;
		std::fill(t+1,t+1+num,0);
		for(int i=1;i<=n;++i) ++t[fir[i]=s[i]];
		for(int i=1;i<=num;++i) t[i]+=t[i-1];
		for(int i=n;i;--i) sa[t[fir[i]]--]=i;
		for(int k=1;k<=n;k<<=1){
			cnt=0;
			for(int i=n-k+1;i<=n;++i) sec[++cnt]=i;
			for(int i=1;i<=n;++i) if(sa[i]>k) sec[++cnt]=sa[i]-k;
			std::fill(t+1,t+1+num,0);
			for(int i=1;i<=n;++i) ++t[fir[i]];
			for(int i=1;i<=num;++i) t[i]+=t[i-1];
			for(int i=n;i;--i) sa[t[fir[sec[i]]]--]=sec[i];
			std::swap(sec,fir),cnt=1,fir[sa[1]]=1;
			for(int i=2;i<=n;++i)
				fir[sa[i]]=((sec[sa[i-1]]==sec[sa[i]]&&sec[sa[i-1]+k]==sec[sa[i]+k])?cnt:++cnt);
			if(cnt==n) break;
			num=cnt;
		}
		for(int i=1;i<=n;++i) rank[sa[i]]=i;
		return;
	}
	inline void get_height(char *s){
		int n=len;
		s[n+1]=s[0]=0;
		for(int i=1,k=0;i<=n;++i){
			if(k) --k;
			while(s[i+k]==s[sa[rank[i]-1]+k]) ++k;
			height[rank[i]]=k;
		}
		for(int i=1;i<=n;++i) minx[i][0]=height[i];
		for(int k=1;(1<<k)<=n;++k){
			for(int i=1;i+(1<<k)-1<=n;++i) minx[i][k]=std::min(minx[i][k-1],minx[i+(1<<(k-1))][k-1]);
		}
		return;
	}
	inline int query(int l,int r){
		int len=logt[r-l+1];
		return std::min(minx[l][len],minx[r-(1<<len)+1][len]);
	}
	inline int querylcp(int l,int r){
		if(l==0||r==0||l>n||r>n) return 0;
		int a=rank[l],b=rank[r];
		if(a>b) std::swap(a,b);
		return query(a+1,b);
	}
	
}A,B;

inline int read(void){
	int res,f=1;
	char c;
	while((c=getchar())<'0'||c>'9')
		if(c=='-')f=-1;
	res=c-48;
	while((c=getchar())>='0'&&c<='9')
		res=res*10+c-48;
	return res*f;
}
inline void solve(void){
	for(int i=1;i<=n;++i) fs[i]=s[n-i+1];
	A.build(s,n),B.build(fs,n);
	A.get_height(s),B.get_height(fs);
	int maxx=0;
	for(int len=1;len<=n;++len){
		for(int L=len,R=2*len;R<=n;L+=len,R+=len){
			int lcp=A.querylcp(L,R),lcs=B.querylcp(n-L+2,n-R+2);
			maxx=std::max(maxx,(lcp+lcs)/len+1);
		}
	}
	printf("%d\n",maxx);
	return;
}
int main(void){
	for(int i=2;i<=50000;++i) logt[i]=logt[i>>1]+1;
	int T=read();
	while(T--){
		n=read();
		char op[2];
		for(int i=1;i<=n;++i) scanf("%s",op),s[i]=op[0];
		solve();
	}

	return 0;
}

CF1073G Yet Another LCP Problem

给定字符集为小写字母的字符串 $s$ 。

$q$ 次询问，每次给定大小分别为 $a,b$ 的集合 $A,B \subseteq \{1,2,\cdots,n\}$ ，求：

$\sum \limits_{i \in A} \sum \limits_{j \in B} \text{lcp}(\text{suf}_i,\text{suf}_j)$
$1 \leq n ,q \leq 2 \times 10^5, 1 \leq \sum a,\sum b \leq 2 \times 10^5$

将 $i,j$ 变为 $rk(i),rk(j)$ 后排序，将 $A,B$ 变成一个递增的序列，放到 $sa$ 数组上进行考虑（原来考虑的是后缀 $i$ 和后缀 $j$ 的 $\text{lcp}$ ，将 $i,j$ 变为 $rk(i),rk(j)$ 后变为考虑后缀 $sa_i,sa_j$ 的 $\text{lcp}$ ）。因为 $sa$ 数组上有性质 $\text{lcp}(sa_i,sa_j) = \min \limits_{k=i+1}^{j} \text{height}_{k} (i<j)$ ，所以我们就方便使用数据结构进行整体考虑了。

先假设不存在 $A_i \neq B_j$ 。

对于一个 $A_i$ ，我们钦定 $A_i$ 只和小于它的 $B_j$ 产生贡献。因此，从前往后扫描 $A_i$ ，同时用单调栈维护 $\sum \limits_{B_j \leq x} \text{lcp}(sa_{B_j},sa_{x})$ 。 $x$ 是我们维护的一个指针，表示我们现在扫到了 $sa$ 数组的第 $x$ 位。根据 $\text{height}$ 数组的性质，当指针 $x$ 移动到 $x'$ 时，原有的 $\text{lcp}(sa_{B_j},sa_{x})$ 变为 $\text{lcp}(sa_{B_j},sa_{x'})$ ，要对 $\text{lcp} (sa_x,sa_{x'})$ 取 $\min$ ，对应单调栈的弹出操作。

如果当前的 $x'$ 指向某个 $B_j$ ，则向单调栈添加 $n - sa_{x'} + 1$ 这个元素（对应该后缀长度）。如果当前的 $x'$ 指向了 $A_i$ ，那么可以直接在单调栈中查询统计好的答案。

对于 $B_i$ ，我们也可以钦定 $B_i$ 只和小于它的 $A_j$ 产生贡献。据此可以使用另一个单调栈维护贡献。

注意到，如果存在 $B_i = A_j$ ，它们的贡献只能被统计一次。于是我们钦定 $A_i$ 只和小于它的 $B_j$ 产生贡献， $B_i$ 只和小于等于它的 $A_j$ 产生贡献，即可不重不漏地求得答案。

# include <bits/stdc++.h>

const int N=200010,INF=0x3f3f3f3f;

inline int read(void){
	int res,f=1;
	char c;
	while((c=getchar())<'0'||c>'9')
		if(c=='-') f=-1;
	res=c-48;
	while((c=getchar())>='0'&&c<='9')
		res=res*10+c-48;
	return res*f;
}

typedef long long ll;

struct Stack{
	int val[N],l[N],top;
	ll sum;
	inline void init(void){
		top=sum=0;
		return;
	}
	inline void check(int cval){
		int len=0;
		while(top&&val[top]>=cval) sum-=1ll*l[top]*val[top],len+=l[top],--top;
		val[++top]=cval,l[top]=len,sum+=1ll*cval*len;
		return;
	}
	inline void push(int cval){
		val[++top]=cval,l[top]=1,sum+=cval;
		return;
	}
}ta,tb;

int a[N],b[N];
int alen,blen;
char s[N];
int n,q;

namespace sa{
	int rk[N],sa[N],ork[N];
	int buc[N],id[N];
	int ht[N];
	int mx=128;
	int mn[N][20],lg[N];
	
	inline void st_init(void){
		for(int i=1;i<=n;++i) mn[i][0]=ht[i],lg[i]=((i==1)?0:lg[i>>1]+1);
		for(int j=1;(1<<j)<=n;++j) for(int i=1;i+(1<<j)-1<=n;++i)
			mn[i][j]=std::min(mn[i][j-1],mn[i+(1<<(j-1))][j-1]);
		return;
	}
	
	inline int st_query(int l,int r){
		assert(l<=r);
		int t=lg[r-l+1];
		return std::min(mn[l][t],mn[r-(1<<t)+1][t]);
	}
	
	inline int lcp(int l,int r){
		if(l>r) std::swap(l,r);
		if(l==r) return n-sa[l]+1;
		return st_query(l+1,r);
	}
	inline void init(void){
		for(int i=1;i<=n;++i) ++buc[rk[i]=s[i]];
		for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
		for(int i=1;i<=n;++i) sa[buc[rk[i]]--]=i;
		for(int w=1,cc=0;;mx=cc,cc=0,w<<=1){
			for(int i=n-w+1;i<=n;++i) id[++cc]=i;
			for(int i=1;i<=n;++i) if(sa[i]>w) id[++cc]=sa[i]-w;
			memset(buc,0,sizeof(buc));
			memcpy(ork,rk,sizeof(ork));
			cc=0;
			for(int i=1;i<=n;++i) ++buc[ork[i]];
			for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
			for(int i=n;i;--i) sa[buc[ork[id[i]]]--]=id[i];	
			for(int i=1;i<=n;++i)
				rk[sa[i]]=((ork[sa[i]]==ork[sa[i-1]]&&ork[sa[i]+w]==ork[sa[i-1]+w])?cc:++cc);
			
			if(cc==n) break;
		}
		for(int i=1,k=0;i<=n;++i){
			if(k) --k;
			while(s[i+k]==s[sa[rk[i]-1]+k]) ++k;
			ht[rk[i]]=k;
		}
		st_init();
		return;
	}
	
	inline ll solve(void){
		for(int i=1;i<=alen;++i) a[i]=rk[a[i]];
		for(int i=1;i<=blen;++i) b[i]=rk[b[i]];
		std::sort(a+1,a+1+alen),std::sort(b+1,b+1+blen);
		int i=1,j=1,las=0;
		ll ans=0;
		while(i<=alen||j<=blen){
			int op,pos;
			if(i>alen||(j<=blen&&b[j]<a[i])) op=2,pos=b[j++];
			else op=1,pos=a[i++];
			int lcl=lcp(las,pos);
			ta.check(lcl),tb.check(lcl);			
			if(op==1) ans+=tb.sum,ta.push(n-sa[pos]+1);
			else ans+=ta.sum,tb.push(n-sa[pos]+1);
			las=pos;
		}
		return ans;
	}
}
int main(void){
	n=read(),q=read();	
	scanf("%s",s+1);
	sa::init();
	while(q--){
		alen=read(),blen=read();
		for(int i=1;i<=alen;++i) a[i]=read();
		for(int i=1;i<=blen;++i) b[i]=read();
		printf("%lld\n",sa::solve());
	}
	return 0;
}

练习题（弱化版本）

[AHOI2013] 差异

[Luogu P7409 SvT](P7409 SvT - 洛谷 | 计算机科学教育新生态 (luogu.com.cn))

[ICPC2020 Nanjing R] Baby's First Suffix Array Problem

详见题解 https://www.luogu.com.cn/article/iwhoyvnj。

# include <bits/stdc++.h>

const int N=500010,INF=0x3f3f3f3f;
const int MX=500000;

inline int read(void){
	int res,f=1;
	char c;
	while((c=getchar())<'0'||c>'9')
		if(c=='-') f=-1;
	res=c-48;
	while((c=getchar())>='0'&&c<='9')
		res=res*10+c-48;
	return res*f;
}

struct Qdata{
	int id,l,r;
};
std::vector <Qdata> Q[N];
std::vector <int> po[N];

int n,m;
char s[N];

int buc[N],sa[N],rk[N],ht[N],id[N],ork[N],mx;

int ans[N];


inline void init_sa(void){
	
	mx=128;
	std::fill(buc+1,buc+1+mx,0);
	
	rk[n+1]=0;
	
	for(int i=1;i<=n;++i) ++buc[rk[i]=s[i]];
	for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
	for(int i=1;i<=n;++i) sa[buc[rk[i]]--]=i;
	
	for(int w=1,cc=0;w<=n;w<<=1,mx=cc,cc=0){
		for(int i=n-w+1;i<=n;++i) id[++cc]=i;
		for(int i=1;i<=n;++i) if(sa[i]>w) id[++cc]=sa[i]-w;
		memset(buc,0,(mx+1)*4);
		memcpy(ork,rk,sizeof(ork));
		for(int i=1;i<=n;++i) ++buc[ork[i]];
		for(int i=1;i<=mx;++i) buc[i]+=buc[i-1];
		for(int i=n;i;--i)
			sa[buc[ork[id[i]]]--]=id[i];

		cc=0;
		for(int i=1;i<=n;++i)
			rk[sa[i]]=(ork[sa[i]]==ork[sa[i-1]]&&ork[sa[i]+w]==ork[sa[i-1]+w])?cc:++cc;
		if(cc==n) break;
	}

	for(int i=1,k=0;i<=n;++i){
		if(k) --k;
		while(s[i+k]==s[sa[rk[i]-1]+k]) ++k;
		ht[rk[i]]=k;
	}
	return;
}

int T1[N],T2[N];

inline int lb(int x){
	return x&(-x);
}
inline void add(int *arr,int x,int v){
	for(;x<=MX;x+=lb(x)) arr[x]+=v;
	return;
}
inline int query(int *arr,int x){
	int ans=0;
	for(;x;x-=lb(x)) ans+=arr[x];
	return ans;
}

int c[N];

int v[N*5],vc;

inline void pl(int x){
	v[++vc]=x;
	return;
}
inline void recalc(void){
	std::sort(v+1,v+1+vc),vc=std::unique(v+1,v+1+vc)-(v+1);
	return;
}
inline int d(int x){
	int ans=std::lower_bound(v+1,v+1+vc,x)-v;
	return assert(v[ans]==x),ans;
}

// id op k x
struct squa{
	int id,op,k,x;
};
//id x
struct tri{
	int id,x;
};
std::vector <squa> S[N];
std::vector <tri> T[N];

void solve(int L,int R){
	if(L==R) return;
	int mid=(L+R)>>1;
	solve(L,mid),solve(mid+1,R);
	
	c[mid+1]=ht[mid+1];
	for(int i=mid+2;i<=R;++i) c[i]=std::min(c[i-1],ht[i]);
	
	int e=n;
	vc=0;
	
	for(int i=mid;i>=L;--i){
		for(auto C:Q[i]){
			int l=C.l,r=C.r;
			l=std::max(C.l,sa[i]+1);
			if(l<=r){
				if(l+e<r) l=r-e;
				pl(l),pl(r+1);
			}
			l=std::max(C.l,std::max(sa[i]+1,r-e+1));
			if(l<=r) pl(l),pl(r+1);
		}
		e=std::min(e,ht[i]);
	}
	for(int i=mid+1;i<=R;++i) pl(sa[i]);
	recalc(),e=n;
	
	for(int i=mid;i>=L;--i){
		for(auto C:Q[i]){
			int l=C.l,r=C.r,id=C.id;
			l=std::max(C.l,sa[i]+1);
			if(l<=r){
				if(l+e<r) l=r-e;
				int dr=d(r+1),dl=d(l);
				S[dr].push_back((squa){id,1,-1,e});
				S[dl].push_back((squa){id,1,1,e});
				T[dl].push_back((tri){id,r});
			}
			l=std::max(C.l,std::max(sa[i]+1,r-e+1));
			if(l<=r){
				int dr=d(r+1),dl=d(l);
				S[dr].push_back((squa){id,2,-1,e});
				S[dl].push_back((squa){id,2,1,e});
			}
		}
		e=std::min(e,ht[i]);
	}
	for(int i=mid+1;i<=R;++i){
		if(c[i]) po[d(sa[i])].push_back(c[i]);
	}
	for(int i=vc;i;--i){
		for(auto p:po[i])
			add(T1,p,1),add(T2,p+v[i],1);
		for(auto C:S[i]){
			int ret=query(T1,C.x);
			if(C.op==2) ret=query(T1,n)-ret;
			ans[C.id]+=C.k*ret;
		}
		for(auto C:T[i]){
			int ret=query(T2,C.x);
			ans[C.id]-=ret;
		}
	}
	
	for(int i=1;i<=vc;++i){
		for(auto p:po[i])
			add(T1,p,-1),add(T2,p+v[i],-1);
		po[i].clear(),T[i].clear(),S[i].clear();
	}
	
	c[mid]=n;
	for(int i=mid-1;i>=L;--i) c[i]=std::min(c[i+1],ht[i+1]);
	e=n,vc=0;
	
	for(int j=mid+1;j<=R;++j){
		for(auto C:Q[j]){
			int l=C.l,r=C.r;
			l=std::max(C.l,sa[j]+1);
			if(l<=r) pl(r+1),pl(l);
			l=C.l,r=std::min(C.r,sa[j]-1);
			if(l<=r) pl(r+1),pl(l);
		}
	}
	for(int i=L;i<=mid;++i) pl(sa[i]);
	recalc();
	
	for(int j=mid+1;j<=R;++j){
		e=std::min(e,ht[j]);
		for(auto C:Q[j]){
			int l=C.l,r=C.r,id=C.id;
			l=std::max(C.l,sa[j]+1);
			if(l<=r){
				int dr=d(r+1),dl=d(l);
				S[dr].push_back((squa){id,1,-1,n});
				S[dl].push_back((squa){id,1,1,n});
			}
			l=C.l,r=std::min(C.r,sa[j]-1);
			if(l<=r){
				int dr=d(r+1),dl=d(l);
				int lim=(e<=C.r-sa[j])?n:C.r-sa[j];
				S[dr].push_back((squa){id,1,-1,lim});
				S[dl].push_back((squa){id,1,1,lim});
			}
		}
	}
	for(int i=L;i<=mid;++i){
		po[d(sa[i])].push_back(c[i]);
	}
	for(int i=vc;i;--i){
		for(auto p:po[i]) add(T1,p+1,1);
		for(auto C:S[i]){
			int ret=query(T1,C.x+1);
			ans[C.id]+=C.k*ret;
		}
	}
	for(int i=1;i<=vc;++i){
		for(auto p:po[i])
			add(T1,p+1,-1);
		po[i].clear(),T[i].clear(),S[i].clear();
	}

	return;
}

inline void mian(void){
	n=read(),m=read();
	scanf("%s",s+1);
	init_sa();	
	for(int i=1;i<=m;++i){
		int l=read(),r=read(),k=read();
		Q[rk[k]].push_back((Qdata){i,l,r});
	}
	solve(1,n);
	for(int i=1;i<=m;++i) printf("%d\n",ans[i]+1),ans[i]=0;
	for(int i=1;i<=n;++i) Q[i].clear();	
	return;
}

int main(void){
//	freopen("in.txt","r",stdin);
	int T=read();
	while(T--) mian();
	return 0;
}

posted @ 2024-05-31 08:51 Meatherm 阅读(18) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 基础字符串

· 初探后缀自动机

· 字符串入门指南

· 「后缀数组」学习笔记

· <学习笔记> 后缀树(数)组

阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 使用C#创建一个MCP客户端
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· ollama系列1：轻松3步本地部署deepseek，普通电脑可用
· 按钮权限的设计及实现

Loading

Meatherm 的奇妙博客

爱看看不看滚喵 (=•ェ•=)