字符串

懒得认真写博客了...

圈圈

求每次把字符串全部 + 1 之后的最小表示法。

就是那样，先Hash。

+ 1的时候考虑有哪些地方变成0了，在这些位置中O(logn)比较。

没有变成0的话就是上一次的答案。

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>

typedef unsigned long long uLL;

const int N = 50010, B = 1e9 + 7;

int s[N << 1], n, m, k;
uLL H[N << 1], po[N << 1];
std::vector<int> pos[N];

inline void gethash(int n) {
    H[0] = s[0];
    po[0] = 1;
    for(int i = 1; i < n * 2; i++) {
        po[i] = po[i - 1] * B;
        H[i] = H[i - 1] * B + s[i];
    }
    return;
}
inline uLL Hash(int l, int r) {
    if(l == 0) {
        return H[r]; /// error : space
    }
    return H[r] - H[l - 1] * po[r - l + 1];
}

inline int getmin() {
    int i = 0, j = 1;
    while(i < n && j < n) {
        int k = 0;
        while(s[i + k] == s[j + k] && k < n) {
            k++;
        }
        if(k == n) {
            return 0;
        }
        if(s[i + k] > s[j + k]) {
            i += k + 1;
            if(i == j) {
                i++;
            }
        }
        else {
            j += k + 1;
            if(i == j) {
                j++;
            }
        }
    }
    return std::min(i, j);
}

inline bool great(int i, int j, int t) {
    int l = 0, r = n, mid;
    while(l < r) {
        mid = (l + r) >> 1;
        if(Hash(i, i + mid) == Hash(j, j + mid)) {
            l = mid + 1;
        }
        else {
            r = mid;
        }
    }
    return (s[i + r] + t) % m > (s[j + r] + t) % m;
}

int main() {
    freopen("in.in", "r", stdin);
    freopen("my.out", "w", stdout);
    scanf("%d%d%d", &n, &m, &k);
    k--;
    for(int i = 0; i < n; i++) {
        scanf("%d", &s[i]);
        pos[s[i]].push_back(i);
    }

    memcpy(s + n, s, n * sizeof(int));
    gethash(n);

    int t = getmin();
    printf("%d\n", s[t + k]);
    //printf("%d\n", t);
    for(int i = 1; i < m; i++) {
        if(pos[m - i].size()) {
            t = pos[m - i][0];
            for(int j = 1; j < pos[m - i].size(); j++) {
                if(great(t, pos[m - i][j], i)) {
                    t = pos[m - i][j];
                }
            }
        }
        printf("%d\n", (s[t + k] + i) % m);
        //printf("%d\n", t);
    }

    return 0;
}

---

manacher

作用：求出字符串中，以每个位置为中心，最多能向两边扩展多少回文串。

例：  #a#b#a#

f[]:  0 1 0 3 0 1 0

两边中间都要补上#之类的东西，max(f)直接输出就是ans

模板：

#include <cstdio>
#include <cstring>
#include <algorithm>

const int N = 11000010;

char s[N << 1];
int f[N << 1];

int main() {
    scanf("%s", s);
    int n = strlen(s);
    n = (n << 1) + 1;
    for(int i = n - 1; i >= 0; i--) {
        if(i & 1) {
            s[i] = s[i >> 1];
        }
        else {
            s[i] = '#';
        }
    }
    //printf("%s\n", s);
    f[0] = 1;
    int p = 0, ans = 1;
    for(int i = 1; i < n; i++) {
        int t = 2 * p - i;
        if(t < 0 || i + f[t] >= p + f[p]) {
            int j = p + f[p] - i + 1;
            while(i + j < n && i - j >= 0 && s[i + j] == s[i - j]) {
                j++;
            }
            f[i] = j - 1;
        }
        else {
            f[i] = f[t];
        }
        //printf("%d %d\n", i, f[i]);
        if(i + f[i] > p + f[p]) {
            p = i;
        }
        ans = std::max(ans, f[i]);
    }
    printf("%d", ans);
    return 0;
}

 这个是hash替代manacher，可以求出以每个位置为结尾的最长回文串。

