HDU - 7091 重叠的子串(后缀自动机+set启发式合并+树上倍增)

Posted 2021-09-08 Frozen_Guardian

题目链接：点击查看

题目大意：给定一个只含小写字母的字符串 $s$ 和 $q$ 次询问，每次询问给定一个字符串，以 $s[l..r]$ 的形式给出，判断 $s$ 中是否存在两个或多个出现的有重叠部分的给定子串。比如在 $“ababa”$ 中，两个 $“aba”$ 子串就重叠于中间的字母 $“a”$，而两个 $“ab”$ 子串就没有发生重叠。$T$ 组数据。

题目分析：对字符串 $s$ 建立 $SAM$ 然后建出 $parerent$ 树，问题就转换为了子串 $s[l:r]$ 所在的节点，是否存在着相邻的两个 $endpos$ 距离小于 $r-l+1$

针对上面的问题，可以用 $set$ 启发式合并预处理出任意一个节点中相邻两个 $endpos$ 的最小值，时间复杂度是 $O(nlo{g}^{2}n)$ 的

对于每次查询，我们只需要从 $s[1:r]$ 不断跳 $father$ 直到 $s[l:r]$ 所在的区间就可以了，这里可以用树上倍增优化，时间复杂度是 $O(qlogn)$ 的

代码：

// Problem: 重叠的子串
// Contest: HDOJ
// URL: https://acm.hdu.edu.cn/showproblem.php?pid=7091
// Memory Limit: 524 MB
// Time Limit: 20000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

// #pragma GCC optimize(2)
// #pragma GCC optimize("Ofast","inline","-ffast-math")
// #pragma GCC target("avx,sse2,sse3,sse4,mmx")
#include<iostream>
#include<cstdio>
#include<string>
#include<ctime>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<stack>
#include<climits>
#include<queue>
#include<map>
#include<set>
#include<sstream>
#include<cassert>
#include<bitset>
#include<list>
#include<unordered_map>
#define lowbit(x) (x&-x)
using namespace std;
typedef long long LL;
typedef unsigned long long ull;
template<typename T>
inline void read(T &x)
{
	T f=1;x=0;
	char ch=getchar();
	while(0==isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
	while(0!=isdigit(ch)) x=(x<<1)+(x<<3)+ch-'0',ch=getchar();
	x*=f;
}
template<typename T>
inline void write(T x)
{
	if(x<0){x=~(x-1);putchar('-');}
    if(x>9)write(x/10);
    putchar(x%10+'0');
}
const int inf=0x3f3f3f3f;
const int N=1e5+100;
char s[N];
int tot,last,dp[N<<1][20],val[N<<1],pos[N];
vector<int>node[N<<1];
set<int>endpos[N<<1];
struct Node
{
    int ch[26];
    int fa,len;
}st[N<<1];
inline int newnode()
{
	tot++;
	for(int i=0;i<26;i++)
		st[tot].ch[i]=0;
	st[tot].fa=st[tot].len=0;
	node[tot].clear(),endpos[tot].clear();
	val[tot]=inf;
	return tot;
}
void add(int x)
{
    int p=last,np=last=newnode();
    st[np].len=st[p].len+1;
    while(p&&!st[p].ch[x])st[p].ch[x]=np,p=st[p].fa;
    if(!p)st[np].fa=1;
    else
    {
        int q=st[p].ch[x];
        if(st[p].len+1==st[q].len)st[np].fa=q;
        else
        {
            int nq=newnode();
            st[nq]=st[q]; st[nq].len=st[p].len+1;
            st[q].fa=st[np].fa=nq;
            while(p&&st[p].ch[x]==q)st[p].ch[x]=nq,p=st[p].fa;//向上把所有q都替换成nq
        }
    }
}
void dfs(int u,int fa) {
	dp[u][0]=fa;
	for(int i=1;i<20;i++) {
		dp[u][i]=dp[dp[u][i-1]][i-1];
	}
	for(auto v:node[u]) {
		dfs(v,u);
		val[u]=min(val[u],val[v]);
		if(endpos[u].size()<endpos[v].size()) {
			swap(endpos[u],endpos[v]);
		}
		for(auto it:endpos[v]) {
			auto itt=endpos[u].lower_bound(it);
			if(itt!=endpos[u].end()) {
				val[u]=min(val[u],*itt-it);
			}
			if(itt!=endpos[u].begin()) {
				itt--;
				val[u]=min(val[u],it-*itt);
			}
			endpos[u].insert(it);
		}
	}
}
void build() {
	for(int i=1;i<=tot;i++) {
		node[st[i].fa].push_back(i);
	}
	dfs(1,0);
}
int get_fa(int u,int len) {
	for(int i=19;i>=0;i--) {
		if(st[dp[u][i]].len>=len) {
			u=dp[u][i];
		}
	}
	return u;
}
void init()
{
	last=1;
	tot=0;
	newnode();
}
int main()
{
#ifndef ONLINE_JUDGE
//	freopen("data.in.txt","r",stdin);
//	freopen("data.out.txt","w",stdout);
#endif
//	ios::sync_with_stdio(false);
	int w;
	cin>>w;
	while(w--) {
		init();
		int n,m;
		scanf("%d%d%s",&n,&m,s+1);
		for(int i=1;i<=n;i++) {
			add(s[i]-'a');
			pos[i]=last;
			endpos[last].insert(i);
		}
		build();
		while(m--) {
			int l,r;
			scanf("%d%d",&l,&r);
			int len=r-l+1;
			int fa=get_fa(pos[r],len);
			if(val[fa]<len) {
				puts("Yes");
			} else {
				puts("No");
			}
		}
	}
	return 0;
}