[hdu 4416]Good Article Good sentence

最近几天一直在做有关后缀自动机的题目

感觉似乎对后缀自动机越来越了解了呢！喵~

这题还是让我受益颇多的，首先搞一个后缀自动机是妥妥的了

可是搞完之后呢？

我们来观察 step 这个变量，每个节点的 step 是从根节点到此节点所经过的最长步数

那么也就是以该点为结尾的最长的后缀长度

如何统计不被 Bi 串包含的子串呢？

其实很简单，维护每个节点所能匹配的最长的字符串长度

然后 节点->step-max(该节点所能匹配的最长的字符串长度, 节点->fail->step) 就是答案了

因为 S[0..节点->step-1] 必是原串的一个后缀，而 节点所能匹配的最长字符串长度 d 说明 S[节点->step-d..节点->step-1] 是出现在了某个 Bi 串中的

只不过把每个串在自动机上跑一遍并不能得到每个节点所能匹配的最长长度

因为当该节点被匹配时，该结点的 fail 指针所指向的节点也必然被匹配到了

我们需要一个拓扑排序，按拓扑序来更新答案，并同时更新每个节点的 fail 指针指向的点的匹配长度

教练，我不想写拓扑排序~

我才不会说按 step 从大到小的顺序就是拓扑序呢喵~

namespace 写写被 hdu 怒骂 TLE TAT ，这是多么痛的领悟……

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #define ord(ch) ((ch)-'a')
 typedef long long llint;
 const int sizeOfString=;
 const int sizeOfMemory=<<;
 const int sizeOfType=;

 inline int max(int x, int y) {return x>y?x:y;}

 struct node
 {
     int step;
     int same;
     node * fail;
     node * ch[sizeOfType];
 };
 node memory[sizeOfMemory]; int port;
 node * dfa=memory, * last;
 inline node * newnode(node * t=NULL)
 {
     node * newt=memory+(port++);
     newt->step=;
     newt->same=;
     if (t) newt->fail=t->fail, t->fail=newt, memcpy(newt->ch, t->ch, sizeof t->ch);
     else newt->fail=NULL, memset(newt->ch, , sizeof newt->ch);
     return newt;
 }
 inline void insert(int w)
 {
     node * p=last, * newp=newnode();
     newp->step=p->step+;

     for ( ;p->ch[w]==NULL;p=p->fail) p->ch[w]=newp;
     if (p->ch[w]==newp)
         newp->fail=dfa;
     else
     {
         node * q=p->ch[w];
         if (q->step==p->step+)
             newp->fail=q;
         else
         {
             node * newq=newnode(q);
             newq->step=p->step+;
             newp->fail=newq;
             for ( ;p->ch[w]==q;p=p->fail) p->ch[w]=newq;
         }
     }

     last=newp;
 }
 inline void search(char * s)
 {
     int len=strlen(s);
     int tot=;
     node * t=dfa;
     for (int i=;i<len;i++)
     {
         int w=ord(s[i]);
         if (t->ch[w])
         {
             t=t->ch[w];
             t->same=max(t->same, ++tot);
         }
         else
         {
             node * j;
             for (j=t->fail;j!=dfa && !j->ch[w];j=j->fail);
             if (j->ch[w])
             {
                 t=j->ch[w];
                 t->same=max(t->same, tot=(j->step+));
             }
             else
             {
                 t=dfa;
                 tot=;
             }
         }
     }
 }
 inline llint calc(int len)
 {
     static node * p[sizeOfMemory];
     static int cnt[sizeOfString];
     llint ret=;

     memset(cnt, , sizeof(cnt));
     for (int i=;i<port;i++) cnt[dfa[i].step]++;
     for (int i=;i<=len;i++) cnt[i]+=cnt[i-];
     for (int i=;i<port;i++) p[--cnt[dfa[i].step]]=&dfa[i];
     for (int i=port-;i>;i--)
     {
         p[i]->fail->same=max(p[i]->fail->same, p[i]->same);
         if (p[i]->same<p[i]->step)
             ret+=p[i]->step-max(p[i]->same, p[i]->fail->step);
     }

     return ret;
 }

 int T, n;
 char str[sizeOfString], s[sizeOfString];

 int main()
 {
     int cases=;

     for (scanf("%d", &T);T;T--)
     {
         scanf("%d", &n);
         scanf("%s", str);
         port=; dfa=newnode(); dfa->fail=dfa; last=dfa;
         int len=strlen(str);
         for (int i=;i<len;i++)
             insert(ord(str[i]));
         for (int i=;i<=n;i++)
         {
             scanf("%s", s);
             search(s);
         }
         printf("Case %d: %I64d\n", ++cases, calc(len));
     }

     return ;
 }

本傻装B不成反被艹系列