[CTSC 2012][BZOJ 2806]Cheat

真是一道好题喵~

果然自动机什么的就是要和 dp 搞基才是王道有木有！

A:连 CTSC 都叫我们搞基，果然身为一个程序猿，加入 FFF 团是我此生最明智的选择。妹子什么闪边去，大家一起来搞基吧！

Q:教练你是什么时候产生了 dp 和自动机是同性的错觉~　教练你又是什么时候产生了你还有个不入团的选择 ( 妹 子 )这样的错觉~

A:显而易见的，我们……

Q:教练不要转移话题啊！

A:显而易见的，我们先搞一个后缀自动机……

Q:等等，教练，多串的自动机要怎么写？

A:把几个串并在一起不就好了？

Q:不对啊，那查询的时候万一查到两个串相连的地方，不是悲剧了？

A:你傻啊！搞个分割符什么的不就解决了？！

Q:教练我的分割符是用 $ 还是用 # 呢？

(旁白:当然是 $ 了，$ 可是美金的意思，# 算什么，电话号码吗？)

A:。。。。。。

搞出了后缀自动机，就像我们经常做的一样，把每个节点能匹配的最长长度搞出来    (Q:我没文化你也不能这么逗我！)

把字串 S 在第 i 位能匹配到的最长长度 same[i] 搞出来

考虑二分答案L

就有了个显而易见的 dp 转移方程:

f[i]=max{f[j]-j+i | i-same[i]<=j<=i-L}

然后题目就被妥妥的解决了

Q:不对啊教练，这 dp 是 O(n²) 的！

f[i]=max{f[j]-j+i | i-same[i]<=j<=i-L}  ↔  f[i]-i=max{f[j]-j | i-same[i]<=j<=i-L}

A:这显然是单调的，优化优化就 O(n) 了

Q:教练求证明……

A:这个显然嘛，显然……要不然这题还怎么做额？

Q:教练……

A:烦死了，你打个表不就行了！

 #include <cstdio>
 #include <cstring>
 #include <cmath>
 const int sizeOfType=;
 const int sizeOfString=;
 const int sizeOfMemory=; 

 inline void getstring(char * s)
 {
     register char ch;
     register int top=;
     do ch=getchar(); while (ch<'' || ch>'');
     do s[top++]=ch, ch=getchar(); while (ch>='' && ch<='');
     s[top]='\0';
 }

 struct deque
 {
     int l, r;
     int q[sizeOfString];
     inline deque():l(), r(-) {}
     inline void clear() {l=, r=-;}
     inline bool empty() {return l>r;}
     inline int front() {return q[l];}
     inline int back() {return q[r];}
     inline void push(int x) {q[++r]=x;}
     inline void pop_front() {++l;}
     inline void pop_back() {r--;}
 };

 int N, M;
 int len;
 int same[sizeOfString];
 char str[sizeOfString];
 deque q;
 int f[sizeOfString], g[sizeOfString];
 inline int max(int x, int y) {return x>y?x:y;}
 inline void dp(int);

 namespace suffixAutomaton
 {
     struct node
     {
         int step;
         node * fail;
         node * ch[sizeOfType];
     };
     node memory[sizeOfMemory], * port=memory;
     node * dfa, * last;
     inline node * newnode(node * t=NULL)
     {
         node * newt=port++;
         newt->step=;
         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 clear() {port=memory; dfa=newnode(); dfa->fail=dfa; last=dfa;}

     inline int ord(char ch) {return ch>=''?ch-'':;}
     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 buildDfa()
     {
         static char s[sizeOfString];
         int len;

         clear();
         for (int i=;i<M;i++)
         {
             getstring(s); len=strlen(s);
             for (int j=;j<len;j++)
                 insert(ord(s[j]));
             insert(ord('$'));
         }
     }
     inline void search(char * 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];
                 ++tot;
             }
             else
             {
                 node * j;
                 for (j=t->fail;j!=dfa && !j->ch[w];j=j->fail);
                 if (j->ch[w])
                 {
                     t=j->ch[w];
                     tot=j->step+;
                 }
                 else
                 {
                     t=dfa;
                     tot=;
                 }
             }
             same[i]=tot;
         }
     }
 }

 int main()
 {
     scanf("%d %d", &N, &M);
     suffixAutomaton::buildDfa();
     for (int i=;i<=N;i++)
     {
         getstring(str);
         len=strlen(str);
         suffixAutomaton::search(str);

         int L=, R=len+;
         while (L+<R)
         {
             int M=(L+R)>>;
             dp(M);
             if (*f[len]>=*len) L=M;
             else R=M;
         }

         printf("%d\n", L);
     }

     return ;
 }
 inline void dp(int L)
 {
     q.clear();

     for (int i=;i<=len;i++)
     {
         int j=i-L;
         if (j>=)
         {
             for ( ;!q.empty() && g[j]>g[q.back()];q.pop_back());
             q.push(j);
         }
         f[i]=f[i-];
         for ( ;!q.empty() && q.front()<i-same[i];q.pop_front());
         if (!q.empty())
             f[i]=max(f[i], g[q.front()]+i);
         g[i]=f[i]-i;
     }
 }

本傻乱搞系列

后记:

话说我根本不知道如何证明单调性，但是大家注意到这是类似于一个一直在往右移动的窗口(不要问我为什么 i-same[i] 是单增的，事实如此)

移动的窗口，求窗口中最大的数……很眼熟啊！经验和直觉都告诉我们这就是单调队列……

大家理性理解一下就好，就好~