HASH 字符串哈希 映射轉化

哈希HASH的本質思想相似於映射、離散化。

哈希，經過給不一樣字符賦不一樣的值、而且欽定一個進制K和模數，從而實現一個字符串到一個模意義下的K進制數上。

它的主要目的是判重，用於$DFS$、$BFS$判重（八數碼），字符串判斷相等、出現等等。

本篇總結字符串哈希以及一些應用例題。

爲什要用字符串哈希？

由於取出一個字符串是$O(n)$的，比較一遍又是$O(n)$的，何況要比較兩個甚至多個。這就成了$n^2$級別的了。

那咱們比較數字怎麼就不用這麼麻煩呢？由於數字能夠直接比較，（雖然不知道內部是怎麼實現的，反正比一位一位比較確定快）因此咱們考慮把字符串映射到數字上。

就有了字符串哈希。

經過字符串哈希，只要題目支持預處理，咱們能夠$O(n)$預處理以後，$O(1)$進行提取，$O(1)$進行判重。

 

字符串哈希須要什麼？

1.字符。初始座標無所謂。

2.K進制數，一般選擇$131$，$13331$，這兩個質數衝突概率很小（不要問我爲何）。

3.取模數，我用過 $1e9+7$，$998244353$，用$2^{64}$也能夠，這裏利用天然溢出，通常不會有問題。提一句，$unsigned\space long\space long$作減法，即便算出來應該是負數，會自動加上$2^{64}$，至關於$(a+mod-b)%mod$了。沒有問題。

 

處理hash：

1.預處理$K^{len}$ 放入$k[]$中儲存。

2.順便處理$hash[i]=hash[i-1]*K+str[i]$

 

hash的容器：

1.一個題可能產生不少哈希值。有的時候咱們要找一個容器存儲。可以比較快速地查詢一個$hash$值有沒有出現過。

2.比較經常使用的是$map<ll,bool>$，由於自己map就是映射。

3.可是$map$不但有$logn$，常數也不小。因而就有了hash表。

其實就是對$hash$值再分類存放。就能夠避免不少沒有意義的查詢。

再找一個模數，通常是全部哈希值出現次數的幾分之一（數組能開下），能夠的話，就取出現次數也行。

而後，哈希值先除以模數，餘數就是位置。而後用鄰接表存儲。

 

字符串哈希的基本操做：

1.提取：$a[l,r]$段：$hash[r]-hash[l-1]*k[r-l]$ 相似前綴和。

2.插入，同處理。

操做均是$O(1)$

 

字符串哈希支持的應用操做：

1.判斷字符串是否相等。取hash段比較便可，$O(1)$

2.找某兩個位置開始的$LCP$（最長公共前綴），二分位置+$hash$判斷 $O(logn)$ （長度夠小，可用$trie$樹，更好的支持多串$LCP$）（固然，若是你會$SA$，這些都是小兒科~）

3.判斷兩個串字典序大小，找$LCP$，判斷下一位大小。$O(logn)$

4.找回文串。可是要正反二分。若是能夠預處理的話，固然不如$manacher$。或者你用SA建反串而後找LCP。

哈希衝突

1.因爲取模，因此有必定概率，兩個不一樣的串，可是哈希值相同。

咱們認爲哈希值相同，串就相同了。因此，就會出現錯誤。

像1e9+7,unsigned long long 這些，均可以特殊構造卡掉。

見bzoj HASH KILLER系列。

2.解決方法：

①取大質數做爲模數。$10^{15}$以上的模數更不容易被卡。

②雙哈希

即處理兩個哈希值。相同的字符串必定兩個都相同，由於都是一樣的構造方法。

若是哈希值不一樣，必定是不一樣的字符串。

這個時候，若是兩個串的兩個哈希值對應相等，咱們就認爲相等。不然不等。

這樣子衝突的機率就很小了。$1e9+7$，$998244353$的雙模數就基本卡不掉了。

 

字符串哈希例題：

T1：POJ2758

給定一個字符串，要求維護兩種操做
在字符串中插入一個字符
詢問某兩個位置開始的LCP
插入操做<=200，字符串長度<=5w，查詢操做<=2w