#include <cstdio>
#include <cstring>
#include <algorithm>

typedef unsigned long long uLL;

const int N = 11000010, B = 13331;

int f1[N], f2[N], n;
char s[N];
uLL H1[N], H2[N], po[N];

inline void gethash() {
    H1[0] = s[0];
    po[0] = 1;
    for(int i = 1; i < n; i++) {
        H1[i] = H1[i - 1] * B + s[i];
        po[i] = po[i - 1] * B;
    }
    H2[n - 1] = s[n - 1];
    for(int i = n - 2; i >= 0; i--) {
        H2[i] = H2[i + 1] * B + s[i];
    }
    return;
}
inline uLL Hash1(int l, int r) {
    if(!l) {
        return H1[r];
    }
    return H1[r] - H1[l - 1] * po[r - l + 1];
}
inline uLL Hash2(int l, int r) {
    if(r == n - 1) {
        return H2[l];
    }
    return H2[l] - H2[r + 1] * po[r - l + 1];
}

int main() {
    scanf("%s", s);
    n = strlen(s);
    gethash();
    f1[0] = 1;                   //  01234567
    int ans = 1;                 //  babcbabc
    for(int i = 1; i < n; i++) { //  11313575
        if(f1[i - 1] < i && s[i] == s[i - f1[i - 1] - 1]) {
            f1[i] = f1[i - 1] + 2;
        }
        else {
            int k = i - f1[i - 1];
            while(Hash1(k, i) != Hash2(k, i)) {
                k++;
            }
            f1[i] = i - k + 1;
        }
        ans = std::max(ans, f1[i]);
        //printf("%d %d \n", i, f1[i]);
    }
    printf("%d", ans);
    return 0;
}

---

最长双回文串。

这个很奇怪...O(n)的算法，luogu上面跑的飞起，bzoj就T。

先放洛谷AC代码吧。

#include <cstdio>
#include <cstring>
#include <algorithm>

typedef unsigned long long uLL;

const int N = 11000010, B = 13331;

int f1[N], f2[N], n;
char s[N];
uLL H1[N], H2[N], po[N];

inline void gethash() {
    H1[0] = s[0];
    po[0] = 1;
    for(int i = 1; i < n; i++) {
        H1[i] = H1[i - 1] * B + s[i];
        po[i] = po[i - 1] * B;
    }
    H2[n - 1] = s[n - 1];
    for(int i = n - 2; i >= 0; i--) {
        H2[i] = H2[i + 1] * B + s[i];
    }
    return;
}
inline uLL Hash1(int l, int r) {
    if(!l) {
        return H1[r];
    }
    return H1[r] - H1[l - 1] * po[r - l + 1];
}
inline uLL Hash2(int l, int r) {
    if(r == n - 1) {
        return H2[l];
    }
    return H2[l] - H2[r + 1] * po[r - l + 1];
}

int main() {
    scanf("%s", s);
    n = strlen(s);
    gethash();                   //  01234567
    f1[0] = f2[n - 1] = 1;       //  babcbabc
                                 //  75353111
    for(int i = 1; i < n; i++) { //  11313575
        if(f1[i - 1] < i && s[i] == s[i - f1[i - 1] - 1]) {
            f1[i] = f1[i - 1] + 2;
        }
        else {
            int k = i - f1[i - 1];
            while(Hash1(k, i) != Hash2(k, i)) {
                k++;
            }
            f1[i] = i - k + 1;
        }
    }
    for(int i = n - 2; i >= 0; i--) {
        if(i + f2[i + 1] + 1 < n && s[i] == s[i + f2[i + 1] + 1]) {
            f2[i] = f2[i + 1] + 2;
        }
        else {
            int k = i + f2[i + 1];
            while(Hash1(i, k) != Hash2(i, k)) {
                k--;
            }
            f2[i] = k - i + 1;
        }
    }

    int ans = 2;
    for(int i = 1; i < n; i++) {
        ans = std::max(ans, f1[i - 1] + f2[i]);
    }
    printf("%d", ans);
    return 0;
}

 咳咳，问题查出来了，N忘了改，开了1100 0000的uLL数组。。。BZ MLE显示TLE

