【BZOJ1125】【POI2008】poc - splay+哈希

题意：

Description

n列火车，每条有l节车厢。每节车厢有一种颜色（用小写字母表示）。有m次车厢交换操作。求：对于每列火车，在交换车厢的某个时刻，与其颜色完全相同的火车最多有多少。

Input

n l m (2 ≤ n ≤ 1000, 1 ≤ l ≤ 100, 0 ≤ m ≤ 100000) n行字符串，长度为l

m行，每行4个数a b c d,a车的第b个字符与c车第d个字符交换。

Output

n个数，在交换车厢的某个时刻，与该车颜色完全相同的火车最多数目。

题解：

由于$l$很小，可以直接哈希判断两列火车是否相同；

用splay来维护所有火车的哈希值，每次交换操作直接删除两个串的哈希值，交换字符重新计算哈希值后再插入即可；

每次下传标记的时候把哈希值相同的一段打上标记更新答案；

注意当交换的两个字符在同一个串中时要特殊处理，防止被删两次；

时间复杂度$O((l+logn)m)$

然而说起来很简单但我每次写平衡树都要调至少1h /微笑

代码：

 #include<algorithm>
 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<cmath>
 #include<queue>
 #define inf 2147483647
 #define eps 1e-9
 #define H 173
 using namespace std;
 typedef unsigned long long ll;
 typedef double db;
 struct node{
     int son[],fa,siz;
 }t[];
 int n,l,m,x,y,a,b,rt,cnt=,ans[],tag[];
 ll pw[],hs[];
 char s[][];
 bool Son(int u){
     return t[t[u].fa].son[]==u;
 }
 void pushup(int u){
     t[u].siz=t[t[u].son[]].siz+t[t[u].son[]].siz+;
 }
 void pd(int u){
     if(tag[u]){
         ans[t[u].son[]]=max(ans[t[u].son[]],tag[u]);
         tag[t[u].son[]]=max(tag[t[u].son[]],tag[u]);
         ans[t[u].son[]]=max(ans[t[u].son[]],tag[u]);
         tag[t[u].son[]]=max(tag[t[u].son[]],tag[u]);
         tag[u]=;
     }
 }
 void rotate(int u){
     int f=t[u].fa,ff=t[f].fa,ch=Son(u),cf=Son(f);
     pd(f);
     pd(u);
     t[f].son[ch]=t[u].son[ch^];
     t[t[f].son[ch]].fa=f;
     t[ff].son[cf]=u;
     t[u].son[ch^]=f;
     t[u].fa=ff;
     t[f].fa=u;
     pushup(f);
     pushup(u);
 }
 void splay(int u,int to){
     for(;t[u].fa!=to;rotate(u)){
         int f=t[u].fa;
         if(t[f].fa!=to)rotate(Son(u)^Son(f)?u:f);
     }
     if(!to)rt=u;
 }
 int getpre(ll x){
     int nw=rt,u=rt;
     for(;nw;){
         if(x>hs[nw]){
             u=nw;
             nw=t[nw].son[];
         }else nw=t[nw].son[];
     }
     return u;
 }
 int getnxt(ll x){
     int nw=rt,u;
     for(;nw;){
         if(x<hs[nw]){
             u=nw;
             nw=t[nw].son[];
         }else nw=t[nw].son[];
     }
     return u;
 }
 int nxt(int u){
     int nw=t[u].son[];
     while(t[nw].son[])nw=t[nw].son[];
     return nw;
 }
 void ins(int x){
     int u=getpre(hs[x]),v=getnxt(hs[x]);
     splay(u,);
     splay(v,u);
     t[x].son[]=t[v].son[];
     t[t[x].son[]].fa=x;
     t[v].son[]=x;
     t[x].fa=v;
     pushup(x);
     pushup(v);
     pushup(u);
     ans[x]=max(ans[x],t[x].siz);
     tag[x]=max(tag[x],t[x].siz);
 }
 void del(int x){
     splay(x,);
     int u=nxt(x);
     splay(u,x);
     rt=u;
     t[u].son[]=t[x].son[];
     t[t[u].son[]].fa=u;
     t[u].fa=;
     pushup(u);
     t[x].son[]=t[x].son[]=;
     t[x].siz=;
 }
 void dfs(int u){
     pd(u);
     if(t[u].son[])dfs(t[u].son[]);
     if(t[u].son[])dfs(t[u].son[]);
 }
 int main(){
     scanf("%d%d%d",&n,&l,&m);
     pw[]=;
     for(int i=;i<=l;i++)pw[i]=pw[i-]*H;
     rt=n+;
     t[rt].siz=;
     hs[rt]=;
     t[rt].son[]=n+;
     t[n+].siz=;
     t[n+].fa=rt;
     hs[n+]=(1ll<<)-;
     for(int i=;i<=n;i++){
         scanf("%s",s[i]+);
         for(int j=;j<=l;j++){
             hs[i]=hs[i]*H+s[i][j];
         }
         ins(i);
     }
     for(int i=;i<=m;i++){
         scanf("%d%d%d%d",&x,&a,&y,&b);
         if(x==y){
             del(x);
             swap(s[x][a],s[x][b]);
             hs[x]=;
             for(int j=;j<=l;j++){
                 hs[x]=hs[x]*H+s[x][j];
             }
             ins(x);
         }else{
             del(x);
             del(y);
             swap(s[x][a],s[y][b]);
             hs[x]=hs[y]=;
             for(int j=;j<=l;j++){
                 hs[x]=hs[x]*H+s[x][j];
                 hs[y]=hs[y]*H+s[y][j];
             }
             ins(x);
             ins(y);
         }
     }
     dfs(rt);
     for(int i=;i<=n;i++){
         printf("%d\n",ans[i]);
     }
     return ;
 }