3682: Phorni 后缀平衡树 线段树

国际惯例的题面:

考虑如果没有强制在线我们能怎么水掉这个题，先构造出字符串，各种方法求一下后缀数组，然后线段树维护区间rank最小的位置即可。
然而他要求强制在线，支持插入后缀，并比较后缀大小(求rank)的数据结构，当然就是后缀平衡树啦。
于是插入字符串的操作，我们只需要在后缀平衡树上插入这个后缀。此时不需要对线段树进行修改，因为线段树中任何一个位置均不包含新插入的这个后缀(保证信息合法)。
什么你说插入会改变每个后缀的rank值？没关系我们不需要知道每个后缀的rank具体是多少，我们只需要它们的相对大小关系，这个显然是不会改变的是吧。
(你还不明白？先去A了"Bzoj3600: 没有人的算术"再说。什么你A了还不明白？丢人！褪裙吧！)
然后对线段树的修改和查询就显然了。
(话说这题treap不旋比旋转快，替罪羊alpha设为1最快，某大佬裸BST直接AC都是什么鬼啊)

代码:

 #include<cstdio>
 #include<algorithm>
 #include<cctype>
 const int maxe=1e6+1e2;
 const double alpha = 0.85;

 char in[maxe];
 int at[maxe]; // suffix i's node .
 double v[maxe];

 struct SuffixBalancedTree { // we should insert 0 as the minimal suffix .
     int lson[maxe],rson[maxe],siz[maxe],sf[maxe],root,cnt;
     int seq[maxe],sql;
     int fail,failfa;
     double vfl,vfr;

     inline bool cmp(int x,int y) {
         if( !x || !y ) return !x;
         if( in[x] != in[y] ) return in[x] < in[y];
         else return v[at[x-]] < v[at[y-]];
     }
     inline void upgrade(int pos,double l,double r) {
         siz[pos] = siz[lson[pos]] + siz[rson[pos]] + ;
         if( std::max( siz[lson[pos]] , siz[rson[pos]] ) > siz[pos] * alpha ) fail = pos , failfa = - , vfl = l , vfr = r;
         else if( fail == lson[pos] || fail == rson[pos] ) failfa = pos;
     }
     inline void insert(int &pos,double l,double r,const int &id) {
         if( !pos ) {
             v[at[id]=pos=++cnt]= ( l + r ) / 2.0 , siz[pos] =  , sf[pos] = id;
             return;
         } const double vmid = ( l + r ) / 2.0;
         if( cmp(sf[pos],id) ) insert(rson[pos],vmid,r,id) , upgrade(pos,l,r); // id > sf[pos] .
         else insert(lson[pos],l,vmid,id) , upgrade(pos,l,r);
     }
     inline int rebuild(int ll,int rr,double l,double r) {
         const int mid = ( ll + rr ) >>  , pos = seq[mid];
         const double vmid = ( l + r ) / 2.0; v[pos] = vmid , siz[pos] = rr - ll + ;
         if( ll < mid ) lson[pos] = rebuild(ll,mid-,l,vmid);
         if( mid < rr ) rson[pos] = rebuild(mid+,rr,vmid,r);
         return pos;
     }
     inline void dfs(int pos) {
         if(lson[pos]) dfs(lson[pos]);
         seq[++sql] = pos;
         if(rson[pos]) dfs(rson[pos]);
         lson[pos] = rson[pos] = siz[pos] = ;
     }
     inline void insert(const int &id) {
         fail =  , failfa = - , insert(root,,,id);
         if(fail) {
             sql =  , dfs(fail);
             if( ~failfa ) {
                 if( fail == lson[failfa] ) lson[failfa] = rebuild(,sql,vfl,vfr);
                 else rson[failfa] = rebuild(,sql,vfl,vfr);
             } else root = rebuild(,sql,,);
         }
     }
 }sbt;

 int cov[maxe>>];

 struct SegmentTree {
     int mx[maxe<<];
     #define lson(pos) (pos<<1)
     #define rson(pos) (pos<<1|1)
     inline bool cmp(int a,int b) {
         if( cov[a] == cov[b] ) return a < b;
         return v[at[cov[a]]] < v[at[cov[b]]];
     }
     inline void upgrade(int pos) {
         mx[pos] = cmp(mx[lson(pos)],mx[rson(pos)]) ? mx[lson(pos)] : mx[rson(pos)];
     }
     inline void build(int pos,int l,int r) {
         if( l == r ) return void( mx[pos] = l );
         const int mid = ( l + r ) >> ;
         build(lson(pos),l,mid) , build(rson(pos),mid+,r) , upgrade(pos);
     }
     inline void update(int pos,int l,int r,const int &tar) {
         if( l == r ) return; // nothing to update .
         const int mid = ( l + r ) >> ;
         if( tar <= mid ) update(lson(pos),l,mid,tar);
         else update(rson(pos),mid+,r,tar);
         upgrade(pos);
     }
     inline int query(int pos,int l,int r,const int &ll,const int &rr) {
         if( ll <= l && r <= rr ) return mx[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);
         const int ql = query(lson(pos),l,mid,ll,rr) , qr = query(rson(pos),mid+,r,ll,rr);
         return cmp(ql,qr) ? ql : qr;
     }
 }sgt;

 inline char nextchar() {
     static const int BS =  << ;
     static char buf[BS],*st=buf+BS,*ed=st;
     if( st == ed ) ed = buf + fread(st=buf,,BS,stdin);
     return st == ed ? - : *st++;
 }
 inline void getstr(char* s) {
     char c;
     while( !isalpha(c=nextchar()) );
     do *s++=c; while( isalpha(c=nextchar()) );
 }
 inline char realchar() {
     char c;
     while( !isalpha(c=nextchar()) );
     return c;
 }
 inline int getint() {
     int ret =  , ch;
     while( !isdigit(ch=nextchar()) );
     do ret=ret*+ch-''; while( isdigit(ch=nextchar()) );
     return ret;
 }

 int main() {
     static int n,m,len,tpe,lastans;
     n = getint() , m = getint() , len = getint() , tpe = getint() , getstr(in+) , std::reverse(in+,in++len);
     for(int i=;i<=len;i++) in[i] -= 'a' , sbt.insert(i);
     for(int i=;i<=n;i++) cov[i] = getint();
     sgt.build(,,n);
     for(int i=,o,c,x,l,r;i<=m;i++) {
         o = realchar();
         if( o == 'I' ) {
             c = getint();
             if( tpe ) c ^= lastans;
             in[++len] = c , sbt.insert(len);
         } else if( o == 'C' ) x = getint() , cov[x] = getint() , sgt.update(,,n,x);
         else if( o == 'Q' ) l = getint() , r = getint() , printf("%d\n",lastans=sgt.query(,,n,l,r));
     }
     return ;
 }

思い出して 優しいハウリング
回忆起 温柔的振鸣
奏でる声 未来を示してた
演奏之声 昭示了未来
思い出して 優しいハウリング
回忆起 温柔的共鸣
遅くはない そう教えてくれた
永远不会太迟 你是这样教我的
今までの過ちすべて
至今经历的一切
巻き戻すことなんて出来はしない
已不能倒带
間違いを認める勇気
不懂得承认错误的勇气
知らなかったよ 凄く不器用に 生きてた
十分笨拙的生存着