[CTSC2012]熟悉的文章 后缀自动机

题面：洛谷

题解：

　　观察到L是可二分的，因此我们二分L，然后就只需要想办法判断这个L是否可行即可。

　　因为要尽量使L可行，因此我们需要求出对于给定L，这个串最多能匹配上多少字符。

　　如果我们可以对每个位置i求出g[i]表示以这个位置为结尾，向前最多匹配多少位，就可以快速得知任意区间[l, r]是否可以被匹配上，因为一个串如果可以被匹配上，那么它的子串肯定也可以被匹配上。

　　然后我们再做一次DP，设f[i]为DP到i位，最多能匹配上多少字符

　　那么朴素做法就是枚举上一段的结尾，然后更新，不过注意到这个决策是单调的，因此可以用单调队列优化一下。

　　因为有g[i]和mid的限制，所以我们可以选取的上一段结尾的区间是[i - g[i], i - mid].

　　所以在用单调队列维护的时候，为了保证右端点合法，每次不能立即把当前的i加入队列，而是要在下次枚举到区间右端点已经包括了i的时候再把i加入队列。（类似与NOIP普及组跳房子）

　　

　　这样就可以O(n)的求解。

　　不过首先还需要求出g[i]....

　　那么g[i]怎么求呢？　　

　　我们先建立广义后缀自动机，然后在自动机上匹配大串，假设当前匹配到的节点是now，上一次的长度是rnt。

　　那么我们只有沿着parent树向上走，才可以保证l[当前节点]是合法的。

　　因此我们不断向上走，每走到一个节点，都更新rnt = l[now], 直到走到一个节点使得它有当前字符对应的边，这个时候我们把rnt更新为rnt+1,并更新g数组

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

 int n, m, tail, head, len;
 int g[AC], f[AC], q[AC];//g[i]表示以i为结尾，最长能匹配的长度
 char s[AC];//f[i]表示DP到i位，能被覆盖的最大长度

 inline int read()
 {
     int x = ;char c = getchar();
     while(c > '' || c < '') c = getchar();
     while(c >= '' && c <= '') x = x *  + c - '', c = getchar();
     return x;
 }

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

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

     void add(int c)
     {
         int p = last, np = ++ cnt;
         last = cnt, l[np] = l[p] + ;
         for( ; !ch[p][c]; p = fa[p]) ch[p][c] = np;
         if(!p) fa[np] = ;
         else
         {
             int q = ch[p][c];//找到对应节点
             if(l[p] +  == l[q]) fa[np] = q;
             else
             {
                 int nq = ++ cnt;
                 l[nq] = l[p] + ;
                 memcpy(ch[nq], ch[q], sizeof(ch[q]));
                 fa[nq] = fa[q];
                 fa[q] = fa[np] = nq;
                 for( ; ch[p][c] == q; p = fa[p]) ch[p][c] = nq;
             }
         }
     }

     void build()
     {
         cnt = ;
         for(R i = ; i <= m; i ++)
         {
             last = , scanf("%s", s + ), len = strlen(s + );
             for(R j = ; j <= len; j ++) add(s[j] - '');
         }
     }

     void get_g()//求g数组
     {
         int now = , rnt = ;
         /*for(R i = 1; i <= len; i ++)
         {//要先更新g再向下跳，因为根据parent树的性质，只有从一个点向上走才能保证
             int v = s[i] - '0';//这个点中出现的串在遇到的点中都出现了，如果先向下走了就无法保证了
             while(now != 1 && !ch[now][v]) now = fa[now];//一直向上跳到可以匹配为止
             if(ch[now][v]) g[i] = l[now] + 1, now = ch[now][v];
         }*/
         for(R i = ; i <= len; i ++)
         {
             int v = s[i] - '';//因为当前点是上一个点往下走走到的， 所以当前点的l[now]其实不一定合法。。。只能保证l[fa[now]]合法
             while(now !=  && !ch[now][v]) now = fa[now], rnt = l[now];//因此如果这个点是有v这个节点的话，也不能直接取l[now],
             if(ch[now][v]) g[i] = ++rnt, now = ch[now][v];//而是要保留上次的匹配长度
             else g[i] = , rnt = ;
             //printf("%d ", g[i]);
         }
         //printf("\n");
     }
 }sam;

 void pre()
 {
     n = read(), m = read();
     sam.build();
 }

 bool check(int mid)//上一段结尾区间[i - g[i], i - mid]
 {
     int last = ;
     head = tail = ;
     for(R i = ; i <= len; i ++)
     {
         f[i] = f[i - ];//因为如果强制取区间内的值，就相当于强制当这个点必须能产生贡献就产生贡献，但是实际上不产生贡献，直接取f[i -1]可能会更优
         if(i - g[i] > i - mid) continue;//如果没有合法区间就只能这样了
         while(last < i - mid)//每次加入不能超过右区间以保证合法
         {
             ++ last;
             while(head <= tail && f[q[tail]] - q[tail] < f[last] - last) -- tail;
             q[++ tail] = last;
         }
         while(head <= tail && q[head] < i - g[i]) ++ head;//把不属于合法区间的都去掉
         //printf("%d ", q[head]);//去掉非法区间的应该放在后面，因为后面还有加点操作，可能会加入非法节点
         upmax(f[i], f[q[head]] + i - q[head]);
     }
     //printf("\n");
     return f[len] *  >= len * ;
 }

 int half()//l显然满足可二分性
 {
     int l = , r = len, mid;
     while(l < r)
     {
         mid = (l + r + ) >> ;
         if(check(mid)) l = mid;
         else r = mid - ;
     }
     return l;
 }

 void work()
 {
     for(R i = ; i <= n; i ++)
     {
         scanf("%s", s + ), len = strlen(s + );
         sam.get_g(), printf("%d\n", half());
         //for(R j = 1; j <= n; j ++) g[j] = f[j] = 0;
     }
 }

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