BZOJ1014:[JSOI2008]火星人(Splay,hash)

Description

　　火星人最近研究了一种操作：求一个字串两个后缀的公共前缀。比方说，有这样一个字符串：madamimadam，
我们将这个字符串的各个字符予以标号：序号： 1 2 3 4 5 6 7 8 9 10 11 字符 m a d a m i m a d a m 现在，
火星人定义了一个函数LCQ(x, y)，表示：该字符串中第x个字符开始的字串，与该字符串中第y个字符开始的字串
，两个字串的公共前缀的长度。比方说，LCQ(1, 7) = 5, LCQ(2, 10) = 1, LCQ(4, 7) = 0 在研究LCQ函数的过程
中，火星人发现了这样的一个关联：如果把该字符串的所有后缀排好序，就可以很快地求出LCQ函数的值；同样，
如果求出了LCQ函数的值，也可以很快地将该字符串的后缀排好序。 尽管火星人聪明地找到了求取LCQ函数的快速
算法，但不甘心认输的地球人又给火星人出了个难题：在求取LCQ函数的同时，还可以改变字符串本身。具体地说
，可以更改字符串中某一个字符的值，也可以在字符串中的某一个位置插入一个字符。地球人想考验一下，在如此
复杂的问题中，火星人是否还能够做到很快地求取LCQ函数的值。

Input

　　第一行给出初始的字符串。第二行是一个非负整数M，表示操作的个数。接下来的M行，每行描述一个操作。操
作有3种，如下所示
1、询问。语法：Qxy，x,y均为正整数。功能：计算LCQ(x,y)限制：1<=x,y<=当前字符串长度。
2、修改。语法：Rxd，x是正整数，d是字符。功能：将字符串中第x个数修改为字符d。限制：x不超过当前字
符串长度。
3、插入：语法：Ixd，x是非负整数，d是字符。功能：在字符串第x个字符之后插入字符d，如果x=0，则在字
符串开头插入。限制：x不超过当前字符串长度

Output

　　对于输入文件中每一个询问操作，你都应该输出对应的答案。一个答案一行。

Sample Input

madamimadam
7
Q 1 7
Q 4 8
Q 10 11
R 3 a
Q 1 7
I 10 a
Q 2 11

Sample Output

5
1
0
2
1

HINT

1、所有字符串自始至终都只有小写字母构成。

2、M<=150,000

3、字符串长度L自始至终都满足L<=100,000

4、询问操作的个数不超过10,000个。

对于第1，2个数据，字符串长度自始至终都不超过1,000

对于第3，4，5个数据，没有插入操作。

Solution

用splay维护hash值
当前点update的时候就用俩儿子的hash值计算一下字符串(左儿子+x+右儿子)新的hash值
hash一开始被卡了素质三连(模数1e4+7不被卡就有鬼了……)
中途有个变量打错了还过了样例emmm……
喜闻乐见样例是有多弱

Code

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #define N (200000+100)
 #define MOD (19260817)
 using namespace std;
 int Val[N],Size[N],Son[N][],Father[N],Sum[N],hash[N];
 int Root,n,m,x,y,p,sz;
 char opt[],ch[],a[N];

 int Get(int x) {return Son[Father[x]][]==x;}
 void Clear(int x) {Sum[x]=Father[x]=Son[x][]=Son[x][]=Size[x]=Val[x]=;}

 void Update(int x)
 {
     int l=Son[x][],r=Son[x][];
     Size[x]=Size[l]+Size[r]+;
     Sum[x]=((long long)Sum[l]*hash[Size[r]+]%MOD + (long long)Val[x]*hash[Size[r]+] + Sum[Son[x][]])%MOD;
 }

 void Rotate(int x)
 {
     int wh=Get(x);
     int fa=Father[x],fafa=Father[fa];
     Father[fa]=x;
     Son[fa][wh]=Son[x][wh^];
     if (Son[fa][wh]) Father[Son[fa][wh]]=fa;
     Father[x]=fafa;
     Son[x][wh^]=fa;
     if (fafa) Son[fafa][Son[fafa][]==fa]=x;
     Update(fa);
     Update(x);
 }

 void Splay(int x,int tar)
 {
     for (int fa; (fa=Father[x])!=tar; Rotate(x))
         if (Father[fa]!=tar)
             Rotate(Get(fa)==Get(x)?fa:x);
     if (!tar) Root=x;
 }

 int Findx(int x)
 {
     int now=Root;
     while ()
         if (Size[Son[now][]]>=x)
             now=Son[now][];
         else
         {
             x-=Size[Son[now][]];
             if (x==)
             {
                 Splay(now,);
                 return now;
             }
             x--;
             now=Son[now][];
         }
 }

 void Build(int l,int r,int fa)
 {
     if (l>r) return;
     int mid=(l+r)>>;
     Build(l,mid-,mid);
     Build(mid+,r,mid);
     Father[mid]=fa;
     Son[fa][mid>fa]=mid;
     Val[mid]=a[mid]-'a'+;
     Update(mid);
 }

 int Split(int x,int y)
 {
     int xx=Findx(x),yy=Findx(y);
     Splay(xx,);
     Splay(yy,xx);
     return Son[yy][];
 }

 bool check(int len)
 {
     int xx=Split(x,x+len+);
     int ans1=Sum[xx];
     int yy=Split(y,y+len+);
     int ans2=Sum[yy];
     return ans1==ans2;
 }

 int main()
 {
     hash[]=;
     for (int i=; i<=; ++i)
         hash[i]=hash[i-]*%MOD;

     scanf("%s%d",a+,&m);
     n=strlen(a+);
     Build(,n+,);
     Root=(n+)>>;
     sz=n+;

     for (int i=; i<=m; ++i)
     {
         scanf("%s",opt);
         if (opt[]=='Q')
         {
             scanf("%d%d",&x,&y);
             int l=,r=Size[Root]-max(x,y)-,ans=;
             while (l<=r)
                 if (check((l+r)>>))
                 {
                     l=((l+r)>>)+;
                     ans=l-;
                 }
                 else
                     r=((l+r)>>)-;
             printf("%d\n",ans);
         }
         if (opt[]=='R')
         {
             scanf("%d%s",&p,ch);
             Findx(p+);
             Val[Root]=ch[]-'a'+;
             Update(Root);
         }
         if (opt[]=='I')
         {
             scanf("%d%s",&p,ch);
             Split(p+,p+);
             int x=Son[Root][];
             Val[++sz]=ch[]-'a'+;
             Size[sz]=;
             Father[sz]=x;
             Son[x][]=sz;
             Splay(sz,);
         }
     }
 }