---

POJ1509

poj的毒瘤也不是第一次见了，莫名其妙的WA，然后就A...

最小表示法模板题。

#include <cstdio>
#include <cstring>
#include <algorithm>

const int N = 10010;

char s[N << 1];

int main() {
    int T;
    scanf("%d", &T);
    while(T--) {
        scanf("%s", s);
        int n = strlen(s);
        memcpy(s + n, s, n * sizeof(char));
        int i = 1, j = 0;
        while(i < n && j < n) {
            int k = 0;
            while(k < n && s[i + k] == s[j + k]) {
                k++;
            }
            if(k == n) {
                break;
            }
            if(s[i + k] > s[j + k]) {
                i += k + 1;
                if(i == j) {
                    i++;
                }
            }
            else {
                j += k + 1;
                if(j == i) {
                    j++;
                }
            }
        }
        printf("%d\n", std::min(i, j) + 1);
    }
    return 0;
}

---

 APIO2014 回文串

PAM业界毒瘤！！！

这句话不得不说，毕竟理解它花了几分钟，但是两天都打不出来...

最后直接摘抄模板，不管了。注意！insert开新点那里不能先给tr[p][f]赋值。

#include <cstdio>
#include <cstring>
#include <algorithm>

typedef long long LL;

const int N = 300010;

char s[N];
int n;

struct PAM {
    int tr[N][26], cnt[N], fail[N], len[N], num[N];
    int top, last;
    inline void init() { // !!!
        len[0] = 0;
        len[1] = -1;
        fail[0] = 1;
        fail[1] = 1;
        last = 0;
        top = 1;
        return;
    }
    inline int getfail(int d, int x) {
        while(s[d - len[x] - 1] != s[d]) {
            x = fail[x];
        }
        return x;
    }
    inline void insert(int d) {
        int f = s[d] - 'a';
        int p = getfail(d, last);
        if(!tr[p][f]) {
            ++top;
            len[top] = len[p] + 2; // 长度
            fail[top] = tr[getfail(d, fail[p])][f]; // 最长 靠右 子回文串
            num[top] = num[fail[top]] + 1; // 这个串内靠右 回文串数
            tr[p][f] = top; // 两端 + f 转移
        }
        last = tr[p][f]; // 末尾最长回文串
        cnt[last]++; // 该回文串出现次数
    }
    inline void count() { // 统计 cnt
        for(int i = top; i >= 0; i--) {
            cnt[fail[i]] += cnt[i];
        }
    }
}pam;

int main() {
    scanf("%s", s);
    n = strlen(s);
    pam.init();
    for(int i = 0; i < n; i++) {
        pam.insert(i);
    }
    pam.count();

    LL ans = 0;
    for(int i = 2; i <= pam.top; i++) {
        ans = std::max(ans, 1ll * pam.len[i] * pam.cnt[i]);
    }
    printf("%lld", ans);
    
    return 0;
}

有个小问题就是char数组的-1位是空...不知道为什么。

---

SHOI2011 双倍回文

这题用回文自动机秒...

先打了个裸露在外的暴力，T了一个点，然后剪个枝就A了，跑的还贼快...

#include <cstdio>
#include <cstring>
#include <algorithm>

const int N = 500010;

char s[N];
int n;

