【十二省联考2019】字符串问题【后缀自动机】【拓扑排序】

题意：给一个字符串 $S$，以子串的形式给出一些 A 类串和 B 类串以及 $m$ 对 A 类串支配 B 类串的关系。求一个总长度最长的 A 类串序列，使得每个串都存在一个 B 类串前缀被后一个串支配。无穷输出 $-1$。

$|S|,m\le 2\times 10^5$

显然需要先把反串 SAM 建出来，然后树上倍增定位每个子串。

对于每一步，相当于是可以不断丢掉最后一个字符变成前缀，如果是个 B 类串，可以走到一个被支配的 A 类串。

所以 SAM 上每个点向 fail 树上的父亲连一条 $0$ 的边， $u$ 支配 $v$ 就从 $v$ 往 $u$ 连 $|u|$ 的边。然后拓扑排序后做最长路即可。因为没有 $0$ 环，也没有不联通等奇奇怪怪的东西，所以有环就是 $-1$。

然后这道题就做完了……

才怪。你的 A，B 类串定位的是一类子串，而限制是死的。具体来说，一个 B 类串定位到了某个结点的一坨子串上，然后一个 A 类串定位也定位到了这个结点，而且还比 B 类串短，那么它是不能走到这个 B 的。但是 SAM 上它们是同一个结点，所以上面的算法就会出错。

怎么办？拆了呗

当然不用真的拆了，把这些定位的点放结点的 vector 里，然后在内部排序建一下就可以了。

不算难写，单纯的码量大。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cctype>
#include <vector>
#include <utility>
#include <queue>
#include <algorithm>
#define MAXN 800005
#define MAXM 1200005
using namespace std;
typedef long long ll;
inline int read()
{
	int ans=0;
	char c=getchar();
	while (!isdigit(c)) c=getchar();
	while (isdigit(c)) ans=(ans<<3)+(ans<<1)+(c^48),c=getchar();
	return ans;
}
char s[MAXN];
int ch[MAXN][26],len[MAXN],fa[MAXN],las=1,tot=1;
void insert(int c)
{
	int cur=++tot;
	len[cur]=len[las]+1;
	int p=las;
	for (;p&&!ch[p][c];p=fa[p]) ch[p][c]=cur;
	if (!p) fa[cur]=1;
	else
	{
		int q=ch[p][c];
		if (len[q]==len[p]+1) fa[cur]=q;
		else
		{
			int _q=++tot;
			len[_q]=len[p]+1;
			fa[_q]=fa[q],fa[cur]=fa[q]=_q;
			memcpy(ch[_q],ch[q],sizeof(ch[_q]));
			for (;p&&ch[p][c]==q;p=fa[p]) ch[p][c]=_q;
		}
	}
	las=cur;
}
int up[MAXN][20];
inline void build()
{
	for (int i=1;i<=tot;i++) up[i][0]=fa[i];
	for (int j=1;j<20;j++)
		for (int i=1;i<=tot;i++)
			up[i][j]=up[up[i][j-1]][j-1];
}
inline int find(int x,int l)
{
	for (int i=19;i>=0;i--)
		if (len[up[x][i]]>=l)
			x=up[x][i];
	return x;
}
int na,nb,la[MAXN],lb[MAXN],ra[MAXN],rb[MAXN];
struct node
{	
	int idx,type;
	inline int len()const{return type? ra[idx]-la[idx]+1:rb[idx]-lb[idx]+1;}
	inline int pos()const
	{
		if (type==1) return tot+idx;
		if (type==0) return tot+na+idx;
		return idx;
	}
};
inline bool operator <(const node& a,const node& b){return a.len()<b.len()||(a.len()==b.len()&&a.type<b.type);}
vector<node> lis[MAXN];
struct edge{int u,v,w;}e[MAXM];
int head[MAXN],nxt[MAXM],deg[MAXN],cnt;
inline void addnode(int u,int v,int w)
{
	e[++cnt]=(edge){u,v,w};
	nxt[cnt]=head[u];
	head[u]=cnt;
	++deg[v];
}
int pos[MAXN],dfn[MAXN],tim;
ll dp[MAXN];
int q[MAXN],qs,qt;
void clear()
{
	for (int i=1;i<=tot;i++) 
	{
		memset(ch[i],0,sizeof(ch[i])),fa[i]=len[i]=0;
		memset(up[i],0,sizeof(up[i]));
		vector<node>().swap(lis[i]);
	}
	for (int i=1;i<=tot+na+nb+1;i++) head[i]=deg[i]=dp[i]=0;
	for (int i=1;i<=cnt;i++) nxt[i]=0;
	tim=cnt=0,las=tot=1;
}
int main()
{
	for (int T=read();T;T--)
	{
		scanf("%s",s+1);
		int n=strlen(s+1);
		for (int i=n;i>=1;i--) insert(s[i]-'a'),pos[i]=las;
		build();	
		na=read();
		for (int i=1;i<=na;i++)
		{
			la[i]=read(),ra[i]=read();
			lis[find(pos[la[i]],ra[i]-la[i]+1)].push_back((node){i,1});
		}
		nb=read();
		for (int i=1;i<=nb;i++)
		{
			lb[i]=read(),rb[i]=read();
			lis[find(pos[lb[i]],rb[i]-lb[i]+1)].push_back((node){i,0});
		}
		for (int i=1;i<=tot;i++) 
		{
			sort(lis[i].begin(),lis[i].end());
			lis[i].push_back((node){i,-1});
			if (fa[i]) addnode(lis[i].front().pos(),fa[i],0);
			for (int j=0;j<(int)lis[i].size()-1;j++) 
				addnode(lis[i][j+1].pos(),lis[i][j].pos(),0);
		}
		for (int m=read();m;m--)
		{
			int u,v;
			u=read(),v=read();
			addnode(tot+na+v,tot+u,ra[u]-la[u]+1);
		}
		int S=tot+na+nb+1;
		for (int i=1;i<=na;i++) addnode(S,tot+i,ra[i]-la[i]+1);
		qs=1,qt=0;
		for (int i=1;i<=S;i++) if (!deg[i]) q[++qt]=i;
		while (qs<=qt)
		{
			int u=dfn[++tim]=q[qs++];
			for (int i=head[u];i;i=nxt[i])
				if (!(--deg[e[i].v]))
					q[++qt]=e[i].v;
		}
		if (tim<S) puts("-1");
		else
		{
			for (int k=S;k>=1;k--)
			{
				int u=dfn[k];
				for (int i=head[u];i;i=nxt[i])
					dp[u]=max(dp[u],dp[e[i].v]+e[i].w);
			}
			printf("%lld\n",dp[S]);
		}
		clear();
	}
	return 0;
}