HDU 4622 Reincarnation Hash解法详解

今天想学字符串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(n²)的时间枚举完。但仅仅是枚举完，但这里并没有去重，这部分时间，我们用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;
}