标签：
今天想学字符串hash是怎么弄的。就看到了这题模板题
http://acm.hdu.edu.cn/showproblem.php?pid=4622
刚开始当然不懂啦，然后就上网搜解法。很多都是什么后缀自动机那些。作为小白的我当然不懂啦，更重要的是我想学的是字符串hash这种解法呢？然而有这种解法，但是却都是只有代码，看起来很辛苦。所以这里我把我的理解写上来，当然有错误的话，请各路高手指出来，我也好好学习下~~
首先介绍一个字符串Hash的优秀映射函数：BKDRHash，这里hash一开始是等于0的
for(i=1 to lenstr) hash = seed * hash + str[i]; 这是求解hash值的公式。绝大多数情况下能唯一确定字符串。seed是一个参数，一般取 31 、131、 1313、 13131、 131313、 etc..冲突比较小
经典题目：HDU 4622 Reincarnation
题意：给定一个长为2000个字符串，给出Q(Q<=10000)个询问。每个询问包含[L,R]，要求算出这个区间内不同的子串的个数。
思路：暴力枚举区间长度L，从1开始枚举到lenstr，再枚举起点i即可。能在O(n2)的时间枚举完。但仅仅是枚举完，但这里并没有去重，这部分时间，我们用hash来完成，复杂度压到O(1)。什么叫去重呢？例如baba,当我们枚举第二个ba的时候，就要告诉我们”ba”在[1,4]中重复出现了一次，所以ans[1][4]--; //ans[L][R]就是表示区间内不同子串的个数了。
要枚举那么多子串，我们希望，对于任意给定的区间[L,R]，都能快速地算出它的hash值是多少。例如求[3,4]的hash值，明显有 ans = seed * str[3] + str[4];（这是根据公式得到的。）
那么我们先预处理一个前缀hash总和，记为sumHash[i]表示1~i的hash值。则有
sumHash[1] = str[1]; sunHash[2] = seed * str[1] + str[2];
sunHash[3] = seed * sumHash[2] + str[3]; sumHash[4] = seed * sumHash[3] + str[4];
把他们拆出来，即可得到[3,4] ans = sumHash[4] – seed(R-L+1) * sumHash[2];
所以预处理两个数组，powseed[i]表示seed的i次方， sumHash[i]定义如上
然后就是怎么判断重复出现的问题了。我们知道那个hash值是唯一的，我们只能靠这个来判断是否重复出现，但是这个hash值很大，用map<ULL,int>来模拟是可以得，但是很慢。怎么办呢?我们可以用图，先把hash值%MOD压缩下，把他们加入到一幅图中，再开一个数组保存边的权值，用边的权值来和hash值判断相不相同，即可确定是否重复出现。
那个图没什么了不起的，就是为了返回出现的位置，不要被那个图吓到了。
下面代码可以300+ms
#include <cstdio> #include <cstdlib> #include <cstring> typedef unsigned long long int ULL; //BKDRHash，最优的字符串hash算法。hash一开始是等于0的 //for(i=1 to lenstr) hash = seed * hash + str[i]; 这是求解hash值的公式 //我们希望，对于任意给定的区间[L,R]，都能快速地算出它的hash值是多少 //明显我们要算的是：例如[3,4] ans = seed * str[3] + str[4] //那么我们先预处理一个前缀hash总和，记为sumHash[i]表示1~i的hash值 //sumHash[1] = str[1]; sunHash[2] = seed * str[1] + str[2]; //sunHash[3] = seed * sumHash[2] + str[3]; sumHash[4] = seed * sumHash[3] + str[4]; //拆出来，得到若要求[3,4] 既可以 ans = sumHash[4] - seed^(R-L+1) * sumHash[2] //所以预处理两个数组，powseed[i]表示seed的i次方， sumHash[i]定义如上 const int seed = 13131; // 31 131 1313 13131 131313 etc.. const int maxn = 2000+20; char str[maxn]; ULL powseed[maxn]; // seed的i次方 爆了也没所谓，sumHash的也爆。用了ULL，爆了也没所谓，也能唯一确定它，无符号 ULL sumHash[maxn]; //前缀hash值 int ans[maxn][maxn]; //ans[L][R]就代表ans,就是区间[L,R]内不同子串的个数 const int MOD = 10007; struct StringHash { int first[MOD+2],num; // 这里因为是%MOD ，所以数组大小注意，不是maxn ULL EdgeNum[maxn]; // 表明第i条边放的数字(就是sumHash那个数字) int next[maxn],close[maxn]; //close[i]表示与第i条边所放权值相同的开始的最大位置 //就比如baba，现在枚举长度是2，开始的时候ba，close[1] = 1;表明"ba"开始最大位置是从1开始 //然后枚举到下一个ba的时候，close[1]就要变成3了，开始位置从3开始了 void init () { num = 0; memset (first,0,sizeof first); return ; } int insert (ULL val,int id) //id是用来改变close[]的 { int u = val % MOD; //这里压缩了下标，val是一个很大的数字，这里就有一个问题了，val是唯一的，因为它是从sumHash得到的 //那个hash算法很优秀，基本上val是唯一的了。现在我们想知道和val值相同的地方是哪里。又是上面那个例子了。baba。当我们 //枚举第二个ba的时候，我想知道它有没出现过，如果有，请放回它出现的位置。这里其实完全可以用map<ULL,int>book这样做， //如果book[val] != 0，就代表出现过了，更新，返回就可以。但是非常慢，2800+ms,第二次提交还TLE //所以我们逼不得已用图了，再加上其他辅助的数组.EdgeNum[]就是用来判断和val相不相同的。这样时间才降下来 for (int i = first[u]; i ; i = next[i]) //存在边不代表出现过，出现过要用val判断，val才是唯一的，边还是压缩后(%MOD)的呢 { if (val == EdgeNum[i]) //出现过了 { int t = close[i]; close[i] = id;//更新最大位置 return t; } } ++num; //没出现过的话，就加入图吧 EdgeNum[num] = val; // 这个才是精确的 close[num] = id; next[num] = first[u]; first[u] = num; return 0;//没出现过 } }H; void work () { scanf ("%s",str+1); int lenstr = strlen(str+1); for (int i=1;i<=lenstr;++i) sumHash[i] = sumHash[i-1]*seed + str[i]; memset(ans,0,sizeof(ans)); for (int L=1;L<=lenstr;++L) //暴力枚举子串长度 { H.init(); for (int i=1;i+L-1<=lenstr;++i) { int pos = H.insert(sumHash[i+L-1]-powseed[L]*sumHash[i-1],i); ans[i][i+L-1] ++;//ans[L][R]++，自己是一个 ans[pos][i+L-1]--;//pos放回0是没用的 //就像bababa，第二个ba的时候，会ans[1][4]--;表明[1,4]重复了一个 //然后第三个ba的时候，ans[2][6]--,同理，表明[2,6]也是重复了 //那么ans[1][6]重复了两个怎么算？就是在递推的时候，将ans[2][6]的值覆盖上来的 //ans[1][6] += ans[2][6] + ans[1][5] - ans[2][5]; } } for (int i = lenstr; i>=1; i--) { for (int j=i;j<=lenstr;j++) { ans[i][j] += ans[i+1][j]+ans[i][j-1]-ans[i+1][j-1]; } } int m; scanf ("%d",&m); while (m--) { int L,R; scanf ("%d%d",&L,&R); printf ("%d\n",ans[L][R]); } return ; } int main () { powseed[0] = 1; for (int i = 1; i <= maxn-20; ++i) powseed[i] = powseed[i-1] * seed; int t; scanf ("%d",&t); while (t--) work(); return 0; }
下面再附上一个用map模拟的代码。2800+ms，可能会超时哦。
#include <cstdio> #include <cstdlib> #include <cstring> #include <cmath> #include <algorithm> using namespace std; #define inf (0x3f3f3f3f) typedef long long int LL; typedef unsigned long long int ULL; #include <iostream> #include <sstream> #include <vector> #include <set> #include <map> #include <queue> #include <string> //BKDRHash，最优的字符串hash算法。hash一开始是等于0的 //for(i=1 to lenstr) hash = seed * hash + str[i]; 这是求解hash值的公式 //我们希望，对于任意给定的区间[L,R]，都能快速地算出它的hash值是多少 //明显我们要算的是：例如[3,4] ans = seed * str[3] + str[4] //那么我们先预处理一个前缀hash总和，记为sumHash[i]表示1~i的hash值 //sumHash[1] = str[1]; sunHash[2] = seed * str[1] + str[2]; //sunHash[3] = seed * sumHash[2] + str[3]; sumHash[4] = seed * sumHash[3] + str[4]; //拆出来，得到若要求[3,4] 既可以 ans = sumHash[4] - seed^(R-L+1) * sumHash[2] //所以预处理两个数组，powseed[i]表示seed的i次方， sumHash[i]定义如上 const int seed = 13131; // 31 131 1313 13131 131313 etc.. const int maxn = 2000+20; char str[maxn]; ULL powseed[maxn]; // seed的i次方 爆了也没所谓，sumHash的也爆。用了ULL，爆了也没所谓，也能唯一确定它 ULL sumHash[maxn]; //前缀hash值 int ans[maxn][maxn]; //ans[L][R]就代表ans,就是区间[L,R]内不同子串的个数 const int MOD = 10007; struct StringHash { //int book[MOD+20]; map<ULL,int>book; void init () { book.clear(); return ; } int insert (ULL val,int id) { if (book[val]) { int t = book[val]; book[val] = id; return t; } book[val] = id; return 0; } }H; void work () { scanf ("%s",str+1); int lenstr = strlen(str+1); for (int i=1;i<=lenstr;++i) sumHash[i] = sumHash[i-1]*seed + str[i]; memset(ans,0,sizeof(ans)); for (int L=1;L<=lenstr;++L) //暴力枚举子串长度 { H.init(); for (int i=1;i+L-1<=lenstr;++i) { int pos = H.insert(sumHash[i+L-1]-powseed[L]*sumHash[i-1],i); ans[i][i+L-1] ++;//ans[L][R]++，自己是一个 ans[pos][i+L-1]--;//pos放回0是没用的 //就像bababa，第二个ba的时候，会ans[1][4]--;表明[1,4]重复了一个 //然后第三个ba的时候，ans[2][6]--,同理，表明[2,6]也是重复了 //那么ans[1][6]重复了两个怎么算？就是在递推的时候，将ans[2][6]的值覆盖上来的 //ans[1][6] += ans[2][6] + ans[1][5] - ans[2][5]; } } for (int i = lenstr; i>=1; i--) { for (int j=i;j<=lenstr;j++) { ans[i][j] += ans[i+1][j]+ans[i][j-1]-ans[i+1][j-1]; } } int m; scanf ("%d",&m); while (m--) { int L,R; scanf ("%d%d",&L,&R); printf ("%d\n",ans[L][R]); } return ; } int main () { #ifdef local freopen("data.txt","r",stdin); #endif powseed[0] = 1; for (int i = 1; i <= maxn-20; ++i) powseed[i] = powseed[i-1] * seed; int t; scanf ("%d",&t); while (t--) work(); return 0; }
HDU 4622 Reincarnation Hash解法详解
标签：
原文地址：http://www.cnblogs.com/liuweimingcprogram/p/5724152.html
