bzoj1396&&2865 识别子串 后缀自动机+线段树

Input

一行,一个由小写字母组成的字符串S,长度不超过10^5

Output

L行,每行一个整数,第i行的数据表示关于S的第i个元素的最短识别子串有多长.

Sample Input

agoodcookcooksgoodfood

Sample Output

1
2
3
3
2
2
3
3
2
2
3
3
2
1
2
3
3
2
1
2
3
4

 

出现只有一次的是parent数上的叶子节点，endpos=1

所以只需要找endpos=1的节点minlen-maxlen之间对于一段的贡献放向去思考就可以了。

 

理解起来就是对于[endpos−maxlen+1,endpos−minlen+1][endpos−maxlen+1,endpos−minlen+1]中的每个子串都是单独存在的，所以这个RightRight集合贡献给他的答案就是这个点到endposendpos的长度。

对于[endpos−minlen,endpos][endpos−minlen,endpos]中的每个位置xx，贡献就是minlenminlen；

理解起来就是对于[endpos−minlen,endpos][endpos−minlen,endpos]中的每个子串显然是存在多个结束位置的，所以当前这个RightRight集合能够贡献给他的符合只出现一次且最短的，就是刚好跨过它的最小，即minlenminlen。

对于2865数据范围大了，而且还卡内存，不要面孔

纯自己手打

 #pragma GCC optimize(2)
 #pragma G++ optimize(2)
 #include<cstring>
 #include<cmath>
 #include<iostream>
 #include<algorithm>
 #include<cstdio>

 #define inf 1000000007
 #define N 200007
 using namespace std;
 inline int read()
 {
     int x=,f=;char ch=getchar();
     while(!isdigit(ch)){if(ch=='-')f=-;ch=getchar();}
     while(isdigit(ch)){x=(x<<)+(x<<)+ch-'';ch=getchar();}
     return x*f;
 }

 int n;
 char ch[N];

 struct segment_tree
 {
     int tree[N<<];
     inline void push_down(int p,int l,int r)
     {
         if(l==r)return;
         int ls=p<<,rs=p<<|;
         tree[ls]=min(tree[ls],tree[p]);
         tree[rs]=min(tree[rs],tree[p]);
     }
     void update(int p,int l,int r,int x,int y,int num)
     {
         if(x>y)return;
         push_down(p,l,r);
         if(l==x&&y==r)
         {
             tree[p]=min(tree[p],num);
             return;
         }
         int mid=(l+r)>>;
         if(y<=mid)update(p<<,l,mid,x,y,num);
         else if(x>mid)update(p<<|,mid+,r,x,y,num);
         else update(p<<,l,mid,x,mid,num),update(p<<|,mid+,r,mid+,y,num);
     }
     void build(int p,int l,int r)
     {
         if(l==r)
         {
             tree[p]=inf;
             return;
         }
         int mid=(l+r)>>;
         build(p<<,l,mid),build(p<<|,mid+,r);
         tree[p]=inf;
     }
     int query(int p,int l,int r,int x)
     {
         push_down(p,l,r);
         if(l==r)return tree[p];
         int mid=(l+r)>>;
         if(x<=mid) return query(p<<,l,mid,x);
         else return query(p<<|,mid+,r,x);
     }
 }A,B;
 struct sam
 {
     int last,cnt,rt;
     int fa[N],mx[N],c[N][];
     sam(){last=cnt=rt=;}
     void extend(int x)
     {
         int p=last,np=last=++cnt;mx[np]=mx[p]+;
         while(p&&!c[p][x])
         {
             c[p][x]=np;
             p=fa[p];
         }
         if(!p)fa[np]=rt;
         else
         {
             int q=c[p][x];
             if(mx[q]==mx[p]+)fa[np]=q;
             else
             {
                 int nq=++cnt;mx[nq]=mx[p]+;
                 memcpy(c[nq],c[q],sizeof(c[q]));
                 fa[nq]=fa[q];
                 fa[q]=fa[np]=nq;
                 while(c[p][x]==q)c[p][x]=nq,p=fa[p];
             }
         }
     }
     bool flag[N];
     void build()
     {
         memset(flag,true,sizeof(flag));
         for (int i=;i<=cnt;i++)
             flag[fa[i]]=false;
         for (int i=;i<=cnt;i++)
             if(flag[i])
             {
                 int l=mx[i]-mx[fa[i]],r=mx[i];
                 A.update(,,n,,l-,r+);
                 B.update(,,n,l,r,r-l+);
             }
     }
 }sam;
 void solve()
 {
     for (int i=;i<=n;i++)
         printf("%d\n",min(A.query(,,n,i)-i,B.query(,,n,i)));
 }
 int main()
 {
     freopen("fzy.in","r",stdin);
     freopen("fzy.out","w",stdout);
     scanf("%s",ch+);n=strlen(ch+);
     for (int i=;i<=n;i++)
         sam.extend(ch[i]-'a');
     A.build(,,n),B.build(,,n);
 //    cout<<1<<endl<<endl;
     sam.build(),solve();
 }