【NOI2018】君の名は（后缀自动机，线段树）

题面——[NOI2018] 你的名字

题目背景

实力强大的小 A 被选为了 ION2018 的出题人，现在他需要解决题目的命名问题。

题目描述

小 A 被选为了 ION2018 的出题人，他精心准备了一道质量十分高的题目，且已经把除了题目命名以外的工作都做好了。

由于 ION 已经举办了很多届，所以在题目命名上也是有规定的，ION 命题手册规定：每年由命题委员会规定一个小写字母字符串，我们称之为那一年的命名串，要求每道题的名字必须是那一年的命名串的一个非空连续子串，且不能和前一年的任何一道题目的名字相同。

由于一些特殊的原因，小 A 不知道 ION2017 每道题的名字，但是他通过一些特殊手段得到了 ION2017 的命名串，现在小 A 有 $Q$ 次询问：每次给定 ION2017 的命名串和 ION2018 的命名串，求有几种题目的命名，使得这个名字一定满足命题委员会的规定，即是 ION2018 的命名串的一个非空连续子串且一定不会和 ION2017 的任何一道题目的名字相同。

由于一些特殊原因，所有询问给出的 ION2017 的命名串都是某个串的连续子串，详细可见输入格式。

输入格式

第一行一个字符串 $S$ ，之后询问给出的 ION2017 的命名串都是 $S$ 的连续子串。
第二行一个正整数 $Q$，表示询问次数。
接下来 $Q$ 行，每行有一个字符串 $T$ 和两个正整数$l,r$，表示询问如果 ION2017 的命名串是 $S_{l\dots r}$，ION2018 的命名串是 $T$ 的话，有几种命名方式一定满足规定。

输出格式

输出 $Q$ 行，第 $i$ 行一个非负整数表示第 $i$ 个询问的答案。

样例 #1

样例输入 #1

scbamgepe
3
smape 2 7
sbape 3 8
sgepe 1 9

样例输出 #1

12
10
4

提示

数据范围

测试点	$|S|\le$	$Q\le$	$\sum |T|\le$	其他限制
$1$	$200$	$200$	$40000$	$T\le 200$
$2$	$1000$	$200$	$40000$	$T\le 200$
$3$	$1000$	$200$	$40000$	$T\le 200$
$4$	$1000$	$200$	$5\times 10^5$	无
$5$	$1000$	$200$	$5\times 10^5$	无
$6$	$5\times 10^5$	$1$	$5\times 10^5$	无
$7$	$5\times 10^5$	$1$	$5\times 10^5$	无
$8$	$10^5$	$10^5$	$2\times 10^5$	无
$9$	$10^5$	$10^5$	$2\times 10^5$	字符串随机
$10$	$2\times 10^5$	$10^5$	$4\times 10^5$	无
$11$	$2\times 10^5$	$10^5$	$4\times 10^5$	字符串随机
$12$	$3\times 10^5$	$10^5$	$6\times 10^5$	无
$13$	$3\times 10^5$	$10^5$	$6\times 10^5$	字符串随机
$14$	$4\times 10^5$	$10^5$	$8\times 10^5$	无
$15$	$4\times 10^5$	$10^5$	$8\times 10^5$	字符串随机
$16$	$5\times 10^5$	$10^5$	$10^6$	无
$17$	$5\times 10^5$	$10^5$	$10^6$	字符串随机
$18$	$2\times 10^5$	$10^5$	$10^6$	无
$19$	$3\times 10^5$	$10^5$	$10^6$	无
$20$	$4\times 10^5$	$10^5$	$10^6$	无
$21$	$5\times 10^5$	$10^5$	$10^6$	无
$22$	$5\times 10^5$	$10^5$	$10^6$	无
$23$	$5\times 10^5$	$10^5$	$10^6$	无
$24$	$5\times 10^5$	$10^5$	$10^6$	无
$25$	$5\times 10^5$	$10^5$	$10^6$	无

对于前 $17$ 个测试点的所有询问有 $l=1,r=|S|$。

