Codeforces 917F Substrings in a String - 后缀自动机 - 分块 - bitset - KMP

题目传送门

　　传送点I

　　传送点II

　　传送点III

题目大意

　　给定一个字母串，要求支持以下操作：

1. 修改一个位置的字母
2. 查询一段区间中，字符串$s$作为子串出现的次数

Solution 1 Bitset

　　每次匹配一段，可以看成，依次考虑每个位置，匹配的位置对应的起点取交集。例如：

　　大概就这个意思。

　　bitset的count似乎很慢，可以用__builtin_popcount来数中间的位数，然后暴力数两端的位数会快很多。感觉手写倍增法数位数最快。但有人说前面那个内联函数比手写的$O(\log \log n)$的速度要快。

Code

 /**
  * Codeforces
  * Problem#914F
  * Accepted
  * Time: 2760ms
  * Memory: 4300k
  */
 #include <bits/stdc++.h>
 using namespace std;
 typedef bool boolean;

 const int N = 1e5 + , alpha = ;

 int n, m;
 char str[N], buf[N];
 bitset<N> ch[alpha], ans;

 inline void init() {
     scanf("%s", str + );
     n = strlen(str + );
     for (int i = ; i <= n; i++)
         ch[str[i] - 'a'][i] = ;
     scanf("%d", &m);
 }

 inline void solve() {
     int opt, x, y, len;
     while (m--) {
         scanf("%d%d", &opt, &x);
         if (opt == ) {
             scanf("%s", buf);
             ch[str[x] - 'a'][x] = , ch[buf[] - 'a'][x] = ;
             str[x] = buf[];
         } else {
             scanf("%d%s", &y, buf + );
             len = strlen(buf + );
             if (y - x +  < len) {
                 puts("");
                 continue;
             }
             ans.set();
             for (int i = ; i <= len; i++)
                 ans &= (ch[buf[i] - 'a'] >> (i - ));
 //            for (int i = 1; i <= n; i++)
 //                cerr << ans[i] << " ";
 //            cerr << endl;
 //            for (int i = 1; i <= n; i++)
 //                cerr << (ans >> (x - 1))[i];
 //            cerr << endl;
             int res = (ans >> x).count() - (ans >> (y - len + )).count();
             printf("%d\n", res);
         }
     }
 }

 int    main() {
     init();
     solve();
     return ;
 }

bitset

Solution 2 Suffix Automaton , Block Division & KMP

　　这个是出题人的本意。估计出题人没有想到这道题竟然可以直接被bitset水掉。

　　对于在线数一个串的出现次数，排除所有非后缀数据结构。

　　由于后缀数据结构都不支持中间带修。因此考虑分块。每一块维护一个SAM。

　　要求修改的时候暴力重构一个块的SAM。

　　暂且钦定块大小为$C = \sqrt{n}$。

• 如果询问的串长大于$C$，由于询问总串长和$n$同阶，所以这一部分的询问数不会超过$\sqrt{n}$个，所以直接暴力KMP，时间复杂度$O(n^{1.5})$
• 如果询问的串长小于等于$C$，两端涉及到的位置暴力KMP，块间暴力KMP，块内在SAM中查询。这一部分的时间复杂度也是$O(n^{1.5})$

　　所以总时间复杂度为$O(n^{1.5})$、

　　由于SAM自带常数$26$（字符集大小），所以跑着很慢，sad..另外暴力的过程最好老老实实写KMP，千万不要像我一样直接用SAM来代替，然后无限TLE。。

