Bzoj2534:后缀自动机 主席树启发式合并

国际惯例的题面:

考虑我们求解出字符串uvu第一个u的右端点为i，第二个u的右端点为j，我们需要满足什么性质？
显然j>i+L，因为我们选择的串不能是空串。
另外考虑i和j的最长公共前缀(也就是说其parent树上lca的len)，为了保证他们相同，我们需要:
j-len>=i-L。
整理一下，如果我们已知i，j需要在区间[i+L+1,i+L+len]中。
如果我们已知j，i需要在区间[j-L-len,j-L-1]中。
于是我们可以写n^2暴力了:暴力维护parent上每个节点的right集合，对于每个i，暴力向上跳，暴力找可行的j。
然后我们发现，维护right集合可以用主席树启发式合并做，对于计算贡献，我们可以先枚举lca，然后计算有多少组可行的i，j。
在第二个计算的时候，我们显然是会在两颗主席树进行合并的时候进行计算，于是我们可以把较小的那颗拍扁，在另外一棵里暴力查询每一个值的贡献。
这样总复杂度O(nlog^2n)，轻松AC。
注意主席树启发式合并的时间和空间复杂度都是O(nlog^n)的，因为考虑每层摊还下来只会被新建logn次(我已经把长度和节点个数乘起来了)。
另外这题字符集大小为全体可见字符，所以需要用map存后缀自动机。
(不是很明白为什么网上那么多题解都是后缀数组的，明明后缀自动机这么好写(不会后缀数组的就不要说话了.jpg))

代码:

 #include<cstdio>
 #include<cstring>
 #include<map>
 #include<queue>
 using namespace std;
 const int maxn=1e5+1e2,maxl=;

 char in[maxn>>];
 int li,lim;
 int seq[maxn>>],seqlen;
 long long ans;

 struct PersistentSegmentTree {
     int lson[maxn*maxl<<],rson[maxn*maxl<<],siz[maxn*maxl<<],cnt;
     inline void insert(int &pos,int l,int r,int tar) {
         if( !pos ) pos = ++cnt; siz[pos] = ;
         if( l == r ) return;
         const int mid = ( l + r ) >> ;
         if( tar <= mid ) insert(lson[pos],l,mid,tar);
         else insert(rson[pos],mid+,r,tar);
     }
     inline int merge(int p1,int p2,int l,int r) {
         if( ! ( siz[p1] && siz[p2] ) ) return siz[p1] ? p1 : p2;
         int ret = ++cnt; siz[ret] = siz[p1] + siz[p2];
         if( l == r ) return ret;
         const int mid = ( l + r ) >> ;
         lson[ret] = merge(lson[p1],lson[p2],l,mid) ,
         rson[ret] = merge(rson[p1],rson[p2],mid+,r) ;
         return ret;
     }
     inline int query(int pos,int l,int r,const int &ll,const int &rr) {
         if( !pos ) return ;
         if( ll <= l && r <= rr ) return siz[pos];
         const int mid = ( l + r ) >> ;
         if( rr <= mid ) return query(lson[pos],l,mid,ll,rr);
         else if( ll > mid ) return query(rson[pos],mid+,r,ll,rr);
         return query(lson[pos],l,mid,ll,rr) + query(rson[pos],mid+,r,ll,rr);
     }
     inline void dfs(int pos,int l,int r) {
         if( !pos ) return;
         if( l == r ) return void(seq[++seqlen]=l);
         const int mid = ( l + r ) >> ;
         dfs(lson[pos],l,mid) , dfs(rson[pos],mid+,r);
     }
     inline int getsiz(int pos) {
         return siz[pos];
     }
 }segt;

 namespace SAM {
     int fa[maxn],len[maxn],deg[maxn],last,root,cnt;
     int rit[maxn],roots[maxn];
     map<int,int> ch[maxn];
     inline int NewNode(int ll) {
         len[++cnt] = ll;
         return cnt;
     }
     inline int extend(int x,int rr) {
         int p = last;
         int np = NewNode(len[p]+); rit[np] = rr;
         while( ch[p].find(x) == ch[p].end() ) ch[p][x] = np , p = fa[p];
         if( !p ) fa[np] = root;
         else {
             int q = ch[p][x];
             if( len[q] == len[p] +  ) fa[np] = q;
             else {
                 int nq = NewNode(len[p]+);
                 ch[nq] = ch[q] , fa[nq] = fa[q];
                 fa[np] = fa[q] = nq;
                 while( p && ch[p][x] == q ) ch[p][x] = nq , p = fa[p];
             }
         }
         return last = np;
     }
     inline int query(int root,int i,int samelen) {
         if( samelen <  ) return ;
         int ret = segt.query(root,,li,i+lim+,i+lim+samelen);
         if( i - lim -  >  ) ret += segt.query(root,,li,i-lim-samelen,i-lim-);
         return ret;
     }
     inline void topo() {
         for(int i=;i<=cnt;i++) if( fa[i] ) ++deg[fa[i]];
         queue<int> q;
         for(int i=;i<=cnt;i++) if( !deg[i] ) q.push(i);
         while( q.size() ) {
             const int pos = q.front(); q.pop();
             if( pos == root ) continue;
             if( rit[pos] ) {
                 ans += query(roots[pos],rit[pos],len[pos]);
                 int t = ; segt.insert(t,,li,rit[pos]);
                 roots[pos] = segt.merge(roots[pos],t,,li);
             }
             if( segt.getsiz(roots[fa[pos]]) < segt.getsiz(roots[pos]) ) // We won't use roots[pos] again .
                 swap(roots[fa[pos]],roots[pos]);
             seqlen =  , segt.dfs(roots[pos],,li);
             for(int i=;i<=seqlen;i++) ans += query(roots[fa[pos]],seq[i],len[fa[pos]]);
             roots[fa[pos]] = segt.merge(roots[fa[pos]],roots[pos],,li);
             if( !--deg[fa[pos]] ) q.push(fa[pos]);
         }
     }
 }

 int main() {
     scanf("%d%s",&lim,in+) , li = strlen(in+);
     SAM::last = SAM::root = SAM::NewNode();
     for(int i=;i<=li;i++) SAM::extend(in[i],i);
     SAM::topo();
     printf("%lld\n",ans);
     return ;
 }