struct PAM {
    int tr[N][26], cnt[N], len[N], num[N], fail[N];
    int top, last;
    inline void init() {
        len[0] = 0;
        len[1] = -1;
        fail[0] = 1;
        fail[1] = 1;
        top = 1;
        last = 0;
        return;
    }
    inline int getfail(int d, int x) {
        while(s[d - len[x] - 1] != s[d]) {
            x = fail[x];
        }
        return x;
    }
    inline void insert(int d) {
        int f = s[d] - 'a';
        int p = getfail(d, last);
        if(!tr[p][f]) {
            ++top;
            fail[top] = tr[getfail(d, fail[p])][f];
            len[top] = len[p] + 2;
            num[top] = num[fail[top]] + 1;
            tr[p][f] = top;
        }
        last = tr[p][f];
        cnt[last]++;
        return;
    }
    inline void count() {
        for(int i = top; i >= 0; i--) {
            cnt[fail[i]] += cnt[i];
        }
        return;
    }
}pam;

int main() {
    pam.init();
    scanf("%d", &n);
    scanf("%s", s);
    for(int i = 0; i < n; i++) {
        pam.insert(i);
    }
    int ans = 0;
    for(int i = pam.top; i > 1; i--) {
        if(pam.len[i] % 4 || pam.len[i] <= ans) { 
            continue;
        }
        int j = pam.len[i], p = pam.fail[i];
        while(pam.len[p] << 1 > j) {
            p = pam.fail[p];
        }
        if(pam.len[p] << 1 == j) {
            ans = std::max(ans, j);
        }
    }

    printf("%d", ans);
    return 0;
}

---

洛谷P1872 回文串计数

仔细分析之后也可以用PAM秒。

只要记录每个位置为结尾的回文串数量，翻转之后再统计每个位置之前的所有回文串数量，乘起来即可。

#include <cstdio>
#include <cstring>
#include <algorithm>

typedef long long LL;

const int N = 2010;

char s[N];
int n, ans[N], tot;

struct PAM {
    int tr[N][26], len[N], cnt[N], num[N], fail[N];
    int last, top;
    inline void init() {
        len[0] = 0;
        len[1] = -1;
        fail[0] = fail[1] = 1;
        last = 0;
        top = 1;
        return;
    }
    PAM() {
        init();
    }
    inline int getfail(int d, int x) {
        while(s[d - len[x] - 1] != s[d]) {
            x = fail[x];
        }
        return x;
    }
    inline void insert(int d) {
        int f = s[d] - 'a';
        int p = getfail(d, last);
        if(!tr[p][f]) {
            ++top;
            fail[top] = tr[getfail(d, fail[p])][f];
            len[top] = len[p] + 2;
            num[top] = num[fail[top]] + 1;
            tr[p][f] = top;
        }
        last = tr[p][f];
        cnt[last]++;
        ans[d] = num[last];
        tot += num[last];
    }
    inline void count() {
        for(int i = top; i >= 0; i--) {
            cnt[fail[i]] += cnt[i];
        }
        return;
    }
    inline void clear() {
        for(int i = 0; i <= top; i++) {
            for(int j = 0; j < 26; j++) {
                tr[i][j] = 0;
            }
            len[i] = fail[i] = num[i] = cnt[i] = 0;
        }
        init();
        return;
    }
}pam;

int main() {
    scanf("%s", s);
    n = strlen(s);
    for(int i = 0; i < n; i++) {
        pam.insert(i);
    }
    pam.clear();
    std::reverse(s, s + n);
    std::reverse(ans, ans + n);
    tot = 0;
    LL t = 0;
    for(int i = 0; i < n - 1; i++) {
        pam.insert(i);
        t += 1ll * tot * ans[i + 1];
        //printf("%d %d\n", tot, ans[i + 1]);
    }
    printf("%lld", t);
    return 0;
}

---

国家集训队 拉拉队排练

嗯，依旧是PAM水题。 

我的想法是把每个奇回文串搞一个结构体，排序之后快速幂。

T了最后一个点...于是跑去看题解，发现可以用桶装，继续T最后一个点...

