[BJWC2018]Border 的四种求法——SAM+线段树合并+DSU+链分治

Border 的四种求法

给定一个串，q次询问[l,r]的border长度。

思路

首先先对整个串建sam，然后我们对包含r的每一个状态去计算。

设当前状态的最大长度为len，如果一个结束位置i是合法的，当且仅当(lleq i < r)，且(i < l+len)，然后我们需要找到一个最大的i满足这个条件，不难发现此时最暴力的做法就是在parent树上面暴力跳，然后在每个节点endpos集合的线段树上二分查找位置即可。

考虑如何将上面的暴力跳祖先的步骤给优化掉，如果我们可以一次处理一段树上的路径，那么复杂度就更优秀了。

将上面的式子化一下，(l > i-len)，我们对于每一个节点维护一个以i为下标的线段树，每个节点的权值为(i-len)，如果我们要查找l的答案，我们需要找到最大的i满足(i < r)且(i-len < l)，这个也可以在线段树上二分查找来实现。

既然线段树中以i为下标，那么我们完全可以将一条链上的线段树合并，每个节点的权值为(min(i-len))。

这样不难发现每个位置都会在所有祖先的线段树里面出现，这样复杂度就不对了，考虑每个位置的(min(i-len))在什么时候取得，这个len取最大值的时候代表的即r和i的lcp，两个位置的lcp一定是parent树上的lca处取得（越往上面跳len会越小），所以我们可以只在lca处将每个节点加入线段树，也就是r的每一个祖先只计算不包含r的那些子树的endpos集合。

最后考虑如何维护上面的那个“只考虑不包含r的子树的endpos集合”，对于不同的r，显然每一个点考虑的子树是不一样的，为了解决这个问题，便可以用经典的链分治来解决，也就是树链剖分，一条重链上的每一个节点只维护所有轻儿子，然后对于每一条链记录一个前缀线段树，轻边连接的部分我们可以暴力做，重链上的部分直接在前缀线段树上查询即可。

由于至多跳(log n)条重链，所以时间复杂度为(nlog ^2 n)。

/*=======================================
 * Author : ylsoi
 * Time : 2019.3.13
 * Problem : luogu4482
 * E-mail : ylsoi@foxmail.com
 * ====================================*/
#include<bits/stdc++.h>

#define REP(i,a,b) for(int i=a,i##_end_=b;i<=i##_end_;++i)
#define DREP(i,a,b) for(int i=a,i##_end_=b;i>=i##_end_;--i)
#define debug(x) cout<<#x<<"="<<x<<" "
#define fi first
#define se second
#define mk make_pair
#define pb push_back
#define pii pair<int,int>
typedef long long ll;

using namespace std;

void File(){
	freopen("luogu4482.in","r",stdin);
	freopen("luogu4482.out","w",stdout);
}

template<typename T>void read(T &_){
	_=0; T f=1; char c=getchar();
	for(;!isdigit(c);c=getchar())if(c=='-')f=-1;
	for(;isdigit(c);c=getchar())_=(_<<1)+(_<<3)+(c^'0');
	_*=f;
}

string proc(){
	ifstream f("/proc/self/status");
	return string(istreambuf_iterator<char>(f),istreambuf_iterator<char>());
}


const int maxn=4e5+10;
const int inf=0x3f3f3f3f;
int n,q,mp[maxn];
char str[maxn];
vector<int>G[maxn];

namespace Suf{
	int ch[maxn][26],len[maxn],fa[maxn],pos[maxn],last=1,cnt=1;
	void insert(int x,int y){
		int p=last,np=last=++cnt;
		len[np]=len[p]+1;
		pos[np]=y,mp[y]=np;
		while(p && !ch[p][x])ch[p][x]=np,p=fa[p];
		if(!p)fa[np]=1;
		else{
			int q=ch[p][x];
			if(len[q]==len[p]+1)fa[np]=q;
			else{
				int nq=++cnt;
				memcpy(ch[nq],ch[q],sizeof(ch[nq]));
				len[nq]=len[p]+1,fa[nq]=fa[q];
				fa[q]=fa[np]=nq;
				while(p && ch[p][x]==q)ch[p][x]=nq,p=fa[p];
			}
		}
	}
}

using Suf::len;
using Suf::fa;
using Suf::pos;

namespace Tree{
	int tp[maxn],son[maxn],sz[maxn];
	void dfs1(int u){
		sz[u]=1;
		for(int v:G[u]){
			dfs1(v);
			sz[u]+=sz[v];
			if(sz[v]>sz[son[u]])son[u]=v;
		}
	}
	void dfs2(int u,int t){
		tp[u]=t;
		if(son[u])dfs2(son[u],t);
		for(int v:G[u])if(v!=son[u])
			dfs2(v,v);
	}
}

using Tree::tp;
using Tree::son;

namespace Smt{
#define mid ((l+r)>>1)
	int mn[maxn<<5],ch[maxn<<5][2],root[maxn],cnt;
	void insert(int &o,int l,int r,int p,int x){
		if(!o)o=++cnt;
		mn[o]=min(mn[o],x);
		if(l==r)return;
		else{
			if(p<=mid)insert(ch[o][0],l,mid,p,x);
			else insert(ch[o][1],mid+1,r,p,x);
		}
	}
	int query(int o,int l,int r,int R,int x){
		if(l>R || (r<=R && mn[o]>x))return -inf;
		if(l==r)return l;
		else{
			int ret=query(ch[o][1],mid+1,r,R,x);
			if(ret!=-inf)return ret;
			return query(ch[o][0],l,mid,R,x);
		}
	}
#undef mid
}

using Smt::root;
using Smt::insert;
using Smt::query;

set<int>st[maxn];
pii qu[maxn];
int ans[maxn];
vector<int>lis[maxn];

void dfs(int u,int o){
	if(pos[u])insert(root[o],1,n,pos[u],pos[u]-len[o]);
	for(int v:G[u])dfs(v,o);
}

void solve(int u){
	if(son[fa[u]]==u)root[u]=root[fa[u]];
	for(int id:lis[u])ans[id]=max(ans[id],query(root[u],1,n,qu[id].se-1,qu[id].fi-1));

	for(int v:G[u])if(v!=son[u])dfs(v,u);
	if(pos[u])insert(root[u],1,n,pos[u],pos[u]-len[u]),st[u].insert(pos[u]);

	for(int v:G[u]){
		solve(v);
		if(st[u].size()<st[v].size())swap(st[u],st[v]);
		for(int x:st[v])st[u].insert(x);
	}

	for(int id:lis[u]){
		auto it=st[u].lower_bound(min(qu[id].fi+len[u],qu[id].se));
		if(it!=st[u].begin()){
			--it;
			ans[id]=max(ans[id],*it);
		}
	}
}

int main(){
	File();

	using Suf::insert;
	scanf("%s",str+1);
	n=strlen(str+1);
	REP(i,1,n)insert(str[i]-'a',i);

	REP(i,2,Suf::cnt)G[fa[i]].pb(i);
	Tree::dfs1(1);
	Tree::dfs2(1,1);

	memset(Smt::mn,63,sizeof(Smt::mn));

	read(q);
	REP(i,1,q){
		read(qu[i].fi),read(qu[i].se);
		int u=mp[qu[i].se];
		while(u){
			lis[u].pb(i);
			u=fa[tp[u]];
		}
		ans[i]=qu[i].fi-1;
	}

	solve(1);

	REP(i,1,q)printf("%d
",ans[i]-qu[i].fi+1);

	cerr<<proc()<<endl;
	return 0;
}