大力出奇迹——字符串哈希

字符串哈希详解

最新推荐文章于 2024-07-21 23:34:16 发布

原创最新推荐文章于 2024-07-21 23:34:16 发布 · 368 阅读

1 ·

CC 4.0 BY-SA版权

字符串专栏收录该内容

7 篇文章

订阅专栏

什么是字符串哈希

字符串哈希，即把字符串转化为一个 $b a s e$ 进制的数字

哈希的过程

把字符串a看做一个base进制的数字，则a的每个前缀的哈希值为
$h a s h [i]$ $=$ $\% mod$
其中， $b a s e$ 和 $m o d$ 一般取质数，可以减小冲突
把 $h a s h$ 数组定义为无符号类型，可以不模，使其自然溢出
然鹅单哈希容易被卡，最好使用双哈希

双哈希

取不同的base和mod，做两次哈希，得到两组值： $h a s h 1 [], h a s h 2 []$
此时原串的哈希值为一个 $p a i r$
实测双哈希不会慢太多，可放心使用。

字符串哈希的用处

观察每个前缀串的哈希值可得：
$hash[l, r] = hash[r] - has[l-1]*base^{r-l+1}$ （当hash不为无符号数时，减法后取模需 $\%mod + mod) \% mod$ ）
于是可以 $O (1)$ 求得任意子串的哈希值。
简单的说，字符串哈希可以在字符串匹配的过程中，把两个字符串的比较转化为两个数字的比较，在时间上消掉一个 $n$

例题

题目链接
题意：两个串的最长公共子串
(听说后缀自动机能 $O (n)$ 求。晚点再补两份后缀数组 $\&\&$ 后缀自动机的代码。)

解法：

预处理出a和b每个前缀的哈希值
因为最长公共子串的性质，存在长度为 $m$ 的最长公共子串，就一定存在长度为 $m - 1$ 的最长公共子串。
所以可以二分答案
check的时候，把a长度为m的所有子串的哈希值排序，对b的每个长度为m的哈希值，在有序序列中二分查找，能找到则check函数返回1。
时间复杂度：check里面一次排序 $n l o g n$ ，二分答案 $l o g n$ ，一共 $nlog^2n$ 。
看到一种更好的做法，把check中排序+二分的操作换成哈希，可以再消掉一个 $l o g$ …
这里放一个双哈希的 $nlog^2n$ 的代码。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

typedef unsigned long long ull;
typedef long long ll;
typedef pair<ull, ull> puu;
const int base1 = 31;
const int base2 = 196613;

puu has1[100005], has2[100005];
ull p1[100005], p2[100005];

void Hash(const string &a, puu has[])
{
    has[0] = {a[0], a[0]};
    int len = a.size();
    for (int i = 1; i < len; ++i)
    {
        has[i].first = has[i - 1].first * base1 + a[i];
        has[i].second = has[i - 1].second * base2 + a[i];
    }
}

puu sub(int l, int r, puu has[])
{
    if (!l)
        return has[r];
    puu ans;
    ans.first = has[r].first - has[l - 1].first * p1[r - l + 1];
    ans.second = has[r].second - has[l - 1].second * p2[r - l + 1];
    return ans;
}

ull lena, lenb;
vector<puu> h;

bool ok(int n, int lena, int lenb)
{
    h.clear();
    for (int i = n - 1; i < lena; ++i)
		h.push_back(sub(i-n+1, i, has1));
    sort(h.begin(), h.end());
    puu t;
    for (int i = n - 1; i < lenb; ++i)
    {
        t = sub(i - n + 1, i, has2);
        if (binary_search(h.begin(), h.end(), t))
            return 1;
    }
    return 0;
}

string a, b;

int main()
{
    cin >> a >> b;
    Hash(a, has1);
    Hash(b, has2);
    p1[0] = p2[0] = 1;
    for (int i = 1; i <= 100005; ++i)
    {
        p1[i] = base1 * p1[i - 1];
        p2[i] = base2 * p2[i - 1];
    }
    int l = 1, r = min(a.size(), b.size()), m;
    while (l <= r)
    {
        m = l + r >> 1;
        if (ok(m, a.size(), b.size()))
            l = m + 1;
        else
            r = m - 1;
    }
    cout << r;
    return 0;
}