[BZOJ 3682]Phorni

后缀平衡树的模板题？ I'm so weak……

现在觉得替罪羊树比 treap 好写，是不是没救了喵～

#include <cstdio>
#include <cmath>
typedef unsigned long long LL;
const double a=0.55;
const LL inf=1ULL<<63;
const int sizeOfString=500005;
const int sizeOfTree=2100021;

inline int getint();
inline char getch();
inline int getstr(char * );
inline void putint(int);

int n, q, len, type;
char s[sizeOfString];
int P[sizeOfString];
inline void reverse();

struct node {int p, s; LL tag; node * c[2];};
node memory_node[sizeOfString], * port_node=memory_node;
node * root;
node * suf[sizeOfString];
inline node * newnode(int);
inline bool cmp(int, int);
inline bool cmp(node * , node * );
node * flatten(node * , node * );
node * build(node * , int);
void print(node * );
void rebuild(node *& );
void remark(node * , LL, LL);
bool insert(node *& , node * , LL=1, LL=inf, int=0);

struct seg {int p; seg * l, * r;};
seg memory_seg[sizeOfTree], * port_seg=memory_seg;
seg * t;
inline seg * newseg();
inline int min(int, int);
seg * build(int, int);
void update(seg * , int, int, int);
int query(seg * , int, int, int, int);

int main()
{
    int ans=0;
    char ch;
    int c, x, pos, l, r;

    n=getint(), q=getint(), len=getint(), type=getint();
    getstr(s);
    reverse();

    root=suf[0]=newnode(0);
    root->tag=(1+inf)>>1;
    for (int i=1;i<=len;i++)
    {
        suf[i]=newnode(i);
        insert(root, suf[i]);
    }

    for (int i=1;i<=n;i++) P[i]=getint();

    t=build(1, n);
    for (int i=1;i<=q;i++)
    {
        ch=getch();
        if (ch=='I')
        {
            c=getint(); if (type) c=c^ans;
            s[++len]=c+'a';
            suf[len]=newnode(len);
            insert(root, suf[len]);
        }
        if (ch=='C')
        {
            x=getint(); pos=getint();
            P[x]=pos;
            update(t, 1, n, x);
        }
        if (ch=='Q')
        {
            l=getint(); r=getint();
            ans=query(t, 1, n, l, r);
            putint(ans);
        }
    }

    return 0;
}
inline int getint()
{
    register int num=0;
    register char ch;
    do ch=getchar(); while (ch<'0' || ch>'9');
    do num=num*10+ch-'0', ch=getchar(); while (ch>='0' && ch<='9');
    return num;
}
inline char getch()
{
    register char ch;
    do ch=getchar(); while (ch!='I' && ch!='C' && ch!='Q');
    return ch;
}
inline int getstr(char * str)
{
    register int len=0;
    register char ch;
    do ch=getchar(); while (ch<'a' || ch>'z');
    do str[++len]=ch, ch=getchar(); while (ch>='a' && ch<='z');
    return len;
}
inline void putint(int num)
{
    char stack[11];
    register int top=0;
    for ( ;num;num/=10) stack[++top]=num%10+'0';
    for ( ;top;top--) putchar(stack[top]);
    putchar('
');
}
inline void reverse()
{
    static char t[sizeOfString];
    for (int i=1;i<=len;i++) t[i]=s[len-i+1];
    for (int i=1;i<=len;i++) s[i]=t[i];
}
inline node * newnode(int p)
{
    node * ret=port_node++;
    ret->p=p; ret->s=1;
    ret->tag=0LL;
    ret->c[0]=NULL; ret->c[1]=NULL;
    return ret;
}
inline bool cmp(int a, int b)
{
    return suf[a]->tag<suf[b]->tag;
}
inline bool cmp(node * a, node * b)
{
    return s[a->p]==s[b->p]?cmp(a->p-1, b->p-1):s[a->p]<s[b->p];
}
node * flatten(node * x, node * y)
{
    if (!x) return y;
    x->c[1]=flatten(x->c[1], y);
    return flatten(x->c[0], x);
}
node * build(node * x, int s)
{
    node * y, * z;
    if (!s) return x->c[0]=NULL, x;
    y=build(x, s>>1); z=build(y->c[1], s-1-(s>>1));
    y->c[1]=z->c[0]; z->c[0]=y;
    return z;
}
void rebuild(node *& t)
{
    static node temp;
    node * line;
    int n=t->s;
    line=flatten(t, &temp);
    build(line, n);
    t=temp.c[0];
}
void remark(node * t, LL l, LL r)
{
    LL m=(l+r)>>1;
    t->tag=m; t->s=1;
    if (t->c[0]) remark(t->c[0], l, m), t->s+=t->c[0]->s;
    if (t->c[1]) remark(t->c[1], m, r), t->s+=t->c[1]->s;
}
bool insert(node *& t, node * x, LL l, LL r, int d)
{
    LL m=(l+r)>>1;
    bool ret=false;
    if (!t) x->tag=m, t=x, ret=d>(log(root->s)/log(1.0/a));
    else
    {
        t->s++;
        if (cmp(t, x)) ret=insert(t->c[1], x, m, r, d+1);
        else ret=insert(t->c[0], x, l, m, d+1);
        if (ret) if ((t->c[0] && t->c[0]->s>a*t->s) || (t->c[1] && t->c[1]->s>a*t->s))
        {
            rebuild(t);
            remark(t, l, r);
            ret=false;
        }
    }
    return ret;
}
inline seg * newseg()
{
    seg * ret=port_seg++;
    ret->l=ret->r=NULL;
    return ret;
}
inline int min(int x, int y)
{
    if (suf[P[x]]->tag<=suf[P[y]]->tag) return x;
    return y;
}
seg * build(int l, int r)
{
    seg * t=newseg();
    if (l==r) return t->p=l, t;
    int m=(l+r)>>1;
    t->l=build(l, m); t->r=build(m+1, r);
    t->p=min(t->l->p, t->r->p);
    return t;
}
void update(seg * t, int l, int r, int p)
{
    if (l==r) return ;
    int m=(l+r)>>1;
    if (p<=m) update(t->l, l, m, p);
    else update(t->r, m+1, r, p);
    t->p=min(t->l->p, t->r->p);
}
int query(seg * t, int l, int r, int ql, int qr)
{
    if (l==ql && r==qr) return t->p;
    int m=(l+r)>>1;
    if (qr<=m) return query(t->l, l, m, ql, qr);
    else if (ql>=m+1) return query(t->r, m+1, r, ql, qr);
    return min(query(t->l, l, m, ql, m), query(t->r, m+1, r, m+1, qr));
}

到最后也没有搞清楚 zkw 炸在哪里……

大概是 zkw 查询时并不是顺序的缘故？