Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа

Материал из Викиконспекты
Версия от 21:49, 15 июня 2015; 5.18.106.186 (обсуждение) (Метод хеширования)
Перейти к: навигация, поиск

Алгоритм Рабина-Карпа предназначен для поиска подстроки в строке.

Метод хеширования

Наивный алгоритм поиска подстроки в строке работает за [math]O\left(n^2\right)[/math] в худшем случае — слишком долго. Чтобы ускорить этот процесс, можно воспользоваться методом хеширования.

Определение:
Пусть дана строка [math]s[0..n-1][/math]. Тогда полиномиальным хешем строки [math]s[/math] называется число [math]h = \mathrm{hash}(s[0..n-1]) = p^{0} s[0] + ... + p^{n - 1} s[n-1][/math], где [math]p[/math] — некоторое простое число, а [math]s[i][/math] - код [math]i[/math]-ого символа строки [math]s[/math].

Проблему переполнения при вычислении хешей довольно больших строк можно решить так: будем считать хеши по модулю [math]r=2^{64}[/math], чтобы модуль брался автоматически при переполнении типов.

Использование полиномиального хеша именно с убывающими степенями [math]p[/math] позволяет нам, зная хеш некоторой строки, посчитать хеш строки, образованной удалением первого символа и добавлением символа в конец, за [math]O(1)[/math]:

[math]\mathrm{hash}(s[i + 1..i + m - 1]) = (\mathrm{hash}(s[i..i + m - 1]) - p^{m - 1} s[i]) \bmod r[/math].

[math]\mathrm{hash}(s[i + 1..i + m]) = (p \cdot \mathrm{hash}(s[i + 1..i + m - 1]) + s[i + m]) \bmod r[/math].

Получается : [math]\mathrm{hash}(s[i + 1..i + m]) = (p \cdot \mathrm{hash}(s[i..i + m - 1]) - p^{m} s[i] + s[i + m]) \bmod r[/math].

Решение

Алгоритм

Алгоритм начинается с подсчета [math]\mathrm{hash}(s[0..m-1])[/math] и [math]\mathrm{hash}(p[0..m-1])[/math].

Для [math]i \in [0..n - m][/math] вычисляется [math]\mathrm{hash}(s[i..i + m - 1])[/math] и сравнивается с [math]\mathrm{hash}(p[0..m-1])[/math]. Если они оказались равны, то образец [math]p[/math] скорее всего содержится в строке [math]s[/math] начиная с позиции [math]i[/math], хотя возможны и ложные срабатывания алгоритма. Если требуется свести такие срабатывания к минимуму или исключить вовсе, то применяют сравнение некоторых символов из этих строк, которые выбраны случайным образом, или применяют явное сравнение строк, как в наивном алгоритме поиска подстроки в строке. В первом случае проверка произойдет быстрее, но вероятность ложного срабатывания, хоть и небольшая, останется. Во втором случае проверка займет время, равное длине образца, но полностью исключит возможность ложного срабатывания.

Для ускорения работы алгоритма оптимально предпосчитать [math]p^{m}[/math].

Псевдокод

Приведем пример псевдокода, который находит все вхождения строки [math]w[/math] в строку [math]s[/math] и возвращает массив позиций, откуда начинаются вхождения.

vector<int> rabinKarp (s : string, w : string):
   vector<int> answer
   int n = s.length
   int m = w.length
   int hashS = hash(s[0..m-1])
   int hashW = hash(w[0..m-1])
   for i = 0 to n - m
        if hashS == hashW
             answer.add(i)
        hashS = (p * hashS - p[math]^{m}[/math] * hash(s[i]) + hash(s[i + m])) mod r // r — некоторое большое число, p — некоторое просто число
   return answer

Новый хеш [math]hashS[/math] был получен с помощью быстрого пересчёта. Для сохранения корректности алгоритма нужно считать, что [math]s[n + 1][/math] — пустой символ.

Время работы

Изначальный подсчёт хешей выполняется за [math]O(m)[/math].

Каждая итерация выполняется за [math]O(1)[/math], В цикле всего [math]n - m + 1[/math] итераций.

Итоговое время работы алгоритма [math]O(n + m)[/math].

Пример худшего случая