对于所有数据，保证 $1\le l\le r\le |S|$,$1\le |T|\le 5\times 10^5$。

题解

简述题意：给定一个模板串 $S$，多组询问，每次给出一个询问字符串 $T$ 和一个区间 $[l,r]$，要求你输出 $T$ 有多少个本质不同的子串，满足这个子串没有在 $S$ 的 $[l,r]$ 这段区间当中出现。

我们可以把每一个串的贡献放到右端点处统计。容易发现，对于 $T$ 的每个前缀，与之前的前缀以及 $S$ 串重复的部分恰好是长度不超过某个值的所有后缀。所以我们可以对于 $T$ 的每个前缀求出这个长度值。该长度值等于 $\max (与T前面重复的长度,与S重复的长度)$ 。我们先对于每个 $T$ 用后缀自动机求出前一个值，再考虑统一求出后一个值。

对于全串的想法肯定是经典的在后缀自动机上跑，但是如果是子串 $[l,r]$ 的话，我们得模拟出这个子串的 SAM 。通过维护 $endpos$ 集合可以判断 $S$ 串的 SAM 每个节点在 $[l,r]$ 中的 $length$ 元素。

维护 $endpos$ 集合其实只需要维护其中的最大值，所以维护时 $[l,r]$ 的区间限制可以等价于 $[1,r]$，我们把询问离线放在右端点上，用扫描线扫 $S$ 。建出后缀树，根据 dfs 序建出线段树维护 $endpos$ 的最大值。

原本经典的匹配方法，只需要判断失配，然后跳 $fail$ ，但是由于 $length$ 实际上会根据 $endpos$ 变化，所以不能直接跳，可能会跳过。我们失配时只需要将当前匹配长度 $ml$ 减一，直到与父亲的 $length$ 相等的时候再跳。匹配的条件是存在对应出边 $\to y$ ，并且 $(\max endpo{s}_y)-ml\ge l$ ，即 $lm$ 对于出边的 $y$ 是在区间 $[l,r]$ 内合理的。

时间复杂度 $O(\sum |T|\log |S|)$ 。

CODE

原本以为为了防止每次从 $n$ 退到 $1$ ，需要在后缀树上进行倍增处理。结果不需要😅

#include<map>
#include<set>
#include<cmath>
#include<ctime>
#include<queue>
#include<stack>
#include<random>
#include<bitset>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<unordered_map>
// #pragma GCC optimize(2)
// #pragma GCC optimize("Ofast")
using namespace std;
#define MAXN 1000005
#define LL long long
#define ULL unsigned long long
#define ENDL putchar('\n')
#define DB double
#define lowbit(x) (-(x) & (x))
#define FI first
#define SE second
int xchar() {
	static const int maxn = 1000000;
	static char b[maxn];
	static int pos = 0,len = 0;
	if(pos == len) pos = 0,len = fread(b,1,maxn,stdin);
	if(pos == len) return -1;
	return b[pos ++];
}
// #define getchar() xchar()
LL read() {
	LL f = 1,x = 0;int s = getchar();
	while(s < '0' || s > '9') {if(s<0)return -1;if(s=='-')f=-f;s = getchar();}
	while(s >= '0' && s <= '9') {x = (x<<1) + (x<<3) + (s^48);s = getchar();}
	return f*x;
}
void putpos(LL x) {if(!x)return ;putpos(x/10);putchar((x%10)^48);}
void putnum(LL x) {
	if(!x) {putchar('0');return ;}
	if(x<0) putchar('-'),x = -x;
	return putpos(x);
}
void AIput(LL x,int c) {putnum(x);putchar(c);}

