BZOJ 1014 JSOI2008 火星人prefix Splay+Hash+二分

题目

给定字符串，三种操作：
1. 询问
语法：Q x y，x,y均为正整数；
功能：计算LCQ(x, y)；
限制：1 <= x, y <= 当前字符串长度。
2. 修改
语法：R x d，x是正整数，d是字符；
功能：将字符串中第x个数修改为字符d；
限制：x不超过当前字符串长度；
3. 插入
语法：I x d，x是非负整数，d是字符；
功能：在字符串第x个字符之后插入字符d，如果x = 0，则在字符串开头插入；
限制：x不超过当前字符串长度。

对于100%的数据，满足：
1. 所有字符串自始至终都只有小写字母构成。
2. M <= 150,000
3. 字符串长度L自始至终都满足L <= 100,000
4. 询问操作的个数不超过10,000个。

分析

对于静态求LCQ，可以使用后缀数组等字符串数据结构维护；也可以快速求Hash值，然后二分答案求解；
这里的快速求Hash值，可以直接求前缀和的区间减法做到$O(n\log n)$的复杂度，也可以弄个ST表之类的区间加法做到$O(n\log^2 n)$；
现在就是要求动态维护LCQ，SA显然不行，考虑动态维护Hash值。

涉及到区间询问，又涉及到插入操作。

首先我想到的是块状链表……
应该可以卡时过，但是就懒得写了……

正解应该是用Splay维护字符串和Hash值。

Splay的每一个节点有以下6个域：
l，r，f：左儿子，右儿子，父亲；
num：当前位置的字母对应的值；
size：子树大小（用于Hash值的计算和查找第k个位置）；
h：子树的Hash值；

对于询问操作Q x y：
二分答案mid；
找到x将它旋转到根上，找到x+len-1将它旋转到根上，得到Hash值S1；
找到x将它旋转到根上，找到x+len-1将它旋转到根上，得到Hash值S2；
比较S1，S2是否相同，不相同r=mid-1，否则l=mid+1；

对于修改操作R x d：
找到位置x进行修改，再进行一次splay操作；

对于插入操作I x y：
找到位置x进行修改，在进行一次splay操作；

我写的Splay一共有以下几个操作：
void rr(int now);
void rl(int now);
void Splay(int now,int &goal);
void Push_up(int now);
int Ins(int now,int k,int w);
int Find(int now,int k);
int Change(int now,int k,int w);

250行……
不知道hzwer的125行是怎么做到的……

代码

#include <cstdio>
#include <cstring>
#include <cctype>
#include <algorithm>
using namespace std;

typedef unsigned long long uLint;
const int N=100001;
const int M=29;

struct S
{
    int f,l,r;
    int num;
    int size;
    uLint h;
}tr[N];
int tot,rt;

uLint p[N];

char s[N];
int len;

inline void Push_up(int now)
{
    tr[now].size=tr[tr[now].l].size+tr[tr[now].r].size+1;
    tr[now].h=tr[tr[now].r].h+(tr[now].num+tr[tr[now].l].h*M)*p[tr[tr[now].r].size];
}

int Ins(int &now,int k,int w)
{
    int t;
    if (!now)
    {
        t=now=++tot;
        tr[t].size=1;
        tr[t].num=w;
        tr[t].h=w;
    }
    else
    {
        if (k<=tr[tr[now].l].size)
        {
            t=Ins(tr[now].l,k,w);
            tr[tr[now].l].f=now;
        }
        else
        {
            t=Ins(tr[now].r,k-tr[tr[now].l].size-1,w);
            tr[tr[now].r].f=now;
        }
        Push_up(now);
    }
    return t;
}

inline void rl(int now)
{
    int v1=tr[now].r;
    int v2=tr[now].f;
    int v3=tr[v1].l;

    tr[v1].f=v2;
    tr[now].f=v1;
    tr[v3].f=now;

    if (tr[v2].l==now)
        tr[v2].l=v1;
    else tr[v2].r=v1;
    tr[v1].l=now;
    tr[now].r=v3;

    tr[v1].size=tr[now].size;   
    tr[v1].h=tr[now].h;
    Push_up(now);
}

inline void rr(int now)
{
    int v1=tr[now].l;
    int v2=tr[now].f;
    int v3=tr[v1].r;

    tr[v1].f=v2;
    tr[now].f=v1;
    tr[v3].f=now;

    if (tr[v2].l==now)
        tr[v2].l=v1;
    else tr[v2].r=v1;
    tr[v1].r=now;
    tr[now].l=v3;

    tr[v1].size=tr[now].size;
    tr[v1].h=tr[now].h;
    Push_up(now);
}

void Splay(int now,int* goal)
{
    int pre,pre2,w1,w2;
    for (;now!=*goal&&tr[now].f;)
    {
        pre=tr[now].f,pre2=tr[pre].f;
        w1=tr[pre].r==now;
        if (pre==*goal||!pre2)
            w1?rl(pre):rr(pre);
        else
        {
            w2=tr[pre2].r==pre;
            if (w1==w2)
            {
                w2?rl(pre2):rr(pre2);
                w1?rl(pre):rr(pre);
            }
            else
            {
                w1?rl(pre):rr(pre);
                w2?rl(pre2):rr(pre2);
            }
        }
    }
    *goal=now;
}

void Init(void)
{
    p[0]=1;
    for (int i=1;i<N;i++)
        p[i]=p[i-1]*M;

    scanf("%s",&s[1]);
    len=strlen(&s[1]);

    for (int i=1;i<=len;i++)
        Splay(Ins(rt,i-1,s[i]-'a'+1),&rt);
}

int m;

inline int Read(void)
{
    int x=0; char c=getchar();
    for (;!isdigit(c);c=getchar());
    for (;isdigit(c);c=getchar()) x=x*10+c-'0';
    return x;
}

int Find(int now,int k)
{
    if (k<=tr[tr[now].l].size)
        return Find(tr[now].l,k);
    k-=tr[tr[now].l].size;
    if (k==1) return now;
    k--;
    return Find(tr[now].r,k);
}

int Judge(int x,int y,int len)
{
    uLint s1,s2;
    Splay(Find(rt,x),&rt);
    if (len==1)
        s1=tr[rt].num;
    else
    {
        Splay(Find(rt,x+len-1),&(tr[rt].r));
        s1=tr[tr[rt].r].num+M*tr[tr[tr[rt].r].l].h+tr[rt].num*p[1+tr[tr[tr[rt].r].l].size];
    }
    Splay(Find(rt,y),&rt);
    if (len==1)
        s2=tr[rt].num;
    else
    {
        Splay(Find(rt,y+len-1),&(tr[rt].r));
        s2=tr[tr[rt].r].num+M*tr[tr[tr[rt].r].l].h+tr[rt].num*p[1+tr[tr[tr[rt].r].l].size];
    }
    return s1==s2;
}

int Query(int x,int y)
{
    int l=1,r=tot-y+1,mid;
    for (;l<=r;)
    {
        mid=l+r>>1;
        Judge(x,y,mid)?l=mid+1:r=mid-1;
    }
    return r;
}

int Change(int now,int k,int w)
{
    int t;
    if (k<=tr[tr[now].l].size)
    {
        t=Change(tr[now].l,k,w);
        Push_up(now);
        return t;
    }
    else
    {
        k-=tr[tr[now].l].size;
        if (k==1)
        {
            tr[now].num=tr[now].h=w;
            return now;
        }
        else
        {
            k--;
            t=Change(tr[now].r,k,w);
            Push_up(now);
            return t;
        }
    }
}

void dfs(int now)
{
    if (!now) return;
    dfs(tr[now].l);
    printf("%c",tr[now].num+'a'-1);
    dfs(tr[now].r);
}

void Work(void)
{
    char c; int x; int y; char d;
    m=Read();
    for (int i=1;i<=m;i++)
    {
        scanf("\n"); c=getchar(); x=Read();
        if (c=='Q')
        {
            y=Read();
            if (x>y) swap(x,y);
            printf("%d\n",Query(x,y));
        }
        else
        if (c=='R')
        {
            d=getchar();
            Splay(Change(rt,x,d-'a'+1),&rt);
        }
        else
        if (c=='I')
        {
            d=getchar();
            Splay(Ins(rt,x,d-'a'+1),&rt);
        }
//      if (i==4) dfs(rt);
    }
}

int main(void)
{
//  freopen("a.in","r",stdin);
//  freopen("a.out","w",stdout);
    Init();
    Work(); 
    return 0;
}

小结

还需要多练几道平衡树，熟悉一下模板。
注意Splay操作中不一定旋转到根的写法。
这道题应该要再写一遍。