最后发现是输入的 k 爆int了，所以不知怎地超时的……

#include <cstdio>
#include <cstring>
#include <algorithm>

typedef long long LL;

const int N = 1000010;
const LL MO = 19930726;

char s[N];
int n;
LL bin[N];
LL qpow(int aa, int b);

struct PAM {
    int tr[N][26], fail[N], len[N], cnt[N], num[N];
    int last, top;
    inline void init() {
        len[0] = 0;
        len[1] = -1;
        fail[0] = fail[1] = 1;
        last = 0;
        top = 1;
        return;
    }
    PAM() {
        init();
    }

    inline int getfail(int d, int x) {
        while(s[d - len[x] - 1] != s[d]) {
            x = fail[x];
        }
        return x;
    }
    inline void insert(int d) {
        int f = s[d] - 'a';
        int p = getfail(d, last);
        if(!tr[p][f]) {
            ++top;
            fail[top] = tr[getfail(d, fail[p])][f];
            len[top] = len[p] + 2;
            num[top] = num[fail[top]] + 1;
            tr[p][f] = top;
        }
        last = tr[p][f];
        cnt[last]++;
        return;
    }
    inline void count() {
        for(int i = top; i >= 0; i--) {
            cnt[fail[i]] += cnt[i];
            if(len[i] & 1 && i > 1) {
                bin[len[i]] += cnt[i];
            }
        }
        return;
    }
}pam;

inline LL qpow(int aa, int b) {
    LL a = (LL)(aa) % MO;
    LL ans = 1;
    while(b) {
        if(b & 1) {
            ans = (ans * a) % MO;
        }
        a = (a * a) % MO;
        b = b >> 1;
    }
    return ans;
}

int main() {
    //printf("%d", (int)(MO * MO));
    LL k;
    scanf("%d%lld", &n, &k);
    scanf("%s", s);
    for(int i = 0; i < n; i++) {
        pam.insert(i);
    }
    pam.count();
/*
    LL tp = 0;
    for(int i = 2; i <= pam.top; i++) {
        tp += pam.cnt[i];
    }
    if(k > tp) {
        printf("-1");
        return 0;
    }
*/
    int i = n;
    LL ans = 1;
    for(int i = n; i && k; i--) {
        if(!bin[i]) {
            continue;
        }
        if(bin[i] <= k) {
            ans = (ans * qpow(i, bin[i])) % MO;
            k -= bin[i];
        }
        else {
            ans = (ans * qpow(i, k)) % MO;
            k = 0;
            break;
        }
    }

    if(k) {
        ans = -1;
    }
    printf("%lld", ans);
    return 0;
}

---

 PAM总结：

回文自动机，一个点代表一种回文串，支持以下功能：

1，统计所有回文串数。cnt的2 ~ top求和/途中累加num

2，统计所有本质不同回文串数。top - 1

3，统计所有本质不同回文串出现次数。count()之后的cnt

4，统计以第i位结尾的回文串个数。途中num

等等...

---

SAM

这个东西TM比PAM还毒瘤...我真是要被气死了。

跟PAM一样调了两天，一行一行的照抄别人的模板，就是T...

然后把数组开到2n就A了啊啊啊啊啊啊啊毒瘤！！！

模板:

#include <cstdio>
#include <cstring>
#include <algorithm>
typedef long long LL;
const int N = 2000010;
char s[N];
int n;
LL ans;
struct SAM {
    int tr[N][26], fail[N], len[N], cnt[N], bin[N], topo[N];
    int root, top, last;

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