int n,m,s,o,k;
char ss[MAXN],T[MAXN];
int le[MAXN];
vector<char> tt[MAXN];
vector<int> pr[MAXN];
struct SAM{
    int s[26],len,fa;
    SAM(){memset(s,0,sizeof(s));len=fa=0;}
}sam[MAXN];
int las = 1,cnt = 1;
int addsam(int c) {
    int p = las,np = (las = ++ cnt);
    sam[np] = SAM(); sam[np].len = sam[p].len + 1;
    for(;p&&!sam[p].s[c];p=sam[p].fa) sam[p].s[c]=np;
    if(!p) sam[np].fa = 1;
    else {
        int q = sam[p].s[c];
        if(sam[q].len == sam[p].len + 1) sam[np].fa = q;
        else {
            int nq = ++ cnt; sam[nq] = sam[q];
            sam[nq].len = sam[p].len + 1;
            sam[np].fa = sam[q].fa = nq;
            for(;p&&sam[p].s[c]==q;p=sam[p].fa) sam[p].s[c]=nq;
        }
    }return np;
}
vector<int> g[MAXN];
int id[MAXN],l[MAXN],r[MAXN];
int tim;
int dfn[MAXN],rr[MAXN],f[MAXN][20];//19
void dfs(int x,int ff) {
    f[x][0] = ff; dfn[x] = ++ tim;
    for(int i = 1;i <= 19;i ++) f[x][i] = f[f[x][i-1]][i-1];
    for(int &y:g[x]) dfs(y,x);
    rr[x] = tim; return ;
}
int tre[MAXN<<2],M;
void maketree(int n) {M=1;while(M<n+2)M<<=1;}
void addtree(int x,int y) {for(int s=M+x;s;s>>=1)tre[s] = max(tre[s],y);}
int findtree(int l,int r) {
    int as = 0; if(l > r) return as;
    for(int s=M+l-1,t=M+r+1;(s>>1)^(t>>1);s>>=1,t>>=1) {
        if(!(s&1)) as = max(as,tre[s^1]);
        if(t & 1) as = max(as,tre[t^1]);
    } return as;
}
int RR(int x) {return findtree(dfn[x],rr[x]);}
vector<int> bu[MAXN];
LL as[MAXN];
int main() {
    scanf("%s",ss + 1);
    n = strlen(ss + 1);
    m = read();
    for(int i = 1;i <= m;i ++) {
        scanf("%s",T + 1);
        k = strlen(T + 1);
        l[i] = read(); r[i] = read(); bu[r[i]].push_back(i);
        le[i] = k; sam[las=cnt=1] = SAM();
        for(int j = 1;j <= k;j ++) {
            tt[i].push_back(T[j]);
            int p = addsam(T[j]-'a');
            pr[i].push_back(sam[sam[p].fa].len);
        }
    }
    sam[las=cnt=1] = SAM();
    for(int i = 1;i <= n;i ++) {
        id[i] = addsam(ss[i]-'a');
    }
    for(int i = 2;i <= cnt;i ++) g[sam[i].fa].push_back(i);
    dfs(1,0); maketree(tim);
    for(int ii = 1;ii <= n;ii ++) {
        addtree(dfn[id[ii]],ii);
        for(int &i:bu[ii]) {
            // printf("%d:\n",i);
            int p = 1,ll = 0; s = l[i]; o = r[i];
            for(int j = 0;j < le[i];j ++) {
                int c = tt[i][j]-'a';
                // if(p > 1 && sam[sam[p].fa].len >= ll) {
                //     for(int k = 19;k >= 0;k --) {
                //         if(f[p][k] && sam[f[p][k]].len >= ll) p = f[p][k];
                //     }
                // }
                while(p > 1 && (!sam[p].s[c] || RR(sam[p].s[c])-ll < s)) {
                    if(ll <= sam[sam[p].fa].len) p = sam[p].fa;
                    else ll = max(0,ll-1);
                    if(ll <= sam[sam[p].fa].len) p = sam[p].fa;
                }
                if(sam[p].s[c] && RR(sam[p].s[c])-ll >= s) p = sam[p].s[c],ll ++;
                ll = min(ll,min(sam[p].len,RR(p)-s+1));
                as[i] += (j+1) - max(ll,pr[i][j]);
                // printf("    %d: %d(%d)\n",j+1,max(ll,pr[i][j]),p);
            }
        }
    }
    for(int i = 1;i <= m;i ++) {
        AIput(as[i],'\n');
    }
    return 0;
}