2021CCPC(桂林) - Suffix Automaton(后缀树+线段树)

Posted 2021-12-09 Frozen_Guardian

题目大意：给出一个长度为 $n$ 的字符串，再给出 $q$ 次询问，每次询问需要输出本质不同第 $k$ 小的子串的起止位置。如果有多个答案，输出起点最小的那个。

本题规定字符串大小的比较规则如下：

1. 首先按照长度排序
2. 长度相同的情况下，按字典序排序

题目大意：

首先还是利用后缀自动机将后缀树建出来，此时长度为 $d$ 的本质不同的子串，可以用深度为 $d$ 的所有节点集合表示出来。

因为后缀树上的边都是经过压缩的，所以每条边实质上代表的是许多连续的前缀。

所以我们需要枚举深度 $d$，利用差分数组，类比于扫描线的思想，维护一下当前深度所有节点。

上面只是讨论了深度不同的情况，对于深度相同的情况，可以参考题目 HDU - 5008 Boring String Problem(后缀树求本质不同第k大子串) ，跑出后缀树的 $dfs$ 序，不难发现对于同层的节点来说，$dfs$ 序更小的节点对应着字典序更小。

更具体的，我们需要维护一个数据结构，可以满足下面的条件：

1. 维护一个线性表
2. 按照 $dfs$ 序排序
3. 支持插入/删除一个元素
4. 支持查询第 $k$ 小的元素
5. 支持实时统计元素个数

通过分析之后可以发现上面的数据结构可以用平衡树来写，也可以用线段树来写。

然后将询问离线下来，码就完事了，时间复杂度是 $O((n+q)\log n)$

代码：（只过了样例，等题目上传到 gym 后会更新）

// #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=1e6+100;
char s[N];
vector<int>node[N<<1];
int tot,last,endpos[N<<1];
int dfn[N<<1],rk[N<<1],cnt;
vector<int>delta[N];
pair<LL,int>q[N];
int ansl[N],ansr[N];
namespace SEG {
	struct Node {
		int l,r,sum;
	}tree[N<<1<<2];
	void pushup(int k) {tree[k].sum=tree[k<<1].sum+tree[k<<1|1].sum;}
	void build(int k,int l,int r) {
		tree[k]={l,r,0};
		if(l==r) return;
		int mid=(l+r)>>1;
		build(k<<1,l,mid),build(k<<1|1,mid+1,r);
	}
	void update(int k,int pos,int val) {
		if(tree[k].l==tree[k].r) {tree[k].sum=val;return;}
		int mid=(tree[k].l+tree[k].r)>>1;
		if(pos<=mid) update(k<<1,pos,val);
		else update(k<<1|1,pos,val);
		pushup(k);
	}
	int query(int k,int x) {
		if(tree[k].l==tree[k].r) {return tree[k].l;}
		if(x<=tree[k<<1].sum) return query(k<<1,x);
		else return query(k<<1|1,x-tree[k<<1].sum);
	}
	void push(int x) {update(1,dfn[x],1);}
	int kth(int k) {return rk[query(1,k)];}
	void pop(int x) {update(1,dfn[x],0);}
	int size() {return tree[1].sum;}
}
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;
	endpos[tot]=0;
	node[tot].clear();
	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_pos(int u) {
	for(auto v:node[u]) {
		dfs_pos(v);
		endpos[u]=max(endpos[u],endpos[v]);
	}
}
void dfs(int u) {
	dfn[u]=++cnt;
	rk[cnt]=u;
	vector<pair<char,int>>son;
	for(auto v:node[u]) {
		son.push_back({s[endpos[v]-st[u].len],v});
	}
	sort(son.begin(),son.end());
	for(auto it:son) {
		int v=it.second;
		delta[st[u].len+1].push_back(v);
		delta[st[v].len+1].push_back(-v);
		dfs(v);
	}
}
void build() {
	for(int i=1;i<=tot;i++) {
		node[st[i].fa].push_back(i);
	}
	dfs_pos(1);
	dfs(1);
}
void init() {
	last=1;
	cnt=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);
	scanf("%s",s+1);
	init();
	int n=strlen(s+1);
	reverse(s+1,s+1+n);
	for(int i=1;i<=n;i++) {
		add(s[i]-'a');
		endpos[last]=i;
	}
	build();
	int m;
	scanf("%d",&m);
	for(int i=1;i<=m;i++) {
		read(q[i].first);
		q[i].second=i;
		ansl[i]=ansr[i]=-1;
	}
	sort(q+1,q+1+m);
	LL sum=0;
	int p=1;
	SEG::build(1,1,tot);
	for(int d=1;d<=n;d++) {//deep
		for(auto it:delta[d]) {
			if(it>0) {
				SEG::push(it);
			} else {
				SEG::pop(-it);
			}
		}
		LL pre=sum;
		sum+=SEG::size();
		while(p<=m&&q[p].first>pre&&q[p].first<=sum) {
			int k=q[p].first,id=q[p].second;
			int u=SEG::kth(k-pre);
			ansl[id]=n-endpos[u]+1;
			ansr[id]=ansl[id]+d-1;
			p++;
		}
	}
	for(int i=1;i<=m;i++) {
		printf("%d %d\\n",ansl[i],ansr[i]);
	}
	return 0;
}