BZOJ2806(后缀自动机+DP)

题目：http://61.187.179.132/JudgeOnline/problem.php?id=2806

 

题意：给定一个由M个01串组成的字典。依据这个字典和一个阀值L，可以断言一个01串是否"熟悉"，其定义是：

把一个串划分成若干段，如果某个段的长度不小于L，且是字典中的某个串的连续子串，则这个段可识别；如果对于给出的串，

存在一个划分，使得可识别的长度不小于总长度的90%，则这串是"熟悉"的。先后给出N个01串。对于每个给出的串，求使得该

串"熟悉"的最大的L值。如果这样的L值不存在，输出0。 输入数据总长<=1100000。

 

 

分析：后缀自动机是用来求出给定文章最长的在模板中出现的字串的长度。把文章在模板上匹配就行了，记录每一位的最大匹

配长度就行了。然后我们二分答案，然后按照答案的限制求得最大匹配字符数。dp的方程很容易求得：f[i]=max{f[j]+i-

j}。然后，假设二分的答案是limit，某位置的最大匹配长度是v[i]，决策区间就是[i-v[i]，i-limit]，由于i-limit是

逐步增加的，那么每一次只需要往队列里添加i-limit这个点，然后判断队首是否在决策区间里，即是否q[head]>=i-v[i]。

那么此时单调队列里的元素都在决策区间里。这样就可以用队首元素的到最优的f[i]了。最后判断一下是否满足比例大于等于

0.9即可。

 

#include <iostream>
#include <string.h>
#include <algorithm>
#include <stdio.h>

using namespace std;
const int N=2500005;

struct State
{
    State *pre,*go[3];
    int step;
    void clear()
    {
        pre=0;
        step=0;
        memset(go,0,sizeof(go));
    }
}*root,*last;

State statePool[N*2],*cur;

void init()
{
    cur=statePool;
    root=last=cur++;
    root->clear();
}

void Insert(int w)
{
    State *p=last;
    State *np=cur++;
    np->clear();
    np->step=p->step+1;
    while(p&&!p->go[w])
        p->go[w]=np,p=p->pre;
    if(p==0)
        np->pre=root;
    else
    {
        State *q=p->go[w];
        if(p->step+1==q->step)
            np->pre=q;
        else
        {
            State *nq=cur++;
            nq->clear();
            memcpy(nq->go,q->go,sizeof(q->go));
            nq->step=p->step+1;
            nq->pre=q->pre;
            q->pre=nq;
            np->pre=nq;
            while(p&&p->go[w]==q)
                p->go[w]=nq, p=p->pre;
        }
    }
    last=np;
}

char str[N];
int q[N],dp[N],v[N];
int n,m;

void match(char *str)
{
    int len=strlen(str);
    State *p=root;
    int cnt=0;
    for(int i=0;i<len;i++)
    {
        int x=str[i]-'0';
        if(p->go[x])
        {
            cnt++;
            p=p->go[x];
        }
        else
        {
            while(p&&!p->go[x]) p=p->pre;
            if(p->go[x]) cnt=p->step+1,p=p->go[x];
            else         cnt=0,p=root;
        }
        v[i+1]=cnt;
    }
}

bool Judge(int limit,int len)
{
    dp[0]=q[0]=0;
    int head=1,tail=0,p;
    for(int i=1;i<=len;i++)
    {
        dp[i]=dp[i-1];
        p=i-limit;
        if(p>=0)
        {
            while(head<=tail&&dp[p]-p > dp[q[head]]-q[head]) tail--;
            q[++tail]=p;
        }
        while(head<=tail&&q[head]<i-v[i]) head++;
        if(head<=tail) dp[i]=max(dp[i],dp[q[head]]+i-q[head]);
    }
    return 10*dp[len]>=9*len;
}

int main()
{
    init();
    scanf("%d%d",&n,&m);
    while(m--)
    {
        scanf("%s",str);
        int len=strlen(str);
        for(int i=0;i<len;i++)
            Insert(str[i]-'0');
        Insert(2);
    }
    while(n--)
    {
        scanf("%s",str);
        int len=strlen(str);
        match(str);
        int l=0,r=len,ans=0;
        while(l<=r)
        {
            int mid=(l+r)>>1;
            if(Judge(mid,len))
            {
                l=mid+1;
                ans=mid;
            }
            else r=mid-1;
        }
        printf("%d\n",ans);
    }
    return 0;
}