H. Security 后缀自动机 + 线段树合并维护end集合

点我看题

题意 给出一个字符串S m次询问
每次询问给出l r 和字符串Q
要你求出S[l-r] 中 字典序最小的 比 Q的字典序大的子串。

PS：其实是一个SAM模板题， 线段树合并维护SAM每个节点的end集合，然后贪心的构建子串就行了。 但是我并不会写。

题目要求求出所有子串信息，很容易的想到使用SAM。
假设没有 l ，r 这个区间限制，那么只要建立出整个串的SAM，然后贪心的找子串就行了。
现在加了l r 这个限制，如果我们还要贪心的去找子串 就必须知道当前遍历的SAM中的节点X 的end集合是否有[l,r] 中的点。
这样的话就是一个套路题了，线段树维护一下即可。 如果直接对每个节点直接建线段树 复杂度是n^2logn 的 显然无法接受。
考虑在后缀链接上跑线段树合并即可。

总的来说是个套路题，然而我知道怎么写后还是写不出来。。 。。。。。。。。。。。。。。。。。。。。。
你说尴不尴尬。。。。。

在cf上扒了一个大神的板子 感觉很棒

#include <bits/stdc++.h>
#define mk make_pair
#define ll long long
using namespace std;
const int N = 2e5 + 5;
const int mod = 1e9 + 7;
struct SAM{
    int n, tot, last;
    int ch[N][26], dep[N], fa[N];
    int root[N], ls[N * 20], rs[N * 20], cnt;
    vector<int> G[N];
    void init() {
        tot = last = 1;
        memset(ch[1], 0, sizeof(ch[1]));
    }
    inline int newnode(int _dep) {
        dep[++tot] = _dep;
        memset(ch[tot], 0, sizeof(ch[tot]));
        return tot;
    }
    void add(int alp) {
        ++n;
        alp -= 'a';
        int u, p = newnode(dep[last] + 1);
        for (u = last; u && !ch[u][alp]; u = fa[u])
            ch[u][alp] = p;
        if (!u) fa[p] = 1;
        else {
            int v = ch[u][alp];
            if (dep[v] == dep[u] + 1) fa[p] = v;
            else {
                int nv = newnode(dep[u] + 1);
                fa[nv] = fa[v];
                fa[v] = fa[p] = nv;
                memcpy(ch[nv], ch[v], sizeof(ch[v]));
                for (; u && ch[u][alp] == v; u = fa[u])
                    ch[u][alp] = nv;
            }
        }
        last = p;
    }
    int build(int l, int r, int p) {
        if (l == r) 
            return ++cnt;
        int mid = l + r >> 1;
        int now = ++cnt;
        if (p <= mid)
            ls[now] = build(l, mid, p);
        else 
            rs[now] = build(mid + 1, r, p);
        return now;
    }
    int merge(int x, int y) {
        if (x == 0 || y == 0)
            return x + y;
        int now = ++cnt;
        ls[now] = merge(ls[x], ls[y]);
        rs[now] = merge(rs[x], rs[y]);
        return now;
    }
    void dfs(int x) {
        for (int i = 0; i < G[x].size(); ++i) {
            int u = G[x][i];
            dfs(u);
            root[x] = merge(root[x], root[u]);
            //cout << x << "/" << u << endl;
        }
    }
    void build_segtree(char* s) {
        int now = 1;
        int n = strlen(s + 1);
        for (int i = 1; i <= n; ++i) {
            now = ch[now][s[i] - 'a'];
            root[now] = build(1, n, i);  //cout << now << "/" << i << "/" << fa[now] << endl;
        }
        for (int i = 1; i <= tot; ++i)
            G[fa[i]].push_back(i);
        dfs(1);
    }
    string ans;
    bool chk(int k, int l, int r, int p, int q) {
        if (k == 0) 
            return false;
        if (l >= p && r <= q)
            return true;
        if (l > q || r < p)
            return false;
        int mid = l + r >> 1;
        return chk(ls[k], l, mid, p, q) || chk(rs[k], mid + 1, r, p, q);
    }
    bool check(int l, int r, int p) {
        return chk(p, 1, n, l, r);
    }
    bool solve(int now, int l, int r, char *s) {  //cout << l << "," << r << "," << *s << endl; 
        if (l > r) return false;
        if (*s == 0) {
            for (int i = 0; i < 26; i++) {
                if (ch[now][i] && check(l, r, root[ch[now][i]])) {
                    ans.push_back('a' + i);
                    return true;
                }
            }
            return false;
        } else {
            int i = *s - 'a'; //cout << (ch[now][i]) << endl;
            if (ch[now][i] && check(l, r, root[ch[now][i]]) && solve(ch[now][i], l + 1, r, s + 1)) {
                ans.push_back('a' + i);
                return true;
            }
            for (i = i + 1; i < 26; ++i) {
                if (ch[now][i] && check(l, r, root[ch[now][i]])) {
                    ans.push_back('a' + i);
                    return true;
                }
            }
            return false;
        }
    }
} sam;
int n, m;
char s[N];
int main() {
    sam.init();
    scanf("%s", s + 1);
    n = strlen(s + 1);
    for (int i = 1; i <= n; i++)
        sam.add(s[i]);
    sam.build_segtree(s);
    scanf("%d", &m);
    while (m--) {
        int l, r;
        scanf("%d %d %s", &l, &r, s + 1);
        sam.ans.clear();
        if (!sam.solve(1, l, r, s + 1))
            printf("-1\n");
        else {
            reverse(sam.ans.begin(), sam.ans.end());
            printf("%s\n", sam.ans.c_str());
        }
    }
}