后缀数组的第X种求法

后缀自动机构造后缀数组。

因为有个SB题洛谷5115，它逼迫我学习后缀数组...(边分树合并是啥？)。

一些定义：sa[i]表示字典序排第i的后缀是从哪里开始的。Rank[i]表示后缀i的排名。height[i]表示排名i和i - 1的后缀的最长公共前缀。

首先我们可以建出后缀树，然后按字典序DFS即可获得sa数组和rank数组。

接下来要求height，使用经典后缀数组的求法即可。

说一下关于后缀数组经典倍增构造方法的一些理解。关于网上流传的那个锯齿形图，其实就是把上一次的两个排名拼接起来进行排序。

height数组的构建也很神奇。按照下标求，可以发现sa[Rank[i]](它自己)和j = sa[Rank[i] - 1]和i + 1的关系：

若i和j的[1, x]这些位相同，那么i + 1和j的[2, x]这些位相同。所以height[Rank[i]]至少有x - 1。

拍过的模板......暂时没找到模板题(板子字符集居然是62...是想卡爆SAM吧)

#include <bits/stdc++.h>

const int N = 200010;

int n, pw[N], ST[N][20];
int tr[N][26], len[N], fail[N], tot = 1, last = 1, ed[N], Lp[N];
int tr2[N][26], sa[N], Rank[N], height[N], num;
char str[N];

inline void insert(char c, int id) {
    int f = c - 'a', p = last, np = ++tot;
    last = np;
    ed[np] = 1;
    Lp[np] = id;
    len[np] = len[p] + 1;
    while(p && !tr[p][f]) {
        tr[p][f] = np;
        p = fail[p];
    }
    if(!p) {
        fail[np] = 1;
    }
    else {
        int Q = tr[p][f];
        if(len[Q] == len[p] + 1) {
            fail[np] = Q;
        }
        else {
            int nQ = ++tot;
            Lp[nQ] = Lp[Q];
            len[nQ] = len[p] + 1;
            fail[nQ] = fail[Q];
            fail[Q] = fail[np] = nQ;
            memcpy(tr[nQ], tr[Q], sizeof(tr[Q]));
            while(tr[p][f] == Q) {
                tr[p][f] = nQ;
                p = fail[p];
            }
        }
    }
    return;
}

void DFS(int x) {
    if(ed[x]) {
        sa[++num] = Lp[x];
        Rank[Lp[x]] = num;
    }
    for(int i = 0; i < 26; i++) {
        if(!tr2[x][i]) continue;
        DFS(tr2[x][i]);
    }
    return;
}

inline void getsa() {
    for(int i = 2; i <= tot; i++) { /// build suffix tree
        char c = str[Lp[i] + len[fail[i]]];
        tr2[fail[i]][c - 'a'] = i;
    }
    DFS(1); /// DFS suffix tree to get SA and Rank
    for(int i = 1, j, k = 0; i <= n; i++) { /// get height
        j = sa[Rank[i] - 1];
        if(!j) continue;
        if(k) k--;
        while(i + k <= n && j + k <= n && str[i + k] == str[j + k]) {
            k++;
        }
        height[Rank[i]] = k;
    }
    return;
}

inline void prework() {
    for(int i = 2; i <= n; i++) pw[i] = pw[i >> 1] + 1;
    for(int i = 1; i <= n; i++) ST[i][0] = height[i];
    for(int j = 1; j <= pw[n]; j++) {
        for(int i = 1; i + (1 << j) - 1 <= n; i++) {
            ST[i][j] = std::min(ST[i][j - 1], ST[i + (1 << (j - 1))][j - 1]);
        }
    }
    return;
}

inline getSmall(int l, int r) {
    if(l > r) std::swap(l, r);
    l++;
    int t = pw[r - l + 1];
    return std::min(ST[l][t], ST[r - (1 << t) + 1][t]);
}

int main() {
    scanf("%s", str + 1);
    n = strlen(str + 1);
    for(int i = n; i >= 1; i--) {
        insert(str[i], i);
    }
    getsa();
    prework();
    
    int m;
    scanf("%d", &m);
    for(int i = 1; i <= m; i++) {
        int x, y;
        scanf("%d%d", &x, &y);
        if(x == y) {
            printf("%d ", n - x + 1);
        }
        else {
            int t = getSmall(Rank[x], Rank[y]);
            printf("%d ", t);
        }
    }

    return 0;
}