【洛谷4770/UOJ395】[NOI2018]你的名字（后缀数组_线段树合并）
题目：
分析：
一个很好的SAM应用题……
一句话题意：给定一个字符串\(S\)。每次询问给定字符串\(T\)和两个整数\(l\)、\(r\)，求\(T\)有多少个本质不同的非空子串不是\(S[l,r]\)的子串。
首先显然是“正难则反”，求有多少个本质不同的非空子串是\(S[l,r]\)的子串（下面的“答案”一词指的是这个值）。先考虑没有\(l\)和\(r\)限制的情况。分别处理询问。对于\(S\)建出后缀自动机。枚举\(T\)的所有前缀，在\(S\)的后缀自动机上走（匹配）。每个前缀对答案的贡献就是这个前缀有多少后缀出现在\(S\)中，即当前在后缀自动机上匹配的深度。
但是直接把所有贡献都加起来是错的，因为没有保证本质不同。于是对\(T\)也建出后缀自动机，不统计每个前缀的贡献，而是统计每个结点的贡献，即统计每个结点对应的本质不同的字符串中有多少个在\(S\)中出现。记\(lim[i]\)为\(T\)的前缀\(i\)有多少个后缀在\(S\)中出现，那么一个结点\(p\)的贡献就是\(max(0,min(lim[i],max[p])-max[fa[p]])\)，其中\(i\)是\(p\)的\(Right\)集合中的任意一个点。由于以\(Right\)集合中任意一点结尾的，长度不超过\(max[p]\)的子串都是相同的，所以\(i\)的选取不会影响\(min(lim[i],max[p])\)的值。
至于带\(l\)和\(r\)限制的情况，用线段树合并求出\(S\)的后缀自动机上每个结点的\(Right\)集合。\(T\)在\(S\)的后缀自动机上匹配时，要查询要走到的结点的\(Right\)集合与\([l+len,r]\)的交集是否非空（\(len\)是当前匹配长度，即查询是否有一个长为\(len+1\)的子串在\(S[l,r]\)中出现过）。
代码：
统计答案的时候直接算了这个结点对应的字符串中有多少个不是\(S[l,r]\)的子串，因此式子和上面分析的略有不同。
#include <cstdio>
#include <algorithm>
#include <cctype>
#include <cstring>
#include <string>
#define _ 0
using namespace std;
namespace zyt
{
const int N = 5e5 + 10, B = 20;
template<typename T>
inline bool read(T &x)
{
char c;
bool f = false;
x = 0;
do
c = getchar();
while (c != EOF && c != '-' && !isdigit(c));
if (c == EOF)
return false;
if (c == '-')
f = true, c = getchar();
do
x = x * 10 + c - '0', c = getchar();
while (isdigit(c));
if (f)
x = -x;
return true;
}
inline void read(string &s)
{
char buf[N];
scanf("%s", buf);
s = buf;
}
template<typename T>
inline void write(T x)
{
static char buf[20];
char *pos = buf;
if (x < 0)
putchar('-'), x = -x;
do
*pos++ = x % 10 + '0';
while (x /= 10);
while (pos > buf)
putchar(*--pos);
}
typedef long long ll;
const int CH = 26;
inline int ctoi(const char c)
{
return c - 'a';
}
namespace Segment_Tree
{
struct node
{
int sum, s[2];
}tree[(N << 1) * B];
int cnt, head[N << 1];
int insert(const int lt, const int rt, const int pos)
{
int rot = ++cnt;
++tree[rot].sum;
if (lt == rt)
return rot;
int mid = (lt + rt) >> 1;
if (pos <= mid)
tree[rot].s[0] = insert(lt, mid, pos);
else
tree[rot].s[1] = insert(mid + 1, rt, pos);
return rot;
}
int merge(const int rot1, const int rot2)
{
if (!rot1)
return rot2;
if (!rot2)
return rot1;
int rot = ++cnt;
int lt = merge(tree[rot1].s[0], tree[rot2].s[0]);
int rt = merge(tree[rot1].s[1], tree[rot2].s[1]);
tree[rot] = (node){tree[rot1].sum + tree[rot2].sum, lt, rt};
return rot;
}
int query(const int rot, const int lt, const int rt, const int ls, const int rs)
{
if (ls > rs)
return 0;
if (ls <= lt && rt <= rs)
return tree[rot].sum;
int mid = (lt + rt) >> 1, ans = 0;
if (ls <= mid)
ans += query(tree[rot].s[0], lt, mid, ls, rs);
if (rs > mid)
ans += query(tree[rot].s[1], mid + 1, rt, ls, rs);
return ans;
}
}
struct SAM
{
int last, cnt;
struct node
{
int max, fa, first, s[CH];
}tree[N << 1];
void init()
{
last = cnt = 1;
memset(tree[1].s, 0, sizeof(int[CH]));
}
void insert(const char c)
{
int x = ctoi(c);
int np = ++cnt, p = last;
memset(tree[np].s, 0, sizeof(int[CH]));
tree[np].max = tree[p].max + 1;
while (p && !tree[p].s[x])
tree[p].s[x] = np, p = tree[p].fa;
if (!p)
tree[np].fa = 1;
else
{
int q = tree[p].s[x];
if (tree[p].max + 1 == tree[q].max)
tree[np].fa = q;
else
{
int nq = ++cnt;
memcpy(tree[nq].s, tree[q].s, sizeof(int[CH]));
tree[nq].first = tree[q].first;
tree[nq].max = tree[p].max + 1;
tree[nq].fa = tree[q].fa;
tree[np].fa = tree[q].fa = nq;
while (p && tree[p].s[x] == q)
tree[p].s[x] = nq, p = tree[p].fa;
}
}
last = np;
}
static int buf[N << 1];
void topo()
{
static int count[N];
int maxx = 0;
memset(count, 0, sizeof(count));
for (int i = 1; i <= cnt; i++)
++count[tree[i].max], maxx = max(maxx, tree[i].max);
for (int i = 1; i <= maxx; i++)
count[i] += count[i - 1];
for (int i = cnt; i > 0; i--)
buf[count[tree[i].max]--] = i;
}
void build(const string &s, const bool segment)
{
using Segment_Tree::head;
init();
for (int i = 0; i < s.size(); i++)
{
insert(s[i]);
tree[last].first = i;
if (segment)
head[last] = Segment_Tree::insert(0, s.size() - 1, i);
}
if (segment)
{
topo();
for (int i = cnt; i > 0; i--)
{
using Segment_Tree::head;
head[tree[buf[i]].fa] = Segment_Tree::merge(head[tree[buf[i]].fa], head[buf[i]]);
}
}
}
}s1, s2;
int SAM::buf[N << 1], lim[N];
string s;
ll solve(const string &t, const int l, const int r)
{
using Segment_Tree::head;
using Segment_Tree::query;
SAM::node *tree = s1.tree;
int now = 1, len = 0;
for (int i = 0; i < t.size(); i++)
{
int x = ctoi(t[i]), nxt = tree[now].s[x];
while (now && !nxt)
now = tree[now].fa, nxt = tree[now].s[x], len = tree[now].max;
while (now)
{
int tmp = 0;
while (len >= 0 && !(tmp = query(head[nxt], 0, s.size() - 1, l + len, r)))
{
--len;
if (len == tree[tree[now].fa].max)
now = tree[now].fa, nxt = tree[now].s[x];
}
if (tmp)
{
now = nxt, ++len;
break;
}
else
now = tree[now].fa, nxt = tree[now].s[x], len = tree[now].max;
}
if (!now)
now = 1, len = 0;
lim[i] = len;
}
ll ans = 0;
for (int i = 1; i <= s2.cnt; i++)
ans += max(0, s2.tree[i].max - max(s2.tree[s2.tree[i].fa].max, lim[s2.tree[i].first]));
return ans;
}
int work()
{
int T;
read(s), read(T);
s1.build(s, true);
while (T--)
{
using namespace Segment_Tree;
static string t;
int l, r;
read(t), read(l), read(r);
--l, --r;
s2.build(t, false);
write(solve(t, l, r)), putchar('\n');
}
return (0^_^0);
}
}
int main()
{
return zyt::work();
}
