java - 在java中使用散列来匹配模式

Question

我试图学习如何使用多重哈希来匹配给定文本字符串中的模式。我在java中找到了以下实现:

void multiHashing() {
    int counter = 0;
    int d = 26;
    int r = 10;
    int [] qP = qPrimes(d,r); // stores 10 prime numbers
    long [] P = new long[r];
    long [] T = new long[r];
    long [] H = new long[r];
    for (int k=0;k<r;k++) {
        H[k] = mod(((long) Math.pow(d, m-1)), qP[k]);
        for (int i=0;i<m;i++) {
            P[k] = mod((d*P[k] + ((int)pattern.charAt(i) - 97)), qP[k]); //what has been done here
            T[k] = mod((d*T[k] + ((int)text.charAt(i) - 97)), qP[k]);
        }           
    }
    for (int s=0;s<=n-m;s++) {
        if (isEqual(P,T)) {
            out.println(s);
            counter++;
        }
        if (s < n-m) {
            for (int k=0;k<r;k++)
                T[k] = mod(d*(T[k] - ((int)text.charAt(s) - 97)*H[k]) + ((int)text.charAt(s+m) - 97), qP[k]);       // what has been done here? 
        }

    }
} 

问题是:我无法理解上面代码中我已在代码中注释掉的某些行。这些方面实际上做了什么？

Answer 1

这是Rabin-Karp字符串搜索算法。该算法没有将模式与文本的每个部分进行比较，而是尝试比较这些部分的哈希值以减少计算量。

为了计算哈希值，它使用 rolling hash它维护文本的固定宽度窗口(在本例中宽度 = 模式长度)，并通过一次移动该窗口一个字符来更新它。

Input: pattern P, text T, d, prime number q

m = P.length
n = T.length
p = 0 // hash of pattern P
t = 0 // hash of text T
h = (d ^ (m-1)) % q 

// preprocessing: hashing P[1..m] and T[1..m] (first window of T)
for i = 1 to m 
    p = (d * p + P[i]) % q //(1)
    t = (d * t + T[i]) % q

// matching
for s = 0 to n-m
    if(p == t)
        if(P[1..m] == T[s+1..s+m]
            print "matched"
    // update the rolling hash
    if(s < n-m)
        t = (d * (t - T[s+1] * h) + T[s+m+1]) % q // (2)

在预处理阶段，它计算模式 P 和文本 T 的第一个窗口的哈希。为了计算模式的哈希，我们需要计算每个字符的哈希。(1) p = (d * p + P[i]) % q 实际上计算的是第 i 个字符的哈希值。

来自维基百科的示例:

// ASCII a = 97, b = 98, r = 114.

hash("abr") = (97 × 1012) + (98 × 1011) + (114 × 1010) = 999,509

在将模式与文本的第 s 个窗口进行比较后的匹配阶段(如果 P 的哈希值与 T 的第 s 个窗口相等)，我们需要更新哈希值以表示第 (s+1) 个文本窗口T. (2) t = (d * (t - T[s+1] * h) + T[s+m+1]) % q 首先减去最后一个字符的哈希值窗口，然后添加下一个字符的哈希值，从而将窗口向前移动一个字符。

来自维基百科:

rolling hash function just adds the values of each character in the substring. This rolling hash formula can compute the next hash value from the previous value in constant time: s[i+1..i+m] = s[i..i+m-1] - s[i] + s[i+m]

We can then compute the hash of the next substring, "bra", from the hash of "abr" by subtracting the number added for the first 'a' of "abr", i.e. 97 × 1012, multiplying by the base and adding for the last a of "bra", i.e. 97 × 1010. Like so:

           base  old hash  old 'a'     new 'a'

hash("bra") = [101 × (999,509 - (97 × 1012))] + (97 × 1010) = 1,011,309

备注:

(int)text.charAt(s) - 97:97是字符“a”的ascii代码，因此此操作将“a”更改为0，“b”更改为1等。