BZOJ3413: 匹配（后缀自动机，Parent树，线段树合并）

Description

Input

第一行包含一个整数n(≤100000)。

第二行是长度为n的由0到9组成的字符串。

第三行是一个整数m。

接下来m≤5·10行，第i行是一个由0到9组成的字符串s，保证单行字符串长度小于等于10^5，所有字符串长度和小于等于3·10^6

Output

输出m行，第i行表示第si和S匹配所比较的次数。

Sample Input

7
1090901
4
87650
0901
109
090

Sample Output

7
10
3
4

解题思路：

卡了我一天，我好弱啊

这道题需要在思路上做出一步转化，将分配次数分配到每个点上。

话句话说，假如说在模板串i位上匹配了f[i]次，那么答案就是sigma(f[i])。

那么就要求我们求出在每一位上的f[i]的值。

f[i]=在i上失配次数+在i上匹配成功次数，其中失配次数可以单独处理出来。

如果匹配永远不会成功，那么，我们可以知道，失配次数一定是n。

如果匹配在某一位成功，那么失配次数就是左端点右移次数。

那么成功次数呢？

可知，在完成匹配之后的部分，是不产生贡献的。

那么结果就是在一个Parent节点子树内的结束节点。

所以我们就需要维护一个集合，集合内包含所有Parent节点子树内的endpos。

这部分用线段树就好了，向上合并。

查询个数时只需要确定好上限。

查询结束位置时只需要进行后缀自动机匹配即可，记录最后一个节点并保证未失配。

再进行第二次匹配，只需要限制其上限，在线段树中查询个数就好了。

代码：

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 const int N=;
 const int S=;
 typedef long long lnt;
 struct sant{
     int tranc[];
     int len;
     int pre;
 }s[S];
 struct pnt{
     int hd;
     int root;
 }p[S];
 struct trnt{
     int ls;
     int rs;
     int sum;
 }tr[S<<];
 int cnt;
 int siz;
 int fin;
 int n,Q;
 int top;
 int size;
 char tmp[N];
 int topo[S];
 int has[S];
 int t;
 void pushup(int spc)
 {
     tr[spc].sum=tr[tr[spc].ls].sum+tr[tr[spc].rs].sum;
     return ;
 }
 int hav(int l,int r,int spc,int pos)
 {
     if(!spc)
         return ;
     if(l==r)
         return l;
     int mid=(l+r)>>;
     if(pos<=mid)
         return hav(l,mid,tr[spc].ls,pos);
     else
         return hav(mid+,r,tr[spc].rs,pos);
 }
 void update(int l,int r,int &spc,int pos)
 {

     if(!spc)
         spc=++size;
     tr[spc].sum++;
     if(l==r)
         return ;
     int mid=(l+r)>>;
     if(pos<=mid)
         update(l,mid,tr[spc].ls,pos);
     else
         update(mid+,r,tr[spc].rs,pos);
     return ;
 }
 int Merge(int spcf,int spcs)
 {
     if(!spcf||!spcs)
         return spcf+spcs;
     int spc=++size;
     tr[spc].sum=tr[spcf].sum+tr[spcs].sum;
     tr[spc].ls=Merge(tr[spcf].ls,tr[spcs].ls);
     tr[spc].rs=Merge(tr[spcf].rs,tr[spcs].rs);
     return spc;
 }
 int Minpos(int l,int r,int spc)
 {
     if(l==r)
         return l;
     int mid=(l+r)>>;
     if(tr[tr[spc].ls].sum)
         return Minpos(l,mid,tr[spc].ls);
     else
         return Minpos(mid+,r,tr[spc].rs);
 }
 lnt query(int l,int r,int spc,int lim)
 {
     if(l>lim||!spc)
         return ;
     if(l==r||r<=lim)
         return tr[spc].sum;
     int mid=(l+r)>>;
     return query(l,mid,tr[spc].ls,lim)+query(mid+,r,tr[spc].rs,lim);
 }
 void Insert(int c,int plc)
 {
     t=plc;
     int nwp,nwq,lsp,lsq;
     nwp=++siz;
     s[nwp].len=s[fin].len+;
     for(lsp=fin;lsp&&!s[lsp].tranc[c];lsp=s[lsp].pre)
         s[lsp].tranc[c]=nwp;
     if(!lsp)
         s[nwp].pre=;
     else{
         lsq=s[lsp].tranc[c];
         if(s[lsq].len==s[lsp].len+)
             s[nwp].pre=lsq;
         else{
             nwq=++siz;
             s[nwq]=s[lsq];
             s[nwq].len=s[lsp].len+;
             s[lsq].pre=s[nwp].pre=nwq;
             while(s[lsp].tranc[c]==lsq)
             {
                 s[lsp].tranc[c]=nwq;
                 lsp=s[lsp].pre;
             }
         }
     }
     fin=nwp;
     update(,n,p[fin].root,plc);
     return ;
 }
 int main()
 {
     fin=++siz;
     scanf("%d",&n);
     scanf("%s",tmp+);
     for(int i=;i<=n;i++)
         Insert(tmp[i]-'',i);
     for(int i=;i<=siz;i++)
         has[s[i].len]++;
     for(int i=;i<=siz;i++)
         has[i]+=has[i-];
     for(int i=;i<=siz;i++)
         topo[has[s[i].len]--]=i;
     for(int i=siz;i;i--)
     {
         int x=topo[i];
         if(x==)
             continue;
         p[s[x].pre].root=Merge(p[s[x].pre].root,p[x].root);
     }
     scanf("%d",&Q);
     while(Q--)
     {
         scanf("%s",tmp+);
         int len=strlen(tmp+);
         int root=;
         int endpos=0x3f3f3f3f;
         lnt ans=;
         for(int i=;i<=len;i++)
             root=s[root].tranc[tmp[i]-''];
         if(!root)
             ans=n;
         else{
             endpos=Minpos(,n,p[root].root);
             ans=endpos-len;
         }
         root=;
         for(int i=;i<=len;i++)
         {
             int c=tmp[i]-'';
             root=s[root].tranc[c];
             int tmp=ans;
             if(root)
                 ans+=query(,n,p[root].root,endpos+i-len);
             else
                 break;
         }
         printf("%lld\n",ans);
     }
     return ;
 }