洛谷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 = , MO = 1e9 + ;

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

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

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

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

AC代码

[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 = , MO = 1e9 + ;

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

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

 inline void insert(int f) {
     int p = last, np = ++tot;
     last = np;
     len[np] = len[p] + ;
     vis[np] = Time;
     while(p && !tr[p][f]) {
         tr[p][f] = np;
         p = fail[p];
     }
     if(!p) {
         fail[np] = ;
     }
     else {
         int Q = tr[p][f];
         if(len[Q] == len[p] + ) {
             fail[np] = Q;
         }
         else {
             int nQ = ++tot;
             len[nQ] = len[p] + ;
             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(); i <= tot; i++) {
         memset(tr[i], , sizeof(tr[i]));
         val[i] = e[i] = fail[i] = len[i] = ;
     }
     last = tot = ;
     tp = ;
     return;
 }

 void DFS(int x, int p) {
     stk[++top] = x;
     /// calc ans x
     //printf("x = %d \n", x);
     while(p < top && len[stk[p + ]] *  <= len[x]) {
         ++p;
     }
     if(vis[x] == Time) {
         ans = 1ll * ans * (val[stk[p]] + ) % 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 + );
     n = strlen(str + );
     /*if(n <= 200) {
         bf::solve();
         return;
     }*/
     ++Time;
     ans = ;
     for(register int i(); i <= n; i++) {
         insert(str[i] - 'a');
     }
     for(register int i(); i <= tot; i++) {
         add(fail[i], i);
     }

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

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

AC代码

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