洛谷P2375 动物园

我要死了。这是我做过的最恶心的题之一。

天下第一的大毒瘤。有gay毒。

我不如熊猫好多年...

---

题意：给定字符串，求g[i]，表示：[0, i]中满足该子串既是前缀又是后缀还不重叠的子串数。

解：题面都写了KMP，想必跟KMP有关。

然后我痛苦的思考了1天无果......

我首先想到求出nex[]和f[]，f[]表示可重叠的既是前缀又是后缀的子串数。

然后想找出f[]和g[]的关系，失败。

然后想到再来一个len[]表示f[]最长的那一个的长度，还是不行...

被折磨了一天，撑不住了，在吃完饭的时候开始看题解。

发现：我们要魔改KMP，每次跳完增加之后若大于一半，就再跳...

这时你停住的地方j就是恰好比一半小的最大值。

然后如果i这里的nex为0，j显然为0，g[]显然也为0

否则j不为0，这时你把f[j - 1]加1就是g[i]

你加的1就是[0, j - 1]这个串。

然后j可以直接继承到下一个i

因为你的j和KMP里的j差不多，除了不超过一半之外都一样。

然后你i每次 + 1的时候g[]最多 + 1

这样就搞过了这个大毒瘤题....

(事实上还不是很清楚)

#include <cstdio>
#include <cstring>

typedef long long LL;

const int N = 1000010, MO = 1e9 + 7;

int nex[N], f[N], g[N];
char s[N];

inline void solve() {
    scanf("%s", s);
    int n = strlen(s);
    nex[0] = 0;
    f[0] = 0;
    for(int i = 1, j = 0; i < n; i++) {
        while(j && s[i] != s[j]) {
            j = nex[j - 1];
        }
        if(s[i] == s[j]) {
            j++;
        }
        nex[i] = j;
        if(j) {
            f[i] = f[j - 1] + 1;
        }
        else {
            f[i] = 0;
        }
    }

    g[0] = 0;
    LL ans = 1;
    for(int i = 1, j = 0; i < n; i++) {
        while(j && s[i] != s[j]) {
            j = nex[j - 1];
        }
        if(s[i] == s[j]) {
            j++;
        }
        while(2 * j > (i + 1)) {
            j = nex[j - 1];
        }
        if(!j) {
            g[i] = 0;
        }
        else {
            g[i] = f[j - 1] + 1;
        }
        ans = (ans * (g[i] + 1)) % MO;
    }
    printf("%lld
", ans);
    return;
}

int main() {
    int T;
    scanf("%d", &T);
    while(T--) {
        solve();
    }
    return 0;
}

[update]首先有个30分暴力想必大家都会。

说一下SAM做法。你考虑一个border是什么样的，显然前缀是一条链，而后缀是该点在fail树上到根的链。于是相当于求这两个东西的交，还有个深度限制。

给前缀链标记为1，非前缀标记为0，并统计到根路径的点权和。这样，我们只要找到每个点在fail树上满足限制的最深的点，就能知道答案了。

考虑到每个点在fail树上向下走的时候，满足限制的最深点也是单调向下的。于是拿一个栈维护当前点到根的链，用一个单调指针在栈上找就行了。

#include <bits/stdc++.h>

#define add(x, y) edge[++tp].v = y; edge[tp].nex = e[x]; e[x] = tp

const int N = 2000010, MO = 1e9 + 7;

struct Edge {
    int nex, v;
}edge[N]; int tp;

int n, tr[N][26], fail[N], len[N], e[N], vis[N], Time, val[N], stk[N], top, ans, tot = 1, last = 1;
char str[N];
std::queue<int> Q;
/*
2
abcababc
abcababc
*/
namespace bf {
    typedef unsigned long long uLL;
    const uLL B = 131;
    uLL pw[300], h[300];
    inline void prework() {
        pw[0] = 1;
        for(int i = 1; i <= n; i++) {
            pw[i] = pw[i - 1] * B;
            h[i] = h[i - 1] * B + str[i];
        }
        return;
    }
    inline uLL Hash(int l, int r) {
        return h[r] - h[l - 1] * pw[r - l + 1];
    }
    inline void solve() {
        prework();
        int ans = 1;
        for(int i = 1; i <= n; i++) {
            /// [1, i]
            //printf("i = %d 
", i);
            int temp = 1;
            for(int t = i >> 1; t; t--) {
                //printf("t = %d 
", t);
                if(Hash(1, t) == Hash(i - t + 1, i)) {
                    /// num[i] = t;
                    ++temp;
                }
            }
            ans = 1ll * ans * temp % MO;
        }
        printf("%d
", ans);
        return;
    }
}

inline void insert(int f) {
    int p = last, np = ++tot;
    last = np;
    len[np] = len[p] + 1;
    vis[np] = Time;
    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;
            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 clear() {
    for(register int i(1); i <= tot; i++) {
        memset(tr[i], 0, sizeof(tr[i]));
        val[i] = e[i] = fail[i] = len[i] = 0;
    }
    last = tot = 1;
    tp = 0;
    return;
}

void DFS(int x, int p) {
    stk[++top] = x;
    /// calc ans x
    //printf("x = %d 
", x);
    while(p < top && len[stk[p + 1]] * 2 <= len[x]) {
        ++p;
    }
    if(vis[x] == Time) {
        ans = 1ll * ans * (val[stk[p]] + 1) % MO;
    }
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        val[y] = val[x] + (vis[y] == Time);
        DFS(y, p);
    }
    --top;
    return;
}

inline void solve() {
    scanf("%s", str + 1);
    n = strlen(str + 1);
    /*if(n <= 200) {
        bf::solve();
        return;
    }*/
    ++Time;
    ans = 1;
    for(register int i(1); i <= n; i++) {
        insert(str[i] - 'a');
    }
    for(register int i(2); i <= tot; i++) {
        add(fail[i], i);
    }

    DFS(1, 1); /// get val
    printf("%d
", ans);
    clear();
    return;
}

int main() {
    int T;
    scanf("%d", &T);
    while(T--) {
        solve();
        if(T) memset(str + 1, 0, n * sizeof(char));
    }
    return 0;
}

这题非常良心的没卡空间。