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

Posted 2022-12-08 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)$

2021.11.14 UPDATE：

Memory limit exceeded on test 11，是我写的太丑了么。

2021.11.14 RE-UPDATE：

卡了卡内存A掉了，具体体现在 dfs 里少了一个 vector。

代码：（只过了样例，等题目上传到 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+5;
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;
	sort(node[u].begin(),node[u].end(),[&](int x,int y) 
		return s[endpos[x]-st[u].len]<s[endpos[y]-st[u].len];
	);
	for(auto v:node[u]) 
		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) 
			LL k=q[p].first;
			int 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;