Глава 11. Представление множеств. Хеширование.

     11.1. Хеширование с открытой адресацией

     В предыдущей главе было несколько  представлений  для  мно-
жеств,  элементами которых являются целые числа произвольной ве-
личины. Однако в любом из них хотя бы одна из операций  проверки
принадлежности,  добавления  и удаления элемента требовала коли-
чества действий, пропорционального числу элементов множества. На
практике это бывает слишком много. Существуют способы,  позволя-
ющие  получить для всех трех упомянутых операций оценку C*log n.
Один из таких способов мы рассмотрим в следующей главе.  В  этой
главе мы разберем способ, которые хотя и приводит к C*n действи-
ям  в  худшем  случае,  но  зато "в среднем" требует значительно
меньшего их числа. (Мы не будем уточнять слов "в среднем",  хотя
это и можно сделать.) Этот способ называется хешированием.
     Пусть  нам необходимо представлять множества элементов типа
T, причем число элементов заведомо меньше n.  Выберем  некоторую
функцию h, определенную на значениях типа T и принимающую значе-
ния  0..(n-1).  Было  бы  хорошо, чтобы эта функция принимала на
элементах будущего множества по возможности более  разнообразные
значения.  Худший случай - это когда ее значения на всех элемен-
тах хранимого множества одинаковы. Эту  функцию  будем  называть
хеш-функцией.

     Введем два массива

         val:  array [0..n-1] of T;
         used: array [0..n-1] of boolean;

(мы  позволяем  себе писать n-1 в качестве границы в определении
типа, хотя в паскале это не разрешается). В этих массивах  будут
храниться  элементы  множества: оно равно множеству всех val [i]
для тех i, для которых used [i], причем все эти val [i]  различ-
ны.  По  возможности  мы  будем хранить элемент t на месте h(t),
считая это место "исконным" для элемента t.  Однако  может  слу-
читься  так,  что новый элемент, который мы хотим добавить, пре-
тендует на уже занятое место (для которого used истинно). В этом
случае мы отыщем ближайшее справа свободное место и запишем эле-
мент туда. ("Справа" значит  "в  сторону  увеличения  индексов";
дойдя  до  края,  мы  перескакиваем в начало.) По предположению,
число элементов всегда меньше n, так что пустые места гарантиро-
ванно будут.
     Формально говоря, в любой момент должно  соблюдаться  такое
требование:  для любого элемента множества участок справа от его
исконного места до его фактического места полностью заполнен.
     Благодаря этому проверка принадлежности заданного  элемента
t  осуществляется  легко: встав на h(t), двигаемся направо, пока
не дойдем до пустого места или до элемента t.  В  первом  случае
элемент  t отсутствует в множестве, во втором присутствует. Если
элемент отсутствует, то его можно добавить на  найденное  пустое
место.  Если  присутствует, то можно его удалить (положив used =
false).

     11.1.1. В предыдущем  абзаце  есть  ошибка.  Найдите  ее  и
исправьте.

     Решение.  Дело  в  том, что при удалении требуемое свойство
"отсутствия пустот" может нарушиться. Поэтому будем делать  так.
Создав дыру, будем двигаться направо, пока не натолкнемся на еще
одно  пустое место (тогда на этом можно успокоиться) или на эле-
мент, стоящий не на исконном месте. Во втором случае  посмотрим,
не  нужно  ли этот элемент поставить на место дыры. Если нет, то
продолжаем поиск, если да, то затыкаем им старую дыру. При  этом
образуется новая дыра, с которой делаем все то же самое.

     11.1.2.  Написать программы проверки принадлежности, добав-
ления и удаления.

     Решение.
  function принадлежит (t: T): boolean;
  | var i: integer;
  begin
  | i := h (t);
  | while used [i] and (val [i] <> t) do begin
  | | i := (i + 1) mod n;
  | end; {not used [i] or (val [i] = t)}
  | belong := used [i] and (val [i] = t);
  end;

  procedure добавить (t: T);
  | var i: integer;
  begin
  | i := h (t);
  | while used [i] and (val [i] <> t) do begin
  | | i := (i + 1) mod n;
  | end; {not used [i] or (val [i] = t)}
  | if not used [i] then begin
  | | used [i] := true;
  | | val [i] := t;
  | end;
  end;

  procedure исключить (t: T);
  | var i, gap: integer;
  begin
  | i := h (t);
  | while used [i] and (val [i] <> t) do begin
  | | i := (i + 1) mod n;
  | end; {not used [i] or (val [i] = t)}
  | if used [i] and (val [i] = t) then begin
  | | used [i] := false;
  | | gap := i;
  | | i := (i + 1) mod n;
  | | while used [i] do begin
  | | | if i = h (val[i]) then begin
  | | | | i := (i + 1) mod n;
  | | | end else if dist(h(val[i]),i) < dist(gap,i) then begin
  | | | | i := (i + 1) mod n;
  | | | end else begin
  | | | | used [gap] := true;
  | | | | val [gap] := val [i];
  | | | | used [i] := false;
  | | | | gap := i;
  | | | | i := i + 1;
  | | | end;
  | | end;
  | end;
  end;

     Здесь  dist  (a, b) - измеренное по часовой стрелке (слева
направо) расстояние от a до b, т.е.

     dist (a,b) = (b - a + n) mod n.

(Мы прибавили n, так как функция mod правильно работает  только
при положительном делимом.)

     11.1.3. Существует много вариантов хеширования. Один из них
таков: обнаружив, что исконное место (обозначим его  i)  занято,
будем  искать  свободное  не  среди  i+1, i+2,..., а среди r(i),
r(r(i)), r(r(r(i))),..., где r - некоторое отображение 0..n-1  в
себя. Какие при этом будут трудности?

     Ответ. (1) Не гарантируется, что если пустые места есть, то
мы их найдем. (2) При удалении неясно, как заполнять  дыры.  (На
практике во многих случаях удаление не нужно, так что такой спо-
соб  также  применяется.  Считается,  что удачный подбор r может
предотвратить образование "скоплений" занятых ячеек.)

     11.1.4.  Пусть  для  хранения  множества  всех   правильных
русских  слов  в  программе орфографии используется хеширование.
Что нужно добавить, чтобы к тому же  уметь  находить  английский
перевод любого правильного слова?

     Решение.  Помимо  массива  val,  элементы которого являются
русскими словами, нужен параллельный массив их английских  пере-
водов.

     11.2. Хеширование со списками

     На  хеш-функцию с m значениями можно смотреть как на способ
свести вопрос о хранении одного большого множества к  вопросу  о
хранении нескольких меньшим. Именно, если у нас есть хеш-функция
с  m значениями, то любое множество разбивается на m подмножеств
(возможно,   пустых),   соответствующих   возможных    значениям
хэш-функции.  Вопрос  о  проверке принадлежности, добавлении или
удалении для большого множества сводится к такому же вопросу для
одного из меньших (чтобы узнать, для какого, надо посмотреть  на
значение хеш-функции).

     В  принципе,  эти  меньшие  множества могут храниться любым
способом (раз они малы, это не очень важно), но удобно  их  хра-
нить  с помощью ссылок, поскольку нам известен их суммарный раз-
мер (равный числу элементов  хешируемого  множества).  Следующая
задача предлагает реализовать этот план.

     11.2.1. Пусть хеш-функция принимает значения 1..k. Для каж-
дого  значения хеш-функции рассмотрим список всех элементов мно-
жества с данным значением хеш-функции. Будем хранить эти k спис-
ков с помощью переменных

     Содержание: array [1..n] of T;
     Следующий: array [1..n] of 1..n;
     ПервСвоб: 1..n;
     Вершина: array [1..k] of 1..n;

так же, как мы это делали для k  стеков  ограниченной  суммарной
длины.  Напишите  соответствующие программы. (Теперь с удалением
будет меньше проблем.)

     Решение. Перед началом работы  надо  положить  Вершина[i]=0
для  всех  i=1..k,  и  связать  все  места  в  список свободного
пространства,  положив   ПервСвоб=1   и   Следующий[i]=i+1   для
i=1..n-1, а также Следующий[n]=0.

  function принадлежит (t: T): boolean;
  | var i: integer;
  begin
  | | i := Вершина[h(t)];
  | i := Вершина[h(t)];
  | {осталось искать в списке, начиная с i}
  | while (i <> 0) and (Содержание[i] <> t) do begin
  | | i := Следующий[i];
  | end; {(i=0) or (Содержание [i] = t)}
  | belong := Содержание[i]=t;
  end;

  procedure добавить (t: T);
  | var i: integer;
  begin
  | if not принадлежит(t) then begin
  | | i := ПервСвоб;
  | | {ПервСвоб <> 0 - считаем, что не переполняется}
  | | ПервСвоб := Следующий[ПервСвоб]
  | | Содержание[i]:=t;
  | | Следующий[i]:=Вершина[h(t)];
  | | Вершина[h(t)]:=i;
  | end;
  end;

  procedure исключить (t: T);
  | var i, pred: integer;
  begin
  | i := Вершина[h(t)]; pred := 0;
  | {осталось искать в списке, начиная с i;  pred -
  |    предыдущий. если он есть, и 0, если нет}
  | while (i <> 0) and (Содержание[i] <> t) do begin
  | | pred := i; i := Следующий[i];
  | end; {(i=0) or (Содержание [i] = t)}
  | if Содержание[i]=t then begin
  | | {элемент есть, надо удалить}
  | | if pred = 0 then begin
  | | | {элемент оказался первым в списке}
  | | | Вершина[h(t)] := Следующий[i];
  | | end else begin
  | | | Следующий[pred] := Следующий[i]
  | | end;
  | | {осталось вернуть i  в список свободных}
  | | Следующий[i] :=  ПервСвоб;
  | | ПервСвоб:=i;
  | end;
  end;

     11.2.2.   (Для  знакомых  с  теорией  вероятностей.)  Пусть
хеш-функция с m значениями используется для хранения  множества,
в  котором  в данный момент n элементов. Доказать, что математи-
ческое ожидание числа действий в предыдущей задаче не  превосхо-
дит  С*(1+n/m),  если добавляемый (удаляемый, искомый) элемент t
выбран случайно, причем все значения h(t) имеют  равные  вероят-
ности (равные 1/m).

     Решение.   Если   l(i)  -  длина  списка,  соответствующего
хеш-значению i, то число операцией не превосходит C*(1+l(h(i)));
усредняя, получаем искомый ответ, так как сумма всех l(i)  равна
n.

     Эта оценка основана на предположении о равных вероятностях.
Однако  в  конкретной  ситуации  всё может быть совсем не так, и
значения хеш-функции могут "скучиваться": для каждой  конкретной
хеш-функции есть "неудачные" ситуации, когда число действий ока-
зывается  большим.  Приём, называемый "универсальным хешировани-
ем", позволяет обойти эту проблему. Идея состоит в том, что  бе-
рётся  семейство  хеш-функций, причем любая ситуация оказывается
неудачной лишь для небольшой части этого семества.

     Пусть H - семейство функций, каждая из  которых  отображает
множество T в множество из n элементов (например, 0..n-1). Гово-
рят, что H - универсальное семейство хеш-функций, если для любых
двух различных значений s и t из множества T вероятность события
"h(s)=h(t)"  для  случайной  функции h из семейства H равна 1/n.
(Другими словами, те функции из H, для которых  h(s)=h(t),  сос-
тавляют 1/n-ую часть всех функций в H.)

     Замечание.  Более сильное требование к семейству H могло бы
состоять в том, чтобы для любых двух различных элементов s  и  t
множества  T  значения h(s) и h(t) случайной функции h являются
независимыми случайными величинами,  равномерно  распределенными
на 0..n-1.

     11.2.3. Пусть t[1]..t[u] - произвольная  последовательность
различных элементов множества T. Рассмотрим количество действий,
происходящих при помещении элементов t[1]..t[u] в множество, хе-
шируемое  с помощью функции h из универсального семейства H. До-
казать, что среднее количество действий (усреднение - по всем  h
из H) не превосходит C*u*(1+u/n).

     Решение. Обозначим через m[i] количество элементов последо-
вательности,   для   которых   хеш-функция   равна   i.   (Числа
m[0]..m[n-1] зависят, конечно,  от  выбора  хеш-функции.)  Коли-
чество действий, которое мы хотим оценить, с точностью до посто-
янного множителя равно сумме квадратов чисел m[0]..m[n-1]. (Если
k  чисел попадают в одну хеш-ячейку, то для этого требуется при-
мерно 1+2+...+k действий.) Эту же сумму квадратов можно записать
как число пар <p,q>, для которых h[t[p]]=h[t[q]]. Последнее  ра-
венство,  если его рассматривать как событие при фиксированных p
и q, имеет вероятность 1/n при p<>q,  поэтому  среднее  значение
соответствующего члена суммы равно 1/n, а для всей суммы получа-
ем оценку порядка u*u/n, а точнее u*u/n + u, если учесть члены с
p=q.

   Оценка  этой  задачи  показывает, что в на каждый добавляемый
элемент  приходится  в среднем C*(1+u/n) операций. В этой оценке
дробь u/n имеет смысл "коэффициента заполнения" хеш-таблицы.

     11.2.4. Доказать аналогичное утверждение  для  произвольной
последовательности  операций добавления, поиска и удаления (а не
только для добавления, как в предыдущей задаче).

     Указание. Будем представлять себе, что в ходе  поиска,  до-
бавления  и удаления элемент проталкивается по списку своих кол-
лег с тем же хеш-значением, пока не найдет своего  двойника  или
не  дойдет  до  конца  списка.  Будем называть i-j-столкновением
столкновение t[i] с t[j]. Общее число  действий  примерно  равно
числу всех столкновений плюс число элементов. При t[i]<>t[j] ве-
роятность i-j-столкновения равна  1/n.  Осталось  проследить  за
столкновениями  между  равными  элементами.  Фиксируем некоторое
значение x из множества T и посмотрим на связанные с ним  опера-
ции.  Они  идут по циклу: добавление - проверки - удаление - до-
бавление - проверки - удаление -  ...  Столкновения  между  ними
происходят  между добавляемым элементом и следующими за ним про-
верками (до удаления включительно), поэтому общее  их  число  не
превосходит числа элементов, равных x.

     Теперь приведем примеры универсальных  семейств.  Очевидно,
для  любых конечных множеств A и B семейство всех функций, отоб-
ражающих A в B, является универсальным.  Однако  этот  пример  с
практической  точки зрения бесполезен: для запоминания случайной
функции из этого семейства нужен массив, число элементов в кото-
ром равно числу элементов в множестве A. (А если мы  можем  себе
позволить  такой массив, то никакого хеширования нам не требует-
ся!)

     Более практичные примеры универсальных семейств могут  быть
построены  с помощью несложных алгебраических конструкций. Через
Z[p] мы обозначаем множество вычетов по простому модулю p,  т.е.
{0,1,...,p-1}; арифметические операции в этом множестве выполня-
ются  по модулю p. Универсальное семейство образуют все линейные
функционалы на Z[p] в степени n со значениями в Z[p]. Более под-
робно,  пусть  a[1],...,a[n]  -  произвольные   элементы   Z[p];
рассмотрим отображение

   h: <x[1]...x[n]> |-> a[1]x{1]+...+a{n]z[n]

Мы получаем семейство из (p в степени n) отображений, параметри-
зованное наборами a[1]...a[n].

     11.2.5. Доказать, что это семейство является универсальным.

     Указание. Пусть x и y - различные точки пространства Z[p] в
степени  n.  Какова  вероятность  того, что случайный функционал
принимает на них одинаковые значения?  Другими  словами,  какова
вероятность  того,  что  он равен нулю на их разности x-y? Ответ
дается таким утверждением: пусть u - ненулевой вектор; тогда все
значения случайного функционала на нем равновероятны.

     В  следующей  задаче  множество B={0,1} рассматривается как
множество вычетов по модулю 2.

     11.2.6. Семейство всех линейных отображений из (B в степени
m) в (B в степени n) является универсальным.

     Родственные идеи неожиданно оказываются полезными в  следу-
ющей ситуации (рассказал Д.Варсонофьев). Пусть мы хотим написать
программу, которая обнаруживала (большинство) опечаток в тексте,
но не хотим хранить список всех правильных словоформ.  Предлага-
ется   поступить  так:  выбрать  некоторое  N  и  набор  функций
f[1],...,f[k], отображающих русские слова в 1..N. В массиве из N
битов положим все биты равными нулю, кроме тех, которые являются
значением какой-то функции набора на какой-то правильной  слово-
форме.  Теперь  приближённый тест на правильность словоформы та-
ков: проверить, что значения всех функций набора на этой  слово-
форме попадают на места, занятые единицами.