洛谷P3975 弦论

题意：求一个串的字典序第k小的子串/本质不同第k小的子串。

解：一开始我的想法是在后缀树上找，但是不知道后缀树上的边对应的是哪些字符...

然而可以不用fail树转移，用转移边转移即可。

先建一个后缀自动机，记忆化搜索每个节点向后向后有多少个串。

然后从起点开始向后一个字符一个字符的确定。

注意每到一个新点就要判断是否结束，并把k减去在此结束的串的个数。

#include <cstdio>
#include <cstring>

const int N = 1000010;

int tr[N][26], len[N], fail[N], siz[N], bin[N], cnt[N], topo[N];
int top, last;

inline void init() {
    top = last = 1;
    return;
}

inline void insert(char c) {
    int f = c - 'a';
    int p = last, np = ++top;
    last = np;
    len[np] = len[p] + 1;
    cnt[np] = 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 = ++top;
            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;
}

inline void sort() {
    for(int i = 1; i <= top; i++) {
        bin[len[i]]++;
    }
    for(int i = 1; i <= top; i++) {
        bin[i] += bin[i - 1];
    }
    for(int i = 1; i <= top; i++) {
        topo[bin[len[i]]--] = i;
    }
    return;
}

inline void count() {
    for(int i = top; i >= 1; i--) {
        int x = topo[i];
        cnt[fail[x]] += cnt[x];
    }
    return;
}

char s[N];

int DFS(int x) {
    if(siz[x]) {
        return siz[x];
    }
    siz[x] = cnt[x];
    for(int i = 0; i < 26; i++) {
        if(tr[x][i]) {
            siz[x] += DFS(tr[x][i]);
        }
    }
    return siz[x];
}

int main() {
    scanf("%s", s + 1);
    int n = strlen(s + 1);
    init();
    for(int i = 1; i <= n; i++) {
        insert(s[i]);
    }
    sort();
    int flag, k;
    scanf("%d%d", &flag, &k);
    if(flag) {
        count();
    }
    else {
        for(int i = 2; i <= top; i++) {
            cnt[i] = 1;
        }
    }

    int sum = 0;
    for(int i = 2; i <= top; i++) {
        sum += cnt[i] * (len[i] - len[fail[i]]);
    }

    int p = 1;
    DFS(p);
    if(k > sum) {
        puts("-1");
        return 0;
    }
    cnt[1] = 0;
    while(1) {
        //printf("k = %d   %d 
", k, k == 1);
        if(k == 1) {
            break;
        }
        else {
            k -= cnt[p];
        }
        //printf("k = %d p = %d 
", k, p);
        for(int i = 0; i < 26; i++) {
            if(!tr[p][i]) {
                continue;
            }
            if(siz[tr[p][i]] >= k) {
                putchar(i + 'a');
                p = tr[p][i];
                break;
            }
            else {
                k -= siz[tr[p][i]];
            }
        }
    }

    return 0;
}

 又思考了一下，虽然记忆化搜索会搜到重复的节点，但是这些重复所表示的是到达它的不同方案，也就是它代表的不同子串。所以需要重复统计。

这样一个节点的一条转移边其实就是它下一个字符拼上f之后能形成的子串数。

感觉好神奇...