洛谷 P3975 后缀自动机 + 建link树 + 字典树统计字符串个数

       题目给定一个字符串 $s$，指令 $t$， $t$ 为 $1$ 则不同位置的相同的串视作不同，为 $0$ 则视作相同，问你字典序第 $k$ 小的串。

       首先按照 $link$ 来建树，自下而上除 $clone$ 点外长度递减。我们标记所有 $endpos$ 等价类，也就是插入的每个字符对应的状态，然后依照 $link$ 树来统计，所有的 $endpos$ 等价类中的最长后缀出现了几次（若题目说不能重复计算则全为 $1$）。

       另外再有一个遍历字典树来求以当前字符串为前缀的字符串个数。这样后续求第 $k$ 小就可以通过数量来判断当前是否为第 $k$ 小。若此时前缀的字符串数量少于 $k$，则用 $k$ 减去以该前缀为前缀的所有字符串的数量。反之只减去该前缀的数量，也就是 $endpos$ 等价类中的最长后缀的数量。然后再做进一步判断，是否要继续找第 $k$ 小。

       说实话还有一个小地方没搞懂，统计子串数量的时候，为什么不需要增加 $clone$ 点的 $size$，容我再研究研究。

       代码如下：

#include<bits/stdc++.h>
#define endl '\n'
using namespace std;
typedef long long LL;
const int maxn =  1e6 + 5;

char s[maxn];
int sz, last, cnt;               // sz = size
int size[maxn], head[maxn], sum[maxn];

struct state{
    int len, link;
    int next[26];
}st[maxn];

struct node{
    int v, next;
}edge[maxn];

inline void add(int u, int v){
    edge[cnt].next = head[u];
    edge[cnt].v = v;
    head[u] = cnt++;
}

inline void init(){
    memset(head, -1, sizeof(head));
    st[0].len = 0;
    st[0].link = -1;
    sz = 0;
    last = 0;
}

inline void extend(int c){
    int now = ++sz;
    st[now].len = st[last].len + 1;
    int p = last;
    while(~p && !st[p].next[c]){
        st[p].next[c] = now;
        p = st[p].link;
    }
    if(p == -1)
        st[now].link = 0;
    else{
        int q = st[p].next[c];
        if(st[p].len + 1 == st[q].len)
            st[now].link = q;
        else{
            int clone = ++sz;
            st[clone] = st[q];
            st[clone].len = st[p].len + 1;
            st[q].link = st[now].link = clone;
            while(~p && st[p].next[c] == q){
                st[p].next[c] = clone;
                p = st[p].link;
            }
        }
    }
    last = now;
    size[now]++;
}

inline void dfs(int u){
    for(int k = head[u]; ~k; k = edge[k].next){
        dfs(edge[k].v);
        size[u] += size[edge[k].v];
    }
}

inline void dfs2(int u){
    if(sum[u]) return;
    sum[u] = size[u];
    for(int i = 0; i < 26; i++)
        if(st[u].next[i]){
            dfs2(st[u].next[i]);
            sum[u] += sum[st[u].next[i]];
        }
}

int main(){
    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(false);
    init();
    int t, k;
    cin >> s;
    cin >> t >> k;
    for(int i = 0; s[i]; i++)
        extend(s[i] - 'a');
    if(t){
        for(int i = 1; i <= sz; i++)
            add(st[i].link, i);
        dfs(0);
        size[0] = 0;
    }else
        for(int i = 1; i <= sz; i++) size[i] = 1;
    dfs2(0);
    if(sum[0] < k) cout << -1 << endl;
    else{
        int now = 0, u;
        while(k > 0){                       // 是否要继续找更大字典序的字符串
            for(int i = 0; i < 26; i++){
                u = st[now].next[i];
                if(u){
                    if(sum[u] < k)
                        k -= sum[u];        // 字典序小的字符串总数量
                    else{
                        cout << char('a' + i);
                        k -= size[u];       //  以当前结点为结尾的最长串的数量
                        now = u;
                        break;
                    }
                }
            }
        }
    }
}