[CTSC 2012] Cheat

[题目链接]

https://www.lydsy.com/JudgeOnline/problem.php?id=2806

[算法]

首先建立广义后缀自动机

注意到问题具有单调性 ， 不妨对于每组询问二分答案mid

如何检验?

记fi表示前i个字符最多能选几个 ， 有转移方程 ：

fi = max{ fi - 1 , fj + i - j } (i - maxlen[i] <= j <= i - mid)

其中maxlen[i]表示第i个字符向前最多可匹配多少个字符

i - maxlen[i]单调递增 , i - mid同样单调递增

单调队列优化即可

时间复杂度 : O(NlogN)

[代码]

#include<bits/stdc++.h>
using namespace std;
#define N 1100010
 
int n , m , L;
int dp[N] , maxlen[N] , q[N];
char s[N];
 
#define rint register int
 
struct Suffix_Automaton
{
    int sz , last;
    int father[N] , child[N][] , depth[N];
    Suffix_Automaton()
    {
        sz = ;
        last = ;
    }
    inline int new_node(int dep)
    {
        depth[++sz] = dep;
        return sz;
    }
    inline void extend(int ch)
    {
        int np = new_node(depth[last] + );
        int p = last;
        while (child[p][ch] == )
        {
            child[p][ch] = np;
            p = father[p];
        }
        if (child[p][ch] == np) father[np] = ;
        else
        {
            int q = child[p][ch];
            if (depth[q] == depth[p] + ) father[np] = q;
            else
            {
                int nq = new_node(depth[p] + );
                father[nq] = father[q];
                father[np] = father[q] = nq;
                memcpy(child[nq] , child[q] , sizeof(child[q]));
                while (child[p][ch] == q)
                {
                    child[p][ch] = nq;
                    p = father[p];
                }
            }
        }
        last = np;
      }
      inline void match()
      {
              int now =  , mxlen = ;
              for (rint i = ; i <= L; ++i)
            {
                    int nxt = s[i] - '';
                          while (now !=  && !child[now][nxt]) now = father[now] , mxlen = depth[now];
                if (child[now][nxt])
                {
                    ++mxlen;
                    now = child[now][nxt];
                } else
                {
                    mxlen = ;
                    now = ;
                }
                maxlen[i] = mxlen;
            }
            }
} SAM;
 
inline void chkmin(int &x , int y)
{
        x = min(x , y);
}
inline void chkmax(int &x , int y)
{
    x = max(x , y);
}
inline bool check(int mid)
{
    int l =  , r = ;
    for (rint i = ; i < mid; ++i) dp[i] = ;
    for (rint i = mid; i <= L; ++i)
    {
        while (l <= r && dp[q[r]] - q[r] <= dp[i - mid] - i + mid) --r;
        q[++r] = i - mid;
        while (l <= r && q[l] < i - maxlen[i]) ++l;
        dp[i] = dp[i - ];
        if (l <= r) chkmax(dp[i] , dp[q[l]] - q[l] + i);
    }
    return dp[L] *  >=  * L;
}
 
int main()
{
 
    scanf("%d%d" , &n , &m);
    int mxl = ;
    for (rint i = ; i <= m; ++i)
    {
        scanf("%s" , s + );
                L = strlen(s + );
                chkmax(mxl , L);
                for (rint j = ; j <= L; ++j) SAM.extend(s[j] - '');
                SAM.extend();
    }
    for (rint i = ; i <= n; ++i)
    {
        scanf("%s" , s + );
        int l =  , r = strlen(s + ) , ans = ;
                L = r;
                chkmin(r , mxl);
        int now =  , mxlen = ;
        SAM.match();
        while (l <= r)
        {
            int mid = (l + r) >> ;
            if (check(mid))
            {
                ans = mid;
                l = mid + ;
            } else r = mid - ;
        }
        printf("%d\n" , ans);
    }
 
    return ;
}