分析：有人用後綴數組？？不會。Splay？？不會。

操做小於等於200，直接暴力重構是正解！！

注意：

1.插入字符位置可能遠大於len，要向len+1取min

2.詢問位置是初始位置，重構的時候，能夠暴力循環記錄每個初始位置如今已經變到了第幾個位置。

#include<cstdio> #include<cstdlib> #include<algorithm> #include<iostream> #include<cmath> #include<cstring>
using namespace std; typedef long long ll; const int N=80000+210; const int mod=998244353; const int K=13331; ll h[N]; ll c[N]; int n,m; int len; int f[N]; int ne[N]; char o[N],a[N]; int main() { scanf("%s",o+1); n=strlen(o+1); memcpy(a+1,o+1,sizeof o);len=n; //cout<<" lenn "<<len<<endl;
    scanf("%d",&m); for(int i=1;i<=n;i++) ne[i]=i; c[0]=1; for(int i=1;i<=n+m+1;i++) { c[i]=(c[i-1]*K)%mod; if(i<=n) h[i]=(h[i-1]*c[1]+(int)o[i])%mod; } char ch,op; int num,x,y; //cout<<"fir "<<a+1<<endl;
    while(m--){ scanf(" %c",&op); if(op=='Q'){ scanf("%d%d",&x,&y); x=ne[x],y=ne[y]; //cout<<x<<" and "<<y<<endl;
            if(a[x]!=a[y]){ printf("0\n");continue; } int ans; int l=0,r=min(len-x,len-y)+1; //cout<<" origin "<<l<<" "<<r<<endl;
            while(l<=r){ int mid=(l+r)>>1; int ed1=x+mid-1; int ed2=y+mid-1; ll ha1=(h[ed1]+mod-h[x-1]*c[mid]%mod)%mod; ll ha2=(h[ed2]+mod-h[y-1]*c[mid]%mod)%mod; //cout<<mid<<" hash "<<ha1<<" "<<ha2<<endl;
                if(ha1==ha2) { ans=mid,l=mid+1; } else{ r=mid-1; } } printf("%d\n",ans); } else{ scanf(" %c%d",&ch,&num); if(num>len) num=len+1; ///add(num);
            len++; for(int i=len;i>=num+1;i--) a[i]=a[i-1]; a[num]=ch; for(int i=num;i<=len;i++) h[i]=(h[i-1]*c[1]+(int)a[i])%mod; for(int i=n;i>=1;i--) { if(ne[i]>=num) ne[i]++;else break;} } //cout<<a+1<<endl;
 } return 0; }

POJ2758

 

 

如下是配贈福利

樹哈希：

咱們知道，一棵無根樹能夠以任何一個點爲根。兩個樹可能看過去形態不一樣，可是可能存在固定兩個樹的根，而後對整個樹從新編號，使得徹底相同。

求樹的同構就是這樣。

相似字符串同構，咱們也要適用哈希。

模板例題：

BZOJ 4337: BJOI2015 樹的同構

50棵樹，50個節點。求同構。

方法：
1.對於兩個同構的樹，存在固定兩個樹的根，而後對整個樹從新編號，使得徹底相同。

因此，咱們能夠對一個樹，以每一個點爲根，而後dfs一遍。

$dfs$的時候，處理子樹的$hash$值。

$hash$的$base$值和第幾個兒子有關。是各不相同的素數。

而後，對於一個子樹，把全部的兒子$hash$值，排序，從小到大合併。

而後對於全部的$hash$值，$sort$一遍。

兩個樹相同，當且僅當全部的$N$個點的$hash$值對應相同。

咱們的$hash$值考慮了深度、每一個點節點個數。因此不容易衝突。

2.咱們之因此要以每一個點爲根，而後$dfs$一遍，

是由於可能從新編號後根不知道是哪兩個。

可是這樣比較暴力。$N^3$

發現，對於一個無根樹，重心最多兩個。

對於兩個同構的樹，若是咱們把重心的搭配4種枚舉一下，那麼必然存在一種樹的$hash$相同。

因此，能夠對每一個樹以重心掃兩邊便可。

$hash$的$base$，也能夠考慮用歐拉序。