看毛片就能AC算法

KMP && ACA

KMP:

吼哇！

反正网上教程满天飞，我就不写了。

发个自己写的模板

  /**
     freopen("in.in", "r", stdin);
     freopen("right.out", "w", stdout);
 */
 //// /////////////////////////////
 #include <cstdio>
 #include <string>
 #include <iostream>
 using std::string;
 const int N = ;

 int nex[N];

 int main() {
     freopen("in.in", "r", stdin);
     freopen("right.out", "w", stdout);
     string s, p;
     std::cin >> s >> p;

     nex[] = ;
     for(int i = , j = ; i < p.size(); i++) {
         while(j && p[i] != p[j]) {
             j = nex[j - ];
         }
         if(p[i] == p[j]) j++;

         /// while(j && p[i + 1] == p[j]) j = nex[j - 1];
         /// 十分失败的优化，反例：
         /// acccc
         /// ccc
         /// 001  :next
         /// 可以看出能匹配两个串，但是这个优化只能算出一个来

         nex[i] = j;
     }

     for(int i = , j = ; i < s.size(); i++) {
         while(j && s[i] != p[j]) {
             j = nex[j - ];
         }
         if(s[i] == p[j]) j++;
         if(j == p.size()) {
             printf("%d\n", i - j + );
             j = nex[j - ];
         }
     }

     for(int i = ; i < p.size(); i++) {
         printf("%d ", nex[i]);
     }

     return ;
 }

KMP模板 洛谷P3375

例题：

剪花布条

A + B for you again

Period

Milking Grid

业界大毒瘤动物园

AC自动机：

就是KMP上trie，用以解决多串匹配问题。

当我花几天的时间理解KMP之后，AC自动机也就很显然了(这怎么就显然了？)

想当我学KMP满大街找教程，现在学AC自动机教程还没看完就懂了...所以说基础很重要。

大致想象一下就行了。直接发代码吧。

 #include <cstdio>
 #include <string>
 #include <iostream>
 #include <queue>
 #include <cstring>
 const int N = ;

 using std::string;

 struct AC {
     int root, tot;
     int tr[N][], nex[N], ed[N];
     bool vis[N];
     AC() {
         root = ;
         tot = ;
     }
     void clear() {
         for(int i = ; i <= tot; i++) {
             nex[i] = ed[i] = ;
             for(int j = ; j < ; j++) {
                 tr[i][j] = ;
             }
         }
         return;
     }

     inline void insert(string x) {
         int p = root;
         for(int i = ; i < x.size(); i++) {
             int f = x[i] - 'a';
             if(!tr[p][f]) {
                 tr[p][f] = ++tot;
             }
             p = tr[p][f];
         }
         ed[p]++;
         return;
     }
     void getnex() {
         nex[root] = root;
         std::queue<int> Q;
         Q.push(root);
         while(!Q.empty()) {
             int x = Q.front();
             Q.pop();
             for(int i = ; i < ; i++) {
                 int y = tr[x][i];
                 if(y) {
                     int j = nex[x];
                     while(j != root && !tr[j][i]) {
                         j = nex[j];
                     }
                     if(tr[j][i] && x != root) {
                         j = tr[j][i];
                     }
                     nex[y] = j;
                     Q.push(y);
                 }
             }
         }
         return;
     }
     int solve(string x) {
         int ans = ;
         memset(vis, , (tot + ) * sizeof(bool));
         for(int i = , j = root; i < x.size(); i++)  {
             int f = x[i] - 'a';
             while(j != root && !tr[j][f]) {
                 j = nex[j];
             }
             if(tr[j][f])  {
                 j = tr[j][f];
             }
             if(ed[j] && !vis[j]) {
                 ans += ed[j];
                 vis[j] = ;
             }
         }
         return ans;
     }
 }ac;

 int main() {
     int n;
     scanf("%d", &n);
     string s;
     for(int i = ; i <= n; i++) {
         std::cin >> s;
         ac.insert(s);
     }
     ac.getnex();
     std::cin >> s;
     printf("%d", ac.solve(s));
     return ;
 }

洛谷P3808

 #include <cstdio>
 #include <string>
 #include <iostream>
 #include <queue>
 #include <cstring>
 const int N = ;

 using std::string;

 struct Ans {
     string s;
     int cnt;
 }a[N];

 struct AC {
     int root, tot;
     int tr[N][], nex[N], ed[N];
     AC() {
         root = ;
         tot = ;
     }
     void clear() {
         for(int i = ; i <= tot; i++) {
             nex[i] = ed[i] = ;
             for(int j = ; j < ; j++) {
                 tr[i][j] = ;
             }
         }
         tot = ;
         return;
     }

     inline void insert(string x, int k) {
         int p = root;
         for(int i = ; i < x.size(); i++) {
             int f = x[i] - 'a';
             if(!tr[p][f]) {
                 tr[p][f] = ++tot;
             }
             p = tr[p][f];
         }
         ed[p] = k;
         return;
     }
     void getnex() {
         nex[root] = root;
         std::queue<int> Q;
         Q.push(root);
         while(!Q.empty()) {
             int x = Q.front();
             Q.pop();
             for(int i = ; i < ; i++) {
                 int y = tr[x][i];
                 if(y) {
                     int j = nex[x];
                     while(j != root && !tr[j][i]) {
                         j = nex[j];
                     }
                     if(tr[j][i] && x != root) {
                         j = tr[j][i];
                     }
                     nex[y] = j;
                     Q.push(y);
                 }
             }
         }
         return;
     }
     void solve(string x) {
         for(int i = , j = root; i < x.size(); i++)  {
             int f = x[i] - 'a';
             while(j != root && !tr[j][f]) {
                 j = nex[j];
             }
             if(tr[j][f])  {
                 j = tr[j][f];
             }
             int jj = j;
             while(jj != root) {
                 if(ed[jj]) {
                     a[ed[jj]].cnt++;
                 }
                 jj = nex[jj];
             }
         }
         return;
     }
 }ac;

 int main() {
     int n;
     string x;
     while(scanf("%d", &n) && n) {
         ac.clear();
         for(int i = ; i <= n; i++) {
             std::cin >> a[i].s;
             ac.insert(a[i].s, i);
         }
         ac.getnex();
         std::cin >> x;
         ac.solve(x);
         int large = -;
         for(int i = ; i <= n; i++) {
             large = std::max(large, a[i].cnt);
         }
         printf("%d\n", large);
         for(int i = ; i <= n; i++) {
             if(a[i].cnt == large) {
                 std::cout << a[i].s << std::endl;
             }
         }
         for(int i = ; i <= n; i++) {
             a[i].cnt = ;
         }
     }
     return ;
 }

洛谷P3796

重点在于getnex()函数。别的依题意稍作修改即可。

第二题有个优化：ed[nex[jj]]可能为0，会额外增加跳的次数。解决办法是搞一个g数组出来表示ed[]不为0的某个nex。

被之前失败的优化经历搞怕了，没用...

KMP与AC自动机的小差异：(在我的模板中)

KMP初始化的nex[0] = 0，而AC自动机的初始化nex[root]  =  root;

KMP中的nex[i]表示最长匹配数，是比下标多1的，而AC自动机中直接指向一个节点。