Code

 /**
  * Codeforces
  * Problem#917F
  * Accepted
  * Time: 2995ms
  * Memory: 28428k
  */
 #include <bits/stdc++.h>
 using namespace std;
 typedef bool boolean;

 typedef class TrieNode {
     public:
         int len, cnt;
         TrieNode* ch[];
 //        map<char, TrieNode*> ch;
         TrieNode* fail;
 }TrieNode;

 const int cs = , N = 1e5 + ;

 typedef class SuffixAutomaton {
     public:
         int maxlen;
         TrieNode* pool;
         int *cnt;
         TrieNode** sp;
         TrieNode *top;
         TrieNode *rt, *last;

         SuffixAutomaton(int maxlen = cs + ):maxlen(maxlen) {
             pool = new TrieNode[(maxlen *  + )];
             sp = new TrieNode*[(maxlen *  + )];
             cnt = new int[(maxlen + )];
         }

         TrieNode* newnode(int len) {
 //            top->ch.clear();
 //            cerr << top - pool << " " << maxlen << endl;
             memset(top->ch, , sizeof(top->ch));
             top->len = len, top->cnt = ;
             top->fail = NULL;
             return top++;
         }

         void reset() {
             top = pool;
             rt = newnode();
             last = rt;
         }

         void extend(char c) {
             int x = c - 'a';
             TrieNode* p = newnode(last->len + );
             while (last && !last->ch[x])
                 last->ch[x] = p, last = last->fail;
             if (!last)
                 p->fail = rt;
             else {
                 TrieNode *q = last->ch[x];
                 if (q->len == last->len + )
                     p->fail = q;
                 else {
                     TrieNode* nq = newnode(last->len + );
                     nq->fail = q->fail, p->fail = nq, q->fail = nq;
 //                    nq->ch = map<char, TrieNode*>(q->ch);
                     memcpy(nq->ch, q->ch, sizeof(nq->ch));
                     while (last && last->ch[x] == q)
                         last->ch[x] = nq, last = last->fail;
                 }
             }
             p->cnt++, last = p;
         }

         void rebuild(char* str, int l, int r) {
             reset();
             for (int i = l; i < r; i++)
                 extend(str[i]);
             memset(cnt, , sizeof(int) * (r - l + ));
             for (int i = ; pool + i < top; i++)    cnt[pool[i].len]++;
             for (int i = ; i <= r - l + ; i++)    cnt[i] += cnt[i - ];
             for (int i = ; pool + i < top; i++)
                 sp[(cnt[pool[i].len]--) - ] = pool + i;
             for (int i = top - pool - ; i > ; i--)    sp[i]->fail->cnt += sp[i]->cnt;
         }

         int query(char *str) {
             TrieNode* p = rt;
                for (int i = ; str[i] && p; i++)
                 p = p->ch[str[i] - 'a'];
             return (p) ? (p->cnt) : ();
         }
 }SuffixAutomaton;

 int n, m, cc = ;
 int f[N];
 char str[N], buf[N];
 SuffixAutomaton sam[N / cs + ];

 inline void init() {
     scanf("%s", str);
     n = strlen(str);
     for (int i = cs; i < n; i += cs, cc++)
         sam[cc].reset(), sam[cc].rebuild(str, i - cs, i);
     scanf("%d", &m);
 }

 #define pick(p) ((l <= p && r >= p) ? (S[p]) : (0))

 int brute(char* S, char* T, int l, int r, int lenT) {
     r += ;
     if (r - l < lenT)    return ;
     f[] = f[] = ;
     for (int i = , j; i < lenT; i++) {
         j = f[i];
         while (j && T[i] != T[j])    j = f[j];
         f[i + ] = ((T[i] == T[j]) ? (j + ) : ());
     }
 //    for (int i = 0; i <= lenT; i++)
 //        cerr << f[i] << " ";
 //    cerr << endl;
     int rt = ;
     for (int i = l, j = ; i < r; i++) {
         while (j && T[j] != S[i])    j = f[j];
         if (T[j] == S[i])    j++;
         if (j == lenT)    rt++, j = f[j];
     }
     return rt;
 }

 inline void solve() {
     int opt, x, y, len, xi, yi;
     while (m--) {
         scanf("%d%d", &opt, &x);
         x--;
         if (opt == ) {
             scanf("%s", buf);
             xi = x / cs;
             str[x] = buf[];
             if (xi < cc)
                 sam[xi].rebuild(str, xi * cs, (xi + ) * cs);
         } else {
             scanf("%d%s", &y, buf);
             y -= , len = strlen(buf);
             if (y - x +  < len) {
                 puts("");
                 continue;
             }
             xi = x / cs, yi = y / cs;
             int res = ;
             if (len >= cs || xi == yi || xi == yi - )
                 res = brute(str, buf, x, y, len);
             else {
                 res = brute(str, buf, x, xi * cs + cs + len - , len);
                 res += brute(str, buf, yi * cs - len + , y, len);
                 for (int i = xi + ; i < yi; i++)
                     res += sam[i].query(buf);
                 for (int i = xi + ; i < yi; i++)
                     res += brute(str, buf, i * cs - len + , i * cs + len - , len);
             }
             printf("%d\n", res);
         }
     }
 }

 int main() {
     init();
     solve();
     return ;
 }