    inline void insert(char c) {
        int f = c - 'a';
        int p = last, np = ++top;
        last = np;
        cnt[np] = 1;
        len[np] = len[p] + 1;
        while(p && !tr[p][f]) {
            tr[p][f] = np;
            p = fail[p];
        }
        if(!p) {
            fail[np] = root;
        }
        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 cal() {
        for(int i = top; i; i--) {
            int x = topo[i];
            cnt[fail[x]] += cnt[x];
            if(cnt[x] > 1) {
                ans = std::max(ans, 1ll * len[x] * cnt[x]);
            }
        }
        return;
    }
}sam;

int main() {
    scanf("%s", s);
    n = strlen(s);
    for(int i = 0; i < n; i++) {
        sam.insert(s[i]);
    }
    sam.sort();
    sam.cal();
    printf("%lld", ans);

    return 0;
}

---

hihocoder 1441 

毒瘤...

如何求一个点的right集合？

他的子树中所有在主链上的len( - 1)

这个卡了我好久。。。不能只取叶子，因为iiaaaii，也不能全取，因为ciiaaaii

#include <cstdio>
#include <cstring>
#include <algorithm>
const int N = 100010;
char s[N], p[N];
int n, A[N], num;

struct SAM {
    int tr[N][26], fail[N], len[N], cnt[N], topo[N], bin[N];
    int root, top, last;
    bool is_new[N];
    ///---------------------
    struct Edge {
        int v, nex;
    }edge[N]; int t;
    int e[N];
    inline void add(int x, int y) {
        t++;
        edge[t].v = y;
        edge[t].nex = e[x];
        e[x] = t;
        return;
    }
    ///---------------------
    inline void init() {
        root = 1;
        top = 1;
        last = 1;
        t = 0;
        return;
    }
    SAM() {
        init();
    }
    inline void insert(char c) {
        int f = c - 'a';
        int p = last, np = ++top;
        last = np;
        len[np] = len[p] + 1;
        cnt[np] = 1;
        is_new[np] = 1;
        while(p && !tr[p][f]) {
            tr[p][f] = np;
            p = fail[p];
        }
        if(!p) {
            fail[np] = root;
        }
        else {
            int Q = tr[p][f];
            if(len[Q] == len[p] + 1) {
                fail[np] = Q;
            }
            else {
                int nQ = ++top;
                fail[nQ] = fail[Q];
                fail[Q] = fail[np] = nQ;
                len[nQ] = len[p] + 1;
                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 build() {
        for(int i = 2; i <= top; i++) {
            add(fail[i], i);
        }
        return;
    }
    inline void DFS(int x) {
        for(int i = e[x]; i; i = edge[i].nex) {
            int y = edge[i].v;
            DFS(y);
        }
        if(is_new[x]) {
            A[++num] = len[x];
        }
        return;
    }
}sam;

int main() {
    scanf("%s", s);
    n = strlen(s);
    for(int i = 0; i < n; i++) {
        sam.insert(s[i]);
    }
    sam.build();
    int T, m;
    scanf("%d", &T);
    while(T--) {
        scanf("%s", p);
        m = strlen(p);
        int k = 1;
        for(int i = 0; i < m; i++) {
            int f = p[i] - 'a';
            k = sam.tr[k][f];
        }
        sam.DFS(k);
        int l = sam.len[sam.fail[k]] + 1;
        int r = sam.len[k];
        for(int i = A[1] - l; i < A[1]; i++) {
            putchar(s[i]);
        }
        putchar(' ');
        for(int i = A[1] - r; i < A[1]; i++) {
            putchar(s[i]);
        }
        putchar(' ');
        std::sort(A + 1, A + num + 1);
        for(int i = 1; i <= num; i++) {
            printf("%d ", A[i]);
        }
        puts("");
        num = 0;
    }

    return 0;
}

---

hihocoder1445 

求本质不同子串数量。

累加len - len[fail] 即可

#include <cstdio>
#include <cstring>
typedef long long LL;
const int N = 2000010;
char s[N];
int n;

struct SAM {
    int tr[N][26], fail[N], len[N];
    int root, top, last;
    inline void init() {
        root = 1;
        top = 1;
        last = 1;
        return;
    }
    SAM() {
        init();
    }

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

int main() {
    scanf("%s", s);
    n = strlen(s);
    for(int i = 0; i < n; i++) {
        sam.insert(s[i]);
    }
    LL ans = 0;
    for(int i = 2; i <= sam.top; i++) {
        ans += sam.len[i] - sam.len[sam.fail[i]];
    }
    printf("%lld", ans);
    return 0;
}

---

hihocoder1449 

分别求长度为 1 ~ n 的子串中出现最多的那个子串出现的次数。

考虑到SAM的一个点代表多个子串，我们要支持区间取max

我觉得线段树可能有问题，就用了O(n)的算法...

后来问了大佬发现线段树可以滋磁这种操作。

我是直接跟更新len，最后从大到小扫一遍。

#include <cstdio>
#include <cstring>
#include <algorithm>
const int N = 1000010;
char s[N];
int n, large[N];

struct SAM {
    int tr[N << 1][26], fail[N << 1], len[N << 1], cnt[N << 1];
    int bin[N << 1], topo[N << 1];
    int root, top, last;
    inline void init() {
        top = 1;
        root = 1;
        last = 1;
        return;
    }
    SAM() {
        init();
    }

    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] = root;
        }
        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 cal() {
        for(int i = top; i >= 1; i--) {
            int x = topo[i];
            cnt[fail[x]] += cnt[x];
            large[len[x]] = std::max(large[len[x]], cnt[x]);
        }
        return;
    }
}sam;

int main() {
    scanf("%s", s);
    n = strlen(s);
    for(int i = 0; i < n; i++) {
        sam.insert(s[i]);
    }
    sam.sort();
    sam.cal();
    for(int i = n; i >= 1; i--) {
        large[i] = std::max(large[i], large[i + 1]);
    }
    for(int i = 1; i <= n; i++) {
        printf("%d\n", large[i]);
    }
    return 0;
}

---

HAOI2016 找相同字符

求两个字符串的相同子串的个数。

允许本质相同。

首先对第一个子串建出SAM。

第二个串匹配到i时，统计以第二个串第i位结尾的答案即可。

那么第i位，匹配到节点p的答案就是：

(当前匹配长度 - len[fail[p]]) * cnt[p] + p的所有父节点的cnt * △len

后半部分可以预处理出一个ans数组来，拓扑序递推即可。

#include <cstdio>
#include <cstring>
typedef long long LL;
const int N = 400010;
char s[N], s2[N];
int n, m, ans[N];
struct SAM {
    int tr[N][26], fail[N], len[N], cnt[N], bin[N], topo[N];
    int top, root, last;
    inline void init() {
        top = 1;
        root = 1;
        last = 1;
        return;
    }
    SAM() {
        init();
    }

    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] = root;
        }
        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 cal() {
        for(int i = top; i; i--) {
            int x = topo[i];
            cnt[fail[x]] += cnt[x];
        }
        for(int i = 1; i <= top; i++) {
            ans[i] = cnt[i] * (len[i] - len[fail[i]]);
        }
        for(int i = 1; i <= top; i++) {
            int x = topo[i];
            ans[x] += ans[fail[x]];
        }
        return;
    }
}sam;
int main() {
    scanf("%s", s);
    scanf("%s", s2);
    n = strlen(s);
    m = strlen(s2);
    for(int i = 0; i < n; i++) {
        sam.insert(s[i]);
    }
    sam.sort();
    sam.cal();
    int p = 1, len = 0;
    LL t = 0;
    for(int i = 0; i < m; i++) {
        int f = s2[i] - 'a';
        while(p != 1 && !sam.tr[p][f]) {
            p = sam.fail[p];
            len = sam.len[p];
        }
        if(sam.tr[p][f]) {
            p = sam.tr[p][f];
            len++;
        }
        if(p != 1) {
            t += sam.cnt[p] * (len - sam.len[sam.fail[p]]) + ans[sam.fail[p]];
        }
    }
    printf("%lld", t);
    return 0;
}