BZOJ1396: 识别子串（后缀自动机，线段树）

Description

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树内的节点对应子串是唯一识别的，那么其|Right|必定=1，那么对应一个|Right|=1的节点

因为Parent树上的节点是其子节点的后缀，而Parent树是逆序的，所以一棵|Right|=1的子树内结尾是一定的，设为endpos。

那么在一个|Right|=1的节点内其有效压缩长度为len-len[fa],那么这段子串可以认为是等价唯一的。其长度为其到endpos的距离。

而在len[fa]以下的，识别长度太小必须使用len[fa]为最小识别长度。

区间修改当然要线段树了。

在len[fa]~len区间内，其答案为endpos-pos+1。

在1~len[fa]区间内，其答案为len[fa]

pos是与位置有关的变量最后算。

只需将endpos-1,len[fa]推入线段树好了

代码：

(不要问我为什么上次拓扑这次建边因为我闲的）

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define lll spc<<1
 #define rrr spc<<1|1
 struct sant{
     int tranc[];
     int len;
     int pre;
 }s[];
 struct pnt{
     int hd;
     int wgt;
     int endp;
 }p[];
 struct ent{
     int twd;
     int lst;
 }e[];
 struct trnt{
     int minval;
     int lzt;
     bool al;
 };
 int cnt;
 int siz;
 int fin;
 int n;
 char tmp[];
 class Sgmt_tree{
     public:
         void res(void)
         {
             for(int i=;i<;i++)
                 tr[i].lzt=tr[i].minval=0x3f3f3f3f;
             return ;
         }
         void pushup(int spc)
         {
             tr[spc].minval=std::min(tr[lll].minval,tr[rrr].minval);
             return ;
         }
         void Add(int spc,int x)
         {
             tr[spc].minval=std::min(tr[spc].minval,x);
             tr[spc].lzt=std::min(tr[spc].lzt,x);
             tr[spc].al=true;
             return ;
         }
         void pushdown(int spc)
         {
             if(tr[spc].al)
             {
                 Add(lll,tr[spc].lzt);
                 Add(rrr,tr[spc].lzt);
                 tr[spc].al=false;
             }
             return ;
         }
         void update(int l,int r,int ll,int rr,int spc,int v)
         {
             if(l>rr||ll>r)
                 return ;
             if(ll<=l&&r<=rr)
             {
                 Add(spc,v);
                 return ;
             }
             int mid=(l+r)>>;
             pushdown(spc);
             update(l,mid,ll,rr,lll,v);
             update(mid+,r,ll,rr,rrr,v);
             pushup(spc);
             return ;
         }
         int query(int l,int r,int pos,int spc)
         {
             if(l==r)
                 return tr[spc].minval;
             int mid=(l+r)>>;
             pushdown(spc);
             if(pos<=mid)
                 return query(l,mid,pos,lll);
             else
                 return query(mid+,r,pos,rrr);
         }
     private:
         trnt tr[];
 }T[];
 void Insert(int c,int w)
 {
     int nwp,nwq,lsq,lsp;
     nwp=++siz;
     p[nwp].wgt=;
     p[nwp].endp=w;
     s[nwp].len=s[fin].len+;
     for(lsp=fin;lsp&&!s[lsp].tranc[c];lsp=s[lsp].pre)
         s[lsp].tranc[c]=nwp;
     if(!s[lsp].tranc[c])
         s[lsp].tranc[c]=nwp;
     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[nwp].pre=s[lsq].pre=nwq;
             while(s[lsp].tranc[c]==lsq)
             {
                 s[lsp].tranc[c]=nwq;
                 lsp=s[lsp].pre;
             }
         }
     }
     fin=nwp;
     return ;
 }
 void ade(int f,int t)
 {
     cnt++;
     e[cnt].twd=t;
     e[cnt].lst=p[f].hd;
     p[f].hd=cnt;
     return ;
 }
 void Dfs(int x)
 {
     for(int i=p[x].hd;i;i=e[i].lst)
     {
         int to=e[i].twd;
         Dfs(to);
         p[x].wgt+=p[to].wgt;
         p[x].endp=std::min(p[x].endp,p[to].endp);
     }
     if(p[x].wgt==)
     {
         int minlen=s[s[x].pre].len+;
         int maxlen=s[x].len;
         int endpos=p[x].endp;
         T[].update(,n,endpos-maxlen+,endpos-minlen+,,endpos+);
         T[].update(,n,endpos-minlen+,endpos,,minlen);
     }
     return ;
 }
 int main()
 {
     scanf("%s",tmp+);
     n=strlen(tmp+);
     for(int i=;i<=n;i++)
         Insert(tmp[i]-'a',i);
     for(int i=;i<=siz;i++)
         ade(s[i].pre,i);
     T[].res();
     T[].res();
     Dfs();
     for(int i=;i<=n;i++)
     {
         int ans1,ans2;
         ans1=T[].query(,n,i,)-i;
         ans2=T[].query(,n,i,);
         printf("%d\n",std::min(ans1,ans2));
     }
     return ;
 }