码迷,mamicode.com
首页 > 其他好文 > 详细

HDU 4622 Reincarnation Hash解法详解

时间:2016-08-01 00:04:36      阅读:849      评论:0      收藏:0      [点我收藏+]

标签:

今天想学字符串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;
}
View Code

 

 

 

下面再附上一个用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;
}
View Code

 

HDU 4622 Reincarnation Hash解法详解

标签:

原文地址:http://www.cnblogs.com/liuweimingcprogram/p/5724152.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!