[COCI2011-2012#5] POPLOCAVANJE 后缀自动机

题面：洛谷

题解：

　　其实还可以用AC自动机做，但是没调出来，，，不知道发生了什么。。。

　　AC自动机做法如下：

　　　　观察到如果我们对给定的每个串建AC自动机，那么直接拿大串在上面匹配，如果遇到了一个单词的终止节点，假设当前大串的位置是i，匹配到的节点是j，那么这个单词覆盖了

　　　　[i - dep[j] + 1, i]这个区间（dep[j]即为单词长度）

　　　　但是我们发现空间根本开不下。

　　　　因为对每个串分别匹配不会影响结果，所以考虑每50个串我们重建一次AC自动机，然后匹配一次。

　　　　匹配中的每次区间修改都用差分维护，那么最后对于每个权值大于等于1的位置都统计1 的贡献即为答案。

　　后缀自动机做法如下：

　　　　考虑统计对于每个位置而言，以i为结尾的最长被覆盖的长度

　　　　我们对大串建立后缀自动机，然后对于每个小串都拿去自动机上匹配。假设我们最后匹配到的状态为x，既然这个状态已经被覆盖了，那么x在parent树上的子树也一定可以被覆盖。

　　　　但是要对每个状态内的最长串长度MAXS取min，因为匹配到一个状态只能代表可以覆盖这个状态所代表的子串，且长度不能大于当前给定图案（小串）的长度。

　　　　那么我们对每次匹配到的状态x打上标记，标记权值为当前小串的长度，如果有多个标记，取最大的那个。

　　　　最后统计打完所有标记之后，对于每个节点都下传标记，下传的过程中依然对标记权值取max。

　　　　最后即可得到对于每个位置而言，以i为结尾的最长被覆盖的长度。

　　　　

　　　　一个快速（好写）统计的方法：

　　　　　　因为对于每个点下传标记就相当于对每个点接收来自它父亲的标记，那么我们只需要保证在接收点x的父亲的标记时，fa[x]已经接收过来自fa[fa[x]]的标记。

　　　　　　因此我们按bfs序来更新标记就可以了，因为l[fa[x]](l[i]表示状态i的MAXS，即最长的保证right集合不变的长度)一定小于l[x]，所以我们按照l[x]的大小来确定顺序即可。

　　

 #include<bits/stdc++.h>
 using namespace std;
 #define R register int
 #define AC 301000
 #define ac 601000

 int n, m, ans;
 int b[AC], k[ac];
 int d[AC], mark[ac];//差分数组
 char s[AC];

 inline void upmax(int &a, int b){
     if(b > a) a = b;
 }

 struct sam_atm{
     int last, cnt;
     int ch[ac][], fa[ac], l[ac], right[ac];

     inline void add(int c, int i)
     {
         int p = last, np = ++ cnt;
         last = np, l[np] = l[p] + , right[np] = i;
         for( ; p && !ch[p][c]; p = fa[p]) ch[p][c] = np;
         if(!p) fa[np] = ;
         else
         {
             int q = ch[p][c];//获取第一个有c的节点的对应边所指向的节点
             if(l[p] +  == l[q]) fa[np] = q;//如果不会造成影响，那么就直接连fa
             else
             {
                 int nq = ++ cnt;//否则就再建新点
                 l[nq] = l[p] + ;
                 memcpy(ch[nq], ch[q], sizeof(ch[q]));//把q的信息赋值给nq,,,接下来nq相当于要取代q了
                 fa[nq] = fa[q], fa[q] = fa[np] = nq;
                 for( ; ch[p][c] == q; p = fa[p]) ch[p][c] = nq;
             }
         }
     }

     void find()
     {
         int len = strlen(s + ), now = ;
         for(R i = ; i <= len; i ++)
         {
             if(!ch[now][s[i] - 'a']) return ;
             now = ch[now][s[i] - 'a'];
         }
         upmax(mark[now], len);
     }

     void work()
     {
         for(R i = ; i <= cnt; i ++) ++ b[l[i]];
         for(R i = ; i <= n; i ++) b[i] += b[i - ];//这里只需要枚举到n，多枚举就re了
         for(R i = ; i <= cnt; i ++) k[b[l[i]] --] = i;//为i赋b[l[i]]的排名
         for(R i = ; i <= cnt; i ++) upmax(mark[k[i]], mark[fa[k[i]]]);        

         for(R i = ; i <= cnt; i ++) //只能用有right的叶子节点更新
             if(right[i]) ++ d[right[i] - mark[i] + ], -- d[right[i] + ];
         for(R i = ; i <= n; i ++) d[i] += d[i - ];
         for(R i = ; i <= n; i ++) ans += (d[i] > );
         printf("%d\n", n - ans);
     }
 }T;

 void pre()
 {
     T.last = T.cnt = ;//这个又忘了。。。
     scanf("%d%s", &n, s + );
     for(R i = ; i <= n; i ++) T.add(s[i] - 'a', i);
     scanf("%d", &m);
     for(R i = ; i <= m; i ++) scanf("%s", s + ), T.find();
 }

 int main()
 {
 //    freopen("in.in", "r", stdin);
     pre();
     T.work();
 //    fclose(stdin);
     return ;
 }