Если количество подстрок данной строки превышает количество хешей (а это выполняется тогда, когда длина строки больше [math]r[/math], так как количество различных значений полиномиального хеша совпадает с [math]r[/math]), то наступление коллизий неизбежно. Но даже при относительно небольших строках вероятность коллизий может быть высока, не говоря уже о способах составления специальных строк, где алгоритм на хешах выдаёт частые ложные срабатывания.

Например, возьмем за [math]S[/math] строку Туэ-Морса[1] длиной [math]2^{k}[/math], [math]r = 2^{64}[/math], [math]p[/math] — любое просто число.

Обозначим за [math]S_k[/math] строку [math]S[/math] для фиксированного [math]k[/math] , а за [math]S'_k[/math] инвертированную строку [math]S[/math].

Покажем, что при [math]k \lt 12[/math], [math]\mathrm{hash}(S_k) = \mathrm{hash}(S'_k)[/math]. Ведь если это так, то сами по себе [math]S_k[/math] и [math]S'_k[/math] встретятся в больших строках много-много раз.

Разберемся, что значит [math]\mathrm{hash}(S_k) = \mathrm{hash}(S'_k)[/math]. Можно смело заменить коды символов на нули и единицы в коэффициентах многочлена — тем самым мы просто сократим обе части на [math]\sum\limits_{i=0}^{2^k - 1} 65 \cdot p^i[/math].

Величина [math]\mathrm{hash}(S_k) - \mathrm{hash}(S'_k)[/math] есть некоторое число [math]T = p^{0} - p^{1} - p^{2} + p^{3} - p^{4} + p^{5} + p^{6} - p^{7} ... \pm p^{2^k - 1}[/math]. То есть это знакопеременная сумма степеней [math]p[/math], где знаки чередуются по тому же правилу, что и символы в строке.

Будем последовательно выносить из этой суммы множители за скобку:

[math]T = (p^{1} - 1)( - p^{0} + p^{2} + p^{4} - p^{6} + p^{8} - p^{10} - p^{12} + p^{14} ...) = [/math]

[math] = (p^{1} - 1)(p^{2} - 1)(p^{0} - p^{4} - p^{8} + p^{12} ...) = ... = (p^{1} - 1)(p^{2} - 1)(p^{4} - 1) ... (p^{2^{k-1}} - 1).[/math]

Покажем, что [math]T[/math] [math]\mathrm{mod}[/math] [math]r = 0[/math]:

Нужно понять, на какую максимальную степень двойки делится каждая из [math]k - 1[/math] скобок. Заметим, что [math](i + 1)[/math]-ая скобка [math]p^{2^{i + 1}}  -  1 = (p^{2i}  -  1)(p^{2i}  +  1)[/math] делится на [math]i[/math]-ую и ещё на какое-то чётное число [math]p^{2i}  +  1[/math]. Это означает, что если [math]i[/math]-ая скобка делится на [math]2^r[/math], то [math](i + 1)[/math]-ая скобка делится по меньшей мере на [math]2^{r + 1}[/math].

Получается, что [math](p^1 - 1)(p^2 - 1)(p^4 - 1)...(p^{2k - 1}  -  1)[/math] делится по меньшей мере на [math]2 \cdot 2^2 \cdot 2^3 \cdot ...  =  2^{k(k - 1) / 2}[/math].

Мы показали, что если k < 12, то величина [math]\mathrm{hash}(S_k) - \mathrm{hash}(S'_k) = 0[/math], то есть [math]\mathrm{hash}(S_k) = \mathrm{hash}(S'_k)[/math]. Значит достаточно взять [math]k \gt = 12[/math], чтобы в рассматриваемой строке было очень много различных подстрок, чьи хеши совпадут.

Сравнение с другими алгоритмами

Преимущества

  • Быстрая скорость работы — [math]O(n + m)[/math], где [math]n[/math] — длина строки, [math]m[/math] — длина образца.
  • Простая и понятная реализация.

Недостатки

  • Возможно подобрать входные данные так, что количество ложных срабатываний будет недопустимо большим (см. Пример худшего случая).

См. также

Примечания

Источники информации

  • Кормен, Томас Х., Лейзерсон, Чарльз И., Ривест, Рональд Л., Штайн Клиффорд Алгоритмы: построение и анализ, 3-е издание. Пер. с англ. — М.:Издательский дом "Вильямс", 2014. — 1328 с.: ил. — ISBN 978-5-8459-1794-2 (рус.) — страницы 1036–1041.
  • Codeforces: Anti-hash test