Hash

Hash

　　以前做普及试炼场的$Hash$部分是拿$Map$水过的...后来觉得还是应该学一下，发现比$Map$的用处多多啦！

　　Hash有很多种，对于字符串一般使用进制$Hash$，就是把字母映射到数字上，再将整个字符串转成一个高进制数比如$233$，再对一个大质数取模，从而将字符串变成一个数字。在实际应用中，有两种需求：

　　·懒得写取模(是有多懒),可以用$unsigned long long$保存$Hash$值，相当于对$2^{64}$取模；

　　·对正确性有着极高的要求：使用两个质数，同时求两个$Hash$值,只有两个值都相等时才判断为相等,这两个质数最好去成比较大又比较接近的两个数,出现$Hash$冲撞的概率就非常低了.一本通上给出了一对很好的双$Hash$模数---孪生质数:$10^9+7,10^9+9$

　　最近发现字符串类的题目还是用$char$数组比较方便,不容易出一些奇奇怪怪的错误,下面是使用字符数组做Hash题目的一些常用操作:

　　头文件部分:　

# include <cstring>
  2 # include <string>
  3 # define ULL unsigned long long

　　对于思想永远僵化在$Pascal$的人群，其实字符数组的下标也是可以从$1$开始用的：

scanf("%s",s+1);
  2 l=strlen(s+1); //求长度 

　　计算进制的各个幂,方便之后截取子串以及滚动求字符串的前缀$Hash$值:

po[0]=1;
  2 for (R i=1;i<=maxn;++i)
  3     po[i]=po[i-1]*base;
  4 for (R i=1;i<=l;++i)
  5     hash[i]=hash[i-1]*base+s[i]-'A'+1;

　　截取$[l,r]$子串的$Hash$值:　

a=hash[r]-hash[l]*po[r-l+1];

　　如果感到难以理解,就把进制换成10来想一想,提交的时候不要忘记改回233就可以了.

　　Hash当然还有许多种,比如$Xor-Hash$(个人觉得非常不靠谱),$mod-hash$(虽然也觉得不靠谱,但是一般配合$Hash$表使用,就没有这样的顾虑了),一本通上还介绍了奇妙的将数字乘上一个无理数再取整的方法...

　　最终发现还是进制$Hash$最好用。根据生日悖论，出现冲撞的概率非常小，出现冲撞的步长是$sqrt{mod}$,但是模数非常大以至于几乎可以忽略这个概率.说到生日悖论,暑假$shallwe$来讲课,发现机房$50$多个人竟然没有生日在同一天的23333

　　刚刚浏览器挂掉了，然后我已经写完的两道题也跟着消失了，真伤心。

　　再来一次：

　　POJ 2752：http://poj.org/problem?id=2752

　　题意概述：对于给定的串，询问它的哪些前缀同时也是后缀。

　　$Hash$模板题。

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# define R register int
# define ULL unsigned long long

using namespace std;

const int base=233;
const int maxn=400005;
char c[maxn];
int l;
ULL hash[maxn];
ULL po[maxn];

int main()
{
    po[0]=1;
    for (R i=1;i<=maxn;++i)
        po[i]=po[i-1]*base;
    while (~scanf("%s",c+1))
    {
        l=strlen(c+1);
           for (R i=1;i<=l;++i)
            hash[i]=hash[i-1]*base+c[i]-'a'+1;
        for (R i=1;i<=l;++i)
            if(hash[i]==hash[l]-hash[l-i]*po[i]) printf("%d ",i);
        printf("
");
    }
    return 0;
}

 

　　POJ 3461：http://poj.org/problem?id=3461

　　题意概述：给定两个串，求$A$串在$B$串的哪些位置出现过.

　　枚举在$B$中的起点，截取子串进行$Hash$判断.

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# define R register int
# define ULL unsigned long long

using namespace std;

const int base=233;
const int maxn=1000005;
int l1,l2,ans,T;
char w[10005],t[maxn];
ULL po[maxn],hash[maxn],goa;

int main()
{
    po[0]=1;
    for (R i=1;i<=maxn;++i)
        po[i]=po[i-1]*base;
    scanf("%d",&T);
    while (T--)
    {
        ans=0;
        scanf("%s",w+1);
        scanf("%s",t+1);
        goa=0;
        l1=strlen(w+1);
        l2=strlen(t+1);
        for (R i=1;i<=l2;++i)
            hash[i]=hash[i-1]*base+t[i]-'A'+1;
        for (R i=1;i<=l1;++i)
            goa=goa*base+w[i]-'A'+1;
        for (R i=1;i<=l2-l1+1;++i)
            if(hash[i+l1-1]-hash[i-1]*po[l1]==goa) ans++;    
        printf("%d
",ans);
    }    
    return 0;
}

 

　　火星人：https://www.lydsy.com/JudgeOnline/problem.php?id=1014

　　题意概述：带修改带插入的LCP问题。$L<=10^5,M<=1.5 imes 10^5$

　　SA好像并不能资瓷修改和插入，所以只好想一个更暴力的办法：二分+Hash；如果只有修改，可以用线段树做，但是如果要插入就只能用平衡树了。如果用平衡树维护前缀哈希值，可能就崩溃了，因为平衡树并不能O(1)地求出前驱后继，所以需要另辟蹊径...维护区间哈希值！这个可以通过左右儿子的区间哈希值和子树大小 $O(1)$ 维护，从这里入手就可以解决了。说起来容易做起来难，调了一晚上才调出来，比较开心的是在洛谷上竟然1A了。bz上T掉了，所以进行了一番魔改，后来发现有的地方少Splay几次就玄学的快起来了。

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# define R register int
# define ULL unsigned long long

using namespace std;

const int maxn=100005;
const int base=233;
char s[maxn],opt[10],cc[4];
ULL po[maxn<<2];
int m,x,y,n,vis[maxn],cnt,l,r,rt,c;
struct node
{
    int siz,f,ch[2];
    int x;
    ULL v;
}t[maxn];

void update (int x)
{
    int l=t[x].ch[0],r=t[x].ch[1];
    if(t[l].v==0&&t[r].v==0) 
        t[x].v=t[x].x;
    else 
        if(t[r].v==0) 
            t[x].v=t[l].v*base+t[x].x;
    else
        t[x].v=(t[l].v*base+t[x].x)*po[ t[r].siz ]+t[r].v;
    t[x].siz=t[l].siz+t[r].siz+1;
}

int D (int x) { return t[ t[x].f ].ch[1]==x; }

void rotate (int x)
{
    int f=t[x].f,ff=t[f].f;
    int dx=D(x),df=D(f);
    int k=t[x].ch[dx^1]; 
    t[k].f=f;
    t[f].ch[dx]=k;
    t[f].f=x;
    t[x].ch[dx^1]=f;
    t[x].f=ff;
    t[ff].ch[df]=x;
    update(f);
    update(x);
}

void Splay (int x,int g)
{
    while(t[x].f!=g)
    {
        if(t[ t[x].f ].f==g) rotate(x);
        else if(D(x)==D(t[x].f)) rotate(t[x].f),rotate(x);
        else rotate(x),rotate(x);
    }
    update(x);
    if(!g) rt=x;
}

void ins (int l,int r,int v)
{
    Splay(l,0),Splay(r,l);
    t[r].ch[0]=++cnt;
    t[cnt].siz=1;
    t[cnt].x=t[cnt].v=v;
    t[cnt].f=r;
    update(r),update(l);
    Splay(cnt,0);
}

int find (int k)
{
    int x=rt;
    while (1)
    {
        int s=t[ t[x].ch[0] ].siz;
        if (s>=k) x=t[x].ch[0];
        else if(s+1==k) return x;
        else x=t[x].ch[1],k-=s+1; 
    }
}

ULL ask (int x)
{
    if(x==0) return 0;
    int l=find(1),r=find(x+2);
    Splay(l,0);
    Splay(r,l);
    ULL ans=t[ t[r].ch[0] ].v;
//    x=find(x);
//    Splay(x,0); 这两句不加的话好像复杂度不是很对，但是加上后就跑的特慢，所以去掉了 
    return ans;
}

bool check (int a,int b,int k,ULL A,ULL B)
{
    ULL x,y;
    x=ask(a+k-1)-A*po[k];
    y=ask(b+k-1)-B*po[k];
    return (x==y);
}

int solve (int x,int y)
{
    if(x>y) swap(x,y);
    int l=1,r=n-y+1,mid,ans=0;
    ULL A=ask(x-1),B=ask(y-1);
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(check(x,y,mid,A,B)) ans=mid,l=mid+1;
        else r=mid-1;
    }
    return ans;
}

int read ()
{
    R x=0;
    char c=getchar();
    while (!isdigit(c)) c=getchar();
    while (isdigit(c)) x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x;
}

int main()
{
    scanf("%s",s+1);
    n=strlen(s+1);
    scanf("%d",&m);
    po[0]=1;
    for (R i=1;i<=n+m;++i) po[i]=po[i-1]*base;
    cnt=2;
    rt=1;
    t[2].f=1;
    t[1].ch[1]=2;
    for (R i=1;i<=n;++i)
    {
        l=find(i),r=find(i+1);
        x=s[i]-'a'+1;
        ins(l,r,x);
    }
    for (R i=1;i<=m;++i)
    {
        scanf("%s",opt+1);
        if(opt[1]=='Q')
        {
            x=read(),y=read();
            printf("%d
",solve(x,y));
        }
        else if(opt[1]=='R')
        {
            scanf("%d",&x);
            scanf("%s",cc+1);
            c=cc[1]-'a'+1;
            l=x,r=x+2;
            l=find(l),r=find(r);
            Splay(l,0);
            Splay(r,l);
            x=t[r].ch[0];
            t[x].v=t[x].x=c;
            update(r);
            update(l);
            Splay(x,0);
        }
        else if(opt[1]=='I')
        {
            scanf("%d",&x);
            scanf("%s",cc+1);
            c=cc[1]-'a'+1;
            l=find(x+1);
            r=find(x+2);
            Splay(l,0);
            Splay(r,l);
            x=t[r].ch[0]=++cnt;
            t[x].v=t[x].x=c;
            t[x].siz=1;
            t[x].f=r;
            update(r);
            update(l);
            Splay(x,0);
            n++;
        }
    }
    return 0;
}

 

---shzr