[LOJ 2720][BZOJ 5417][UOJ 395][NOI 2018]你的名字

题意

给定一个大串 $S$ 以及 $q$ 次询问, 每次询问给定一个串 $T$ 和区间 $[l,r]$, 求 $T$ 中有多少本质不同的子串不是 $S[l:r]$ 的子串.

$|S|\le 5\times 10^5,q\le 10^5,\sum|T|\le10^6$.

题解

普通的码农字符串题...

获得成就: $40\texttt{min}(2400\texttt{s})$ 内打完 $3.9\texttt{kB}$ 的代码(然而并没有打完就A...还是太菜了...)

感觉考场上如果T1T2没打满的话写个 $68$ 分沙雕SAM暴力(询问区间都是原串的 $17$ 个测试点)就可以跑路了...分高好写还不用调...

个人的大体思路是: 因为求本质不同子串个数是容易的, 所以先补集转化为求 $T$ 的所有本质不同的子串中是 $S[l:r]$ 的串的个数.

按照套路我们维护一个类似扫描线的东西, 用SAM对 $T$ 的所有下标 $i$ 求出以 $i$ 为右端点且是 $S[l:r]$ 的子串的最长子串长度. 按照SAM的套路, 这部分的计算就是直接用 $T$ 在 $S$ 的SAM上面跑, 如果可以匹配就匹配, 不能匹配跳到后缀自动机的父亲节点上来移动左端点.

按照上面这样计算是对整串来说的. 因为还要考虑区间 $[l,r]$ 的事情, 我们用线段树合并维护出每个结点的right集合, 设当前匹配长度为 $len$, 那么只有当当前状态的right集合与 $[l+len-1,r]$ 有交集才说明与 $S[l:r]$ 匹配. 如果不满足这个条件, 不能按照SAM的普通套路直接跳prt, 而是应该让 $len$ 减少 $1$. 直接跳的话左端点会移动若干个位置, 可能会跳过最优长度. SAM普通套路直接跳prt是因为如果 $len$ 只减少 $1$ 而没有到达prt的长度的话依然没有改变当前状态不能匹配的事实.

然而直接这样计算铁定会有重复, 我们对 $T$ 的反串建SA求出所有前缀的最长公共后缀长度作为去重的参考信息. 按照SA求本质不同子串个数的套路, 重复的子串必然出现在后缀数组上相邻的两个后缀(注意是反串的后缀)上. 假设相邻的两个后缀 $i,j$ 的在原串的对应前缀的最大匹配长度分别是 $mlen_i,mlen_j$ 且它们的LCP是 $height$ 的话, 贡献就是 $mlen_j-\min(height,mlen_i)$.

实际上 $mlen_j$ 肯定不会小于 $\min(height,mlen_i)$, 因为这部分串是完全一样的. 所以直接减就行了.

以前用map的写法被UOJ 64位指针debuff给卡内存了qaq...然而指针线段树依然在被卡内存...UOJ变97分了QAQ

参考代码

之前听说今天minusT要更新Subterranean Rose? 完蛋在学校看不了qaq

#include <bits/stdc++.h>

const int MAXN=1e6+10;

typedef long long intEx;

struct Node{

	int l;

	int r;

	int sum;

	Node* lch;

	Node* rch;

	Node(int,int);

	void Insert(int);

	int Query(int,int);

};

Node* N[MAXN];

int n;

int q;

int cnt=1;

int root=1;

int last=1;

int s[MAXN];

int SA[MAXN];

int len[MAXN];

int prt[MAXN];

int buc[MAXN];

int mlen[MAXN];

char buf[MAXN];

int rank[MAXN];

int height[MAXN];

int chd[MAXN][26];

int* x=new int[MAXN];

int* y=new int[MAXN];

void BuildSAM();

void Extend(char);

void BuildSA(char*,int);

Node* Merge(Node*,Node*);

int main(){

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

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

	scanf("%s",buf+1);

	n=strlen(buf+1);

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

		Extend(buf[i]);

	BuildSAM();

	scanf("%d",&q);

	while(q--){

		int l,r;

		scanf("%s",buf+1);

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

		int m=strlen(buf+1);

		int cur=root,curlen=0;

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

			int x=buf[i]-'a';

			while(cur!=root&&!chd[cur][x]){

				cur=prt[cur];

				curlen=len[cur];

			}

			if(chd[cur][x]){

				++curlen;

				cur=chd[cur][x];

				while(cur!=root&&!N[cur]->Query(l+curlen-1,r)){

					--curlen;

					if(curlen<=len[prt[cur]])

						cur=prt[cur];

				}

			}

			mlen[i]=curlen;

		}

		std::reverse(buf+1,buf+m+1);

		BuildSA(buf,m);

		intEx ans=0;

		int last=0;

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

			ans+=(m-SA[i]+1)-height[i];

			last=std::min(height[i],last);

			ans-=mlen[m-SA[i]+1]-last;

			last=mlen[m-SA[i]+1];

		}

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

	}

	return 0;

}

void BuildSAM(){

	memset(buc,0,sizeof(int)*(n+1));

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

		++buc[len[i]];

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

		buc[i]+=buc[i-1];

	for(int i=cnt;i>=1;i--)

		s[buc[len[i]]--]=i;

	for(int i=cnt;i>=1;i--)

		N[prt[s[i]]]=Merge(N[prt[s[i]]],N[s[i]]);

}

void Extend(char ch){

	int p=last;

	int x=ch-'a';

	int np=++cnt;

	last=np;

	len[np]=len[p]+1;

	N[np]=new Node(1,n);

	N[np]->Insert(len[np]);

	while(p&&!chd[p][x])

		chd[p][x]=np,p=prt[p];

	if(!p)

		prt[np]=root;

	else{

		int q=chd[p][x];

		if(len[q]==len[p]+1)

			prt[np]=q;

		else{

			int nq=++cnt;

			memcpy(chd[nq],chd[q],sizeof(chd[q]));

			N[nq]=new Node(1,n);

			len[nq]=len[p]+1;

			prt[nq]=prt[q];

			prt[q]=nq;

			prt[np]=nq;

			while(p&&chd[p][x]==q)

				chd[p][x]=nq,p=prt[p];

		}

	}

}

void Node::Insert(int x){

	++this->sum;

	if(this->l!=this->r){

		int mid=(this->l+this->r)>>1;

		if(x<=mid){

			if(this->lch==NULL)

				this->lch=new Node(this->l,mid);

			this->lch->Insert(x);

		}

		else{

			if(this->rch==NULL)

				this->rch=new Node(mid+1,this->r);

			this->rch->Insert(x);

		}

	}

}

int Node::Query(int l,int r){

	if(l<=this->l&&this->r<=r)

		return this->sum;

	else{

		int ans=0;

		int mid=(this->l+this->r)>>1;

		if(l<=mid&&this->lch)

			ans+=this->lch->Query(l,r);

		if(mid+1<=r&&this->rch)

			ans+=this->rch->Query(l,r);

		return ans;

	}

}

Node* Merge(Node* a,Node* b){

	if(a==NULL)

		return b;

	if(b==NULL)

		return a;

	Node* N=new Node(a->l,b->r);

	N->sum=a->sum+b->sum;

	N->lch=Merge(a->lch,b->lch);

	N->rch=Merge(a->rch,b->rch);

	return N;

}

void BuildSA(char* s,int n){

	int m=127;

	memset(buc+1,0,sizeof(int)*m);

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

		++buc[x[i]=s[i]];

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

		buc[i]+=buc[i-1];

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

		SA[buc[x[i]]--]=i;

	for(int k=1;k<n;k<<=1){

		int p=0;

		for(int i=n-k+1;i<=n;i++)

			y[++p]=i;

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

			if(SA[i]>k)

				y[++p]=SA[i]-k;

		memset(buc+1,0,sizeof(int)*m);

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

			++buc[x[i]];

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

			buc[i]+=buc[i-1];

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

			SA[buc[x[y[i]]]--]=y[i];

		std::swap(x,y);

		x[SA[1]]=1;

		p=1;

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

			x[SA[i]]=(y[SA[i]]==y[SA[i-1]]&&y[SA[i]+k]==y[SA[i-1]+k])?p:++p;

		if(p>=n)

			break;

		m=p;

	}

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

		rank[SA[i]]=i;

	int k=0;

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

		if(rank[i]==1)

			continue;

		if(k)

			--k;

		int j=SA[rank[i]-1];

		while(i+k<=n&&j+k<=n&&s[i+k]==s[j+k])

			++k;

		height[rank[i]]=k;

	}

}

Node::Node(int l,int r):l(l),r(r),sum(0),lch(NULL),rch(NULL){}