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(nlogn) 的複雜度，也可以弄個ST表之類的區間加法做到O(nlog2n) ；
現在就是要求動態維護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操作中不一定旋轉到根的寫法。
這道題應該要再寫一遍。