Практикум по методам построения алгоритмов

Сопоставление с образцом

Разбить на страницы
Показывать лекцию целиком

10.1. Простейший пример

10.1.1. Имеется последовательность символов $${x[1]}\ldots{x[n]}$$. Определить, имеются ли в ней идущие друг за другом символы abcd. (Другими словами, требуется выяснить, есть ли в слове $${x[1]}\ldots{x[n]}$$ подслово abcd.)

Решение. Имеется примерно n (если быть точным, n-3 ) позиций, на которых может находиться искомое подслово в исходном слове. Для каждой из позиций можно проверить, действительно ли там оно находится, сравнив четыре символа. Однако есть более эффективный способ. Читая слово $${x[1]}\ldots{x[n]}$$ слева направо, мы ожидаем появления буквы a. Как только она появилась, мы ищем за ней букву b, затем c, и, наконец, d. Если наши ожидания оправдываются, то слово abcd обнаружено. Если же какая-то из нужных букв не появляется, мы оказываемся у разбитого корыта и начинаем все сначала.

Этот простой алгоритм можно описать в разных терминах. Используя терминологию так называемых конечных автоматов, можно сказать, что при чтении слова x слева направо мы в каждый момент находимся в одном из следующих состояний: "начальное" (0), "сразу после a " (1), "сразу после ab " (2), "сразу после abc " (3) и "сразу после abcd " (4). Читая очередную букву, мы переходим в следующее состояние по правилу, указанному в таблице.

Правила перехода для конечного автомата
Текущее состояние Очередная буква Новое состояние
0 a 1
0 кроме а 0
1 b 2
1 a 1
1 кроме a, b 0
2 c 3
2 a 1
2 кроме a, c 0
3 d 4
3 a 1
3 кроме a, d 0

Как только мы попадем в состояние 4, работа заканчивается.

Наглядно выполнение алгоритма можно представить себе так: фишка двигается из кружка в кружок по стрелкам; стрелка выбирается так, чтобы надпись на ней соответствовала очередной букве входного слова. Чтобы этот процесс был успешным, нужно, чтобы для каждой буквы была ровно одна подходящая стрелка из любого кружка.

Соответствующая программа очевидна (мы указываем новое состояние, даже если оно совпадает со старым; эти строки можно опустить):

i:=1; state:=0;
{i - первая непрочитанная буква, state - состояние}
while (i <> n+1) and (state <> 4) do begin
| if state = 0 then begin
| | if x[i] = a then begin
| | | state:= 1;
| | end else begin
| | | state:= 0;
| | end;
| end else if state = 1 then begin
| | if x[i] = b then begin
| | | state:= 2;
| | end else if x[i] = a then begin
| | | state:= 1;
| | end else begin
| | | state:= 0;
| | end;
| end else if state = 2 then begin
| | if x[i] = c then begin
| | | state:= 3;
| | end else if x[i] = a then begin
| | | state:= 1;
| | end else begin
| | | state:= 0;
| | end;
| end else if state = 3 then begin
| | if x[i] = d then begin
| | | state:= 4;
| | end else if x[i] = a then begin
| | | state:= 1;
| | end else begin
| | | state:= 0;
| | end;
| end;
end;
answer := (state = 4);

Иными словами, мы в каждый момент храним информацию о том, какое максимальное начало нашего образца abcd является концом прочитанной части. (Его длина и есть то " состояние", о котором шла речь.)

Терминология, нами используемая, такова. Слово - это любая последовательность символов из некоторого фиксированного конечного множества. Это множество называется алфавитом, его элементы - буквами. Если отбросить несколько букв с конца слова, останется другое слово, называемое началом первого. Любое слово также считается своим началом. Конец слова - то, что останется, если отбросить несколько первых букв. Любое слово считается своим концом. Подслово - то, что останется, если отбросить буквы и с начала, и с конца. (Другими словами, подслова - это концы начал, или, что то же, начала концов.)

В терминах индуктивных функций (см. раздел 1.3.) ситуацию можно описать так: рассмотрим функцию на словах, которая принимает два значения "истина" и "ложь" и истинна на словах, имеющих abcd своим подсловом. Эта функция не является индуктивной, но имеет индуктивное расширение$${x} \mapsto \text{длина максимального начала слова {abcd}, являющегося концом {x}}.$$

10.2. Повторения в образце - источник проблем

10.2.1. Можно ли в предыдущих рассуждениях заменить слово abcd на произвольное слово?

Решение. Нет, и проблемы связаны с тем, что в образце могут быть повторяющиеся буквы. Пусть, например, мы ищем вхождения слова ababc. Вот появилась буква a, за ней идет b, за ней идет a, затем снова b. В этот момент мы с нетерпением ждем буквы c. Однако - к нашему разочарованию - вместо нее появляется другая буква, и наш образец ababc не обнаружен. Однако нас может ожидать утешительный приз: если вместо c появилась буква a, то не все потеряно: за ней могут последовать буквы b и c, и образец-таки будет найден.

Вот картинка, поясняющая сказанное:$${\setlength{\tabcolsep}{.8\tabcolsep} \begin{tabular}{llllllllllllll} x y z a b a b a b c \ldots\leftarrowвходное слово\\ a b a b c \leftarrowмы ждали образца здесь\\ a b a b c \leftarrowа он оказался здесь\\ \end{tabular}$$ Таким образом, к моменту$${\setlength{\tabcolsep}{.8\tabcolsep} \begin{tabular}{lllllll|lllllll} x y z a b a b \leftarrowвходное слово\\ a b a b c \leftarrowмы ждали образца здесь\\ a b a b c \leftarrowа он оказался здесь\\ \end{tabular}$$ есть два возможных положения образца, каждое из которых подлежит проверке. Тем не менее по-прежнему возможен конечный автомат, читающий входное слово буква за буквой и переходящий из состояния в состояние в зависимости от прочитанных букв.

10.2.2. Указать состояния соответствующего автомата и таблицу перехода (новое состояние в зависимости от старого и читаемой буквы).

Решение. По-прежнему состояния будут соответствовать наибольшему началу образца, являющемуся концом прочитанной части слова. Их будет шесть: 0, 1 (a), 2 (ab), 3 (aba), 4 (abab), 5 (ababc). Таблица перехода такая.

Правила перехода для конечного автомата
Текущее состояние Очередная буква Новое состояние
0 a 1 (a)
0 кроме а 0
1 (a) b 2 (ab)
1 (a) a 1 (a)
1 (a) кроме a, b 0
2 (ab) a 3 (aba)
2 (ab) кроме a 0
3 (aba) b 4 (abab)
3 (aba) a 1 (a)
3 (aba) кроме a, b 0
4 (abab) c 5 (ababc)
4 (abab) a 3 (aba)
4 (abab) кроме a, c 0

Для проверки посмотрим, к примеру, на вторую снизу строку. Если прочитанная часть кончалась на abab, а затем появилась буква a, то теперь прочитанная часть кончается на ababa. Наибольшее начало образца ( ababc ), являющееся ее концом - это aba.

Философский вопрос: мы говорили, что трудность состоит в том, что есть несколько возможных положений образца, каждое из которых может оказаться истинным. Им соответствуют несколько начал образца, являющихся концами входного слова. Но конечный автомат помнит лишь самое длинное из них. Как же остальные?

Философский ответ. Дело в том, что самое длинное из них определяет все остальные - это его концы, одновременно являющиеся его началами.

Не составляет труда для любого конкретного образца написать программу, осуществляющую поиск этого образца описанным способом. Однако хотелось бы написать программу, которая ищет произвольный образец в произвольном слове. Это можно делать в два этапа: сначала по образцу строится таблица переходов конечного автомата, а затем читается входное слово и состояние преобразуется в соответствии с этой таблицей. Подобный метод часто используется для более сложных задач поиска (см. далее), но для поиска подслова существует более простой и эффективный алгоритм, называемый алгоритмом Кнута-Морриса-Пратта. (Ранее сходные идеи были предложены Ю.В. Матиясевичем.) Но прежде нам понадобятся некоторые вспомогательные утверждения.

10.3. Вспомогательные утверждения

Для произвольного слова $$X$$ рассмотрим все его начала, одновременно являющиеся его концами, и выберем из них самое длинное. (Не считая, конечно, самого слова $$X$$.) Будем обозначать его $$l(X)$$.

Примеры: $$l({aba})={a}$$, $$l({abab})={ab}$$, $$l({ababa})={aba}$$, $$l({abc}) = \text{пустое слово}$$

10.3.1. Доказать, что все слова $$l(X)$$, $$l(l(X))$$, $$l(l(l(X)))$$ и т.д. являются началами слова $$X$$.

Решение. Каждое из них (согласно определению) является началом предыдущего.

По той же причине все они являются концами слова $$X$$.

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

Решение. Каждое слово короче предыдущего.

10.3.3. Доказать, что любое слово, одновременно являющееся началом и концом слова $$X$$ (кроме самого $$X$$ ) входит в последовательность $$l(X), l(l(X)),\ldots$$

Решение. Пусть слово $$Y$$ есть одновременно начало и конец $$X$$. Слово $$l(X)$$ - самое длинное из таких слов, так что $$Y$$ не длиннее $$l(X)$$. Оба эти слова являются началами $$X$$, поэтому более короткое из них является началом более длинного: $$Y$$ есть начало $$l(X)$$. Аналогично, $$Y$$ есть конец $$l(X)$$. Рассуждая по индукции, можно предполагать, что утверждение задачи верно для всех слов короче $$X$$, в частности, для слова $$l(X)$$. Так что слово $$Y$$, являющееся концом и началом $$l(X)$$, либо равно $$l(X)$$, либо входит в последовательность $$l(l(X)), l(l(l(X))),\dots$$, что и требовалось доказать.

10.4. Алгоритм Кнута-Морриса-Пратта

Алгоритм Кнута-Морриса-Пратта (КМП) получает на вход слово$${X}= {x[1]x[2]}\ldots{x[n]}$$ и просматривает его слева направо буква за буквой, заполняя при этом массив натуральных чисел $${l[1]}\ldots{l[n]}$$, где$${l[i]} = \text{длина слова }l({x[1]}\ldots{x[i]})$$ (функция $$l$$ определена в предыдущем пункте). Словами: l[i] есть длина наибольшего начала слова $${x[1]}\ldots{x[i]}$$, одновременно являющегося его концом.

10.4.1. Какое отношение все это имеет к поиску подслова? Другими словами, как использовать алгоритм КМП для определения того, является ли слово A подсловом слова B?

Решение. Применим алгоритм КМП к слову A\#B, где \# - специальная буква, не встречающаяся ни в A, ни в B. Слово A является подсловом слова B тогда и только тогда, когда среди чисел в массиве l будет число, равное длине слова A.

10.4.2. Описать алгоритм заполнения таблицы $${l[1]}\ldots{l[n]}$$.

Решение. Предположим, что первые i значений $${l[1]}\ldots{l[i]}$$ уже найдены. Мы читаем очередную букву слова (т.е. x[i+1] ) и должны вычислить l[i+1].

Другими словами, нас интересуют начала $$Z$$ слова $${x[1]}\ldots{x[i+1]}$$, одновременно являющиеся его концами - из них нам надо выбрать самое длинное. Откуда берутся эти начала? Каждое из них (не считая пустого) получается из некоторого слова $$Z'$$ приписыванием буквы x[i+1]. Слово $$Z'$$ является началом и концом слова $${x[1]}\ldots{x[i]}$$. Однако не любое слово, являющееся началом и концом слова $${x[1]}\ldots{x[i]}$$, годится - надо, чтобы за ним следовала буква x[i+1].

Получаем такой рецепт отыскания слова $$Z$$. Рассмотрим все начала слова $${x[1]}\ldots{x[i]}$$, являющиеся одновременно его концами. Из них выберем подходящие - те, за которыми идет буква $${x[i+1]}$$. Из подходящих выберем самое длинное. Приписав в его конец x[i+1], получим искомое слово $$Z$$.

Теперь пора воспользоваться сделанными нами приготовлениями и вспомнить, что все слова, являющиеся одновременно началами и концами данного слова, можно получить повторными применениями к нему функции $$l$$ из предыдущего раздела. Вот что получается:

i:=1; l[1]:= 0;
{таблица l[1]..l[i] заполнена правильно}
while i <> n do begin
| len := l[i]
| {len - длина начала слова x[1]..x[i], которое является
|    его концом; все более длинные начала оказались
|    неподходящими}
| while (x[len+1] <> x[i+1]) and (len > 0) do begin
| | {начало не подходит, применяем к нему функцию l}
| | len := l[len];
| end;
| {нашли подходящее или убедились в отсутствии}
| if x[len+1] = x[i+1] do begin
| | {x[1]..x[len] - самое длинное подходящее начало}
| | l[i+1] := len+1;
| end else begin
| | {подходящих нет}
| | l[i+1] := 0;
| end;
| i := i+1;
end;

10.4.3. Доказать, что число действий в приведенном только что алгоритме не превосходит $$C{n}$$ для некоторой константы $$C$$.

Решение. Это не вполне очевидно: обработка каждой очередной буквы может потребовать многих итераций во внутреннем цикле. Однако каждая такая итерация уменьшает len по крайней мере на 1, и в этом случае l[i+1] окажется заметно меньше l[i]. С другой стороны, при увеличении i на единицу величина l[i] может возрасти не более чем на 1, так что часто и сильно убывать она не может - иначе убывание не будет скомпенсировано возрастанием.

Более точно, можно записать неравенство$${l[i+1]} \le {l[i]} - \hbox{(число итераций на {i}-м шаге)} + {1}$$ или$$\hbox{(число итераций на {i}-м шаге)}\le{l[i]}-{l[i+1]} + {1}.$$ Остается сложить эти неравенства по всем i и получить оценку сверху для общего числа итераций.

10.4.4. Будем использовать этот алгоритм, чтобы выяснить, является ли слово X длины n подсловом слова Y длины m. (Как это делать с помощью специального разделителя \#, описано выше.) При этом число действий будет не более $$C({n}+{m})$$, и используемая память тоже. Придумать, как обойтись памятью не более $$C{n}$$ (что может быть существенно меньше, если искомый образец короткий, а слово, в котором его ищут - длинное).

Решение. Применяем алгоритм КМП к слову $${A#B}$$. При этом вычисление значений $${l[1]},\ldots,{l[n]}$$ проводим для слова X длины n и запоминаем эти значения. Дальше мы помним только значение l[i] для текущего i - кроме него и кроме таблицы $${l[1]}\ldots{l[n]}$$, нам для вычислений ничего не нужно.

На практике слова X и Y могут не находиться подряд, поэтому просмотр слова X и затем слова Y удобно оформить в виде разных циклов. Это избавляет также от хлопот с разделителем.

10.4.5. Написать соответствующий алгоритм (проверяющий, является ли слово $${X}={x[1]}\ldots{x[n]}$$ подсловом слова $${Y}={y[1]}\ldots{y[m]}$$ ).

Решение. Сначала вычисляем таблицу $${l[1]}\ldots{l[n]}$$ как раньше. Затем пишем такую программу:

j:=0; len:=0;
{len - длина максимального начала слова X, одновременно
       являющегося концом слова y[1]..y[j]}
while (len <> n) and (j <> m) do begin
| while (x[len+1] <> y[j+1]) and (len > 0) do begin
| | {начало не подходит, применяем к нему функцию l}
| | len := l[len];
| end;
| {нашли подходящее или убедились в отсутствии}
| if x[len+1] = y[j+1] do begin
| | {x[1]..x[len] - самое длинное подходящее начало}
| | len := len+1;
| end else begin
| | {подходящих нет}
| | len := 0;
| end;
| j := j+1;
end;
{если len=n, слово X встретилось; иначе мы дошли до конца
   слова Y, так и не встретив X}

10.5. Алгоритм Бойера- Мура

Этот алгоритм делает то, что на первый взгляд кажется невозможным: в типичной ситуации он читает лишь небольшую часть всех букв слова, в котором ищется заданный образец. Как так может быть? Идея проста. Пусть, например, мы ищем образец abcd. Посмотрим на четвертую букву слова: если, к примеру, это буква e, то нет никакой необходимости читать первые три буквы. (В самом деле, в образце буквы e нет, поэтому он может начаться не раньше пятой буквы.)

Мы приведем самый простой вариант этого алгоритма, который не гарантирует быстрой работы во всех случаях. Пусть $${x[1]}\ldots{x[n]}$$ - образец, который надо искать. Для каждого символа s найдем самое правое его вхождение в слово X, то есть наибольшее k, при котором $${x[k]}={s}$$. Эти сведения будем хранить в массиве pos[s] ; если символ s вовсе не встречается, то нам будет удобно положить $${pos[s]}={0}$$ (мы увидим дальше, почему).

10.5.1. Как заполнить массив pos?

Решение.

положить все pos[s] равными 0
for i:=1 to n do begin
  pos[x[i]]:=i;
end;

В процессе поиска мы будем хранить в переменной last номер буквы в слове, против которой стоит последняя буква образца. Вначале $${last} = {n}$$ (длина образца), затем last постепенно увеличивается.

last:=n;
{все предыдущие положения образца уже проверены}
while last <= m do begin {слово не кончилось}
| if x[n] <> y[last] then begin {последние буквы разные}
| | last := last + (n - pos[y[last]]);
| | {n - pos[y[last]]  - это минимальный сдвиг образца,
| |    при котором напротив y[last] встанет такая же
| |    буква в образце. Если такой буквы нет вообще,
| |    то сдвигаем на всю длину образца}
| end else begin
| | если нынешнее положение подходит, т.е. если
| | x[1]..x[n] = y[last-n+1]..y[last],
| | то сообщить о совпадении;
| | last := last+1;
| end;
end;

Знатоки рекомендуют проверку совпадения проводить справа налево, т.е. начиная с последней буквы образца (в которой совпадение заведомо есть). Можно также немного сэкономить, произведя вычитание заранее и храня не pos[s], а n-pos[s], т.е. число букв в образце справа от последнего вхождения буквы s.

Возможны разные модификации этого алгоритма. Например, можно строку last:=last+1 заменить на last:=last+(n-u), где u - координата второго справа вхождения буквы x[n] в образец.

10.5.2. Как проще всего учесть это в программе?

Решение. При построении таблицы pos написать

for i:=1 to n-1 do...

(далее как раньше), а в основной программе вместо last:=last+1 написать

last:= last+n-pos[y[last]];

Приведенный нами упрощенный вариант алгоритма Бойера-Мура в некоторых случаях требует существенно больше n действий (число действий порядка mn ), проигрывая алгоритму Кнута-Морриса-Пратта.

10.5.3. Привести пример ситуации, в которой образец не входит в слово, но алгоритму требуется порядка mn действий, чтобы это установить.

Решение. Пусть образец имеет вид $${baaa}\ldots{aa}$$, а само слово состоит только из букв a. Тогда на каждом шаге несоответствие выясняется лишь в последний момент.

Настоящий (не упрощенный) алгоритм Бойера-Мура гарантирует, что число действий не превосходит $$C({m}+{n})$$ в худшем случае. Он использует идеи, близкие к идеям алгоритма Кнута-Морриса-Пратта. Представим себе, что мы сравнивали образец со входным словом, идя справа налево. При этом некоторый кусок $$Z$$ (являющийся концом образца) совпал, а затем обнаружилось различие: перед $$Z$$ в образце стоит не то, что во входном слове. Что можно сказать в этот момент о входном слове? В нем обнаружен фрагмент, равный $$Z$$, а перед ним стоит не та буква, что в образце. Эта информация может позволить сдвинуть образец на несколько позиций вправо без риска пропустить его вхождение. Эти сдвиги следует вычислить заранее для каждого конца $$Z$$ нашего образца. Как говорят знатоки, все это (вычисление таблицы сдвигов и ее использование) можно уложить в $$C( m+ n)$$ действий.

10.6. Алгоритм Рабина

Этот алгоритм основан на простой идее. Представим себе, что в слове длины $$m$$ мы ищем образец длины $$n$$. Вырежем окошечко размера $$n$$ и будем двигать его по входному слову. Нас интересует, не совпадает ли слово в окошечке с заданным образцом. Сравнивать по буквам долго. Вместо этого фиксируем некоторую функцию, определенную на словах длины $$n$$. Если значения этой функции на слове в окошечке и на образце различны, то совпадения нет. Только если значения одинаковы, нужно проверять совпадение по буквам.

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

10.6.1. Привести пример удобной для вычисления функции.

Решение. Заменим все буквы в слове и образце их номерами, представляющими собой целые числа. Тогда удобной функцией является сумма цифр. (При сдвиге окошечка нужно добавить новое число и вычесть пропавшее.)

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

10.6.2. Привести пример семейства удобных функций.

Решение. Выберем некоторое число $$p$$ (желательно простое, смотри далее) и некоторый вычет $$x$$ по модулю $$p$$. Каждое слово длины $$n$$ будем рассматривать как последовательность целых чисел (заменив буквы кодами). Эти числа будем рассматривать как коэффициенты многочлена степени $$n-1$$ и вычислим значение этого многочлена по модулю $$p$$ в точке $$x$$. Это и будет одна из функций семейства (для каждой пары $$p$$ и $$x$$ получается, таким образом, своя функция). Сдвиг окошка на $$1$$ соответствует вычитанию старшего члена ( $$x^{n-1}$$ следует вычислить заранее), умножению на $$x$$ и добавлению свободного члена.

Следующее соображение говорит в пользу того, что совпадения не слишком вероятны. Пусть число $$p$$ фиксировано и к тому же простое, а $$X$$ и $$Y$$ - два различных слова длины $$n$$. Тогда им соответствуют различные многочлены (мы предполагаем, что коды всех букв различны - это возможно, если $$p$$ больше числа букв алфавита). Совпадение значений функции означает, что в точке $$x$$ эти два различных многочлена совпадают, то есть их разность обращается в $$0$$. Разность есть многочлен степени $$n-1$$ и имеет не более $$n-1$$ корней. Таким образом, если $$n$$ много меньше $$p$$, то случайному $$x$$ мало шансов попасть в неудачную точку.

10.7. Более сложные образцы и автоматы

Мы можем искать не конкретное слово, а подслова заданного вида. Например, можно искать слова вида a?b, где вместо ? может стоять любая буква (иными словами, нас интересует буква b на расстоянии $$2$$ после буквы a ).

10.7.1. Указать конечный автомат, проверяющий, есть ли во входном слове фрагмент вида a?b.

Решение. Читая слово, следует помнить, есть ли буква a на последнем месте и на предпоследнем - пока не встретим искомый фрагмент. Автомат имеет состояния 00, 01, 10, 11, их смысл таков:$$\begin{tabular}{rl} 00 на предпоследнем и последнем местах нет {a}\\ 01 на предпоследнем нет, на последнем есть\\ 10 не предпоследнем есть, на последнем нет\\ 11 есть и там, и там \end{tabular}$$ Таблица переходов автомата:$$\raisebox{\depth}{\begin{tabular}{|c|c|c|} \hline Текущее Очередная Новое \\ состояние буква состояние \\ \hline 00 a 01 \\ 00 не a 00 \\ 01 a 11 \\ 01 не a 10 \\ 10 a 01 \\ 10 b найдено \\ 10 не {a} и не {b} 00 \\ 11 a11 \\ 11 b найдено \\ 11 не a и не b 10 \\ \hline \end{tabular}}$$

Другой стандартный знак в образце - это звездочка ( * ), на место которой может быть подставлено любое слово. Например, образец ab*cd означает, что мы ищем подслово ab, за которым следует что угодно, а затем (на любом расстоянии) идет cd.

10.7.2. Указать конечный автомат, проверяющий, есть ли во входном слове образец ab*cd (в описанном только что смысле).

Решение.$$\raisebox{\depth}{\begin{tabular}{|c|c|c|} \hline Текущее Очередная Новое \\ состояние буква состояние \\ \hline начальное {a} {a} \\ начальное не {a} начальное \\ a {b} {ab} \\ a {a} {a} \\ a не {a} и не {b} начальное \\ {ab} {c} {abc} \\ {ab} не {c} {ab} \\ {abc} {d} найдено \\ {abc} {c} {abc} \\ {abc} не {c} и не {d} {ab} \\ \hline \end{tabular}}$$

Еще один вид поиска - это поиск любого из слов некоторого списка.

10.7.3. Дан список слов $$X_1,\ldots,X_k$$ и слово $$Y$$. Определить, входит ли хотя бы одно из слов $$X_i$$ в слово $$Y$$ (как подслово). Количество действий не должно превосходить константы, умноженной на суммарную длину всех слов (из списка и того, в котором происходит поиск).

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

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

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

Склеим все образцы в дерево, объединив их совпадающие начальные участки. Например, набору образцов

Формально говоря, вершинами дерева являются все начала всех образцов, а сыновья вершины получаются приписыванием буквы.

Читая входное слово, мы двигаемся по этому дереву: текущая вершина - это наибольшая (самая правая) из вершин, являющихся концом прочитанной части ( $${}={}$$ наибольший конец прочитанной части, являющийся началом одного из образцов).

Определим функцию $$l$$, аргументами и значениями которой являются вершины дерева. Именно, $$l(P) = {}$$ наибольшая вершина дерева, являющаяся концом $$P$$. (Напомним, вершины дерева - это слова.) Нам понадобится такое утверждение:

10.7.4. Пусть $$P$$ - вершина дерева. Доказать, что множество всех вершин, являющихся концами $$P$$, равно $$\{l(P), l(l(P)),\ldots\}$$

Решение. См. доказательство аналогичного утверждения для алгоритма Кнута-Морриса-Пратта.

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

Остается понять, как для каждой вершины дерева вычислить указатель на значение функции $$l$$ в этой вершине. Это делается как раньше, при этом значения $$l$$ для более коротких слов используются при вычислении очередного значения функции $$l$$. Это означает, что вершины дерева следует просматривать в порядке возрастания их длины. Нетрудно понять, что все это можно уложить в требуемое число действий (хотя константа зависит от числа букв в алфавите). Относящиеся к этому подробности см. в лекции 9.

Можно поинтересоваться, какие свойства слов распознаются с помощью конечных автоматов. Оказывается, что существует просто описываемый класс образцов, задающий все такие свойства - класс регулярных выражений.

Пусть фиксирован конечный алфавит $$\Gamma$$, не содержащий символов $$\Lambda$$, $$\varepsilon$$, (, ), * и | (они будут использоваться для построения регулярных выражений и не должны перемешиваться с буквами). Регулярные выражения строятся по таким правилам:

  • буква алфавита Г - регулярное выражение;
  • символы $$\Lambda,$$ $$\varepsilon$$ - регулярные выражения
  • если A,B,C,...,E - регулярные выражения, то (ABC...E) - регулярное выражение;
  • если A,B,C,...,E - регулярные выражения, то (A|B|C|...|E) - регулярное выражение;
  • если A - регулярное выражение, то A* - регулярное выражение.
    •

    Каждое регулярное выражение задает множество слов в алфавите $$\Gamma$$ по таким правилам:

  • букве соответствует одноэлементное множество, состоящее из однобуквенного слова, состоящего из этой буквы;
  • символу $$\varepsilon$$ соответствует пустое множество, а символу $$\Lambda$$ - одноэлементное множество, единственным элементом которого является пустое слово;
  • регулярному выражению (ABC...E) соответствует множество всех слов, которые можно получить, если к слову из A приписать слово из B, затем из C,..., затем из E
  • регулярному выражению (A|B|C|...|E) соответствует объединение множеств, соответствующих выражениям A,B,C,...,E ;
  • регулярному выражению A{*} соответствует итерация множества, соответствующего выражению A, то есть множество всех слов, которые можно так разрезать на куски, что каждый кусок принадлежит множеству, соответствующему выражению A. (В частности, пустое слово всегда содержится в A*.)
    •

    Множества, соответствующие регулярным выражениям, Называются регулярными. Вот несколько примеров:$$\begin{tabular}{ll} Выражение Множество \\[1ex] % {(a|b)*} все слова из букв {a} и {b}\\ {(aa)*} слова из четного числа букв {a}\\ {(}\Lambda{|a|b|aa|ab|ba|bb)} % ??? пробел после запятой? все слова длины не более 2 из букв {a}, {b} \end{tabular}$$

    10.7.5. Написать регулярное выражение, которому соответствует множество всех слов из букв a и b, в которых число букв a четно.

    Решение. Выражение b* задает все слова без буквы a, а выражение $${(b*}\,{a}\,{b*}\,{a}\,{b*)}$$ - все слова ровно с двумя буквами a. Остается объединить эти множества, а потом применить итерацию:$${(}\,{(b*}\,{a}\,{b*}\,{a}\,{b*)}\,|\,{b*}\,{)*}$$ Другой вариант ответа:$${(b*}\,{a}\,{b*}\,{a)} {*}\,{b*}$$

    10.7.6. Написать регулярное выражение, которое задает множество всех слов из букв $${a},{b},{c}$$, в которых слово bac является подсловом.

    Решение. $${((a|b|c)*}\,{bac}\,{(a|b|c)*)}$$

    10.7.7. Написать регулярное выражение, которое задает множество всех слов из букв $${a},{b},{c}$$, в которых слово bac не является подсловом.

    Указание. Эта задача сложнее предыдущей; видимо, самый простой способ ее решить - перейти к конечным автоматам и вернуться обратно (см. ниже задачу 10.7.14.).

    Теперь задачу о поиске образца в слове можно переформулировать так: проверить, принадлежит ли слово множеству, соответствующему данному регулярному выражению.

    10.7.8. Какие выражения соответствуют образцам a?b и ab*cd, рассмотренным ранее? (В образце символ * используется не в том смысле, что в регулярных выражениях!) Предполагается, что алфавит содержит буквы $${a},{b},{c},{d},{e}$$.

    Решение.

    ((a|b|c|d|e)*a(a|b|c|d|e)b(a|b|c|d|e)*)
((a|b|c|d|e)*ab(a|b|c|d|e)*cd(a|b|c|d|e)*)

    10.7.9. Доказать, что для всякого регулярного выражения можно построить конечный автомат, который распознает соответствующее этому выражению множество слов.

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

    Будем двигаться различными способами из Н в К, читая буквы по дороге (на тех стрелках, где они есть). Каждому пути из Н в К, таким образом, соответствует некоторое слово. А источнику в целом соответствует множество слов - тех слов, которые можно прочесть на путях из Н в К.

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

    Мы будем строить конечный автомат по регулярному выражению в два приема. Сначала мы построим источник, которому соответствует то же самое множество слов. Затем для произвольного источника построим автомат, который проверяет, принадлежит ли слово соответствующему множеству.

    10.7.10. По регулярному выражению построить источник, задающий то же множество.

    Решение. Индукция по построению регулярного выражения. Буквам соответствуют графы из одной стрелки. Объединение реализуется так:

    Нарисована картинка для объединения трех множеств, прямоугольники - это источники, им соответствующие; указаны начальные и конечные вершины. На новых стрелках (их $$6$$ ) букв не написано.

    Конкатенации соответствует картинка

    Наконец, итерации соответствует картинка

    10.7.11. Дан источник. Построить конечный автомат, проверяющий, принадлежит ли входное слово соответствующему множеству (то есть можно ли прочесть это слово, идя из Н в К).

    Решение. Состояниями автомата будут множества вершин источника. Именно, прочтя некоторое начало $$X$$ входного слова, мы будем помнить множество всех вершин источника, в которые можно пройти из начальной, прочитав на пути слово $$X$$.

    Тем самым задача решена.

    Оказывается, что регулярные выражения, автоматы и источники распознают одни и те же множества. Чтобы убедиться в этом, нам осталось решить такую задачу:

    10.7.12. Дан источник. Построить регулярное выражение, задающее то же множество, что и этот источник.

    Решение. Пусть источник имеет вершины $$1,\ldots,k$$. Будем считать, что $$1$$ - это начало, а $$k$$ - конец. Через $$D_{i,j,s}$$ обозначим множество всех слов, которые можно прочесть на пути из $$i$$ в $$j$$, если в качестве промежуточных пунктов разрешается использовать только вершины $$1,\ldots,s$$. Согласно определению, источнику соответствует множество $$D_{1,k,k}$$.

    Индукцией по $$s$$ будем доказывать регулярность всех множеств $$D_{i,j,s}$$ при всех $$i$$ и $$j$$. При $$s=0$$ это очевидно (промежуточные вершины запрещены, поэтому каждое из множеств состоит только из букв).

    Из чего состоит множество $$D_{i,j,s+1}$$? Отметим на пути моменты, в которых он заходит в $$(s+1)$$ -ую вершину. При этом путь разбивается на части, каждая из которых уже не заходит в нее. Поэтому легко сообразить, что$$D_{i,j,s+1} = D_{i,j,s}\,|\, (D_{i,s+1,s}\;\;\; D_{s+1,s+1,s}{*}\;\;\; D_{s+1,j,s})$$ (вольность записи: мы используем для операций над множествами обозначения как для регулярных выражений). Остается воспользоваться предположением индукции.

    10.7.13. Где еще используется то же самое рассуждение?

    Ответ. В алгоритме Флойда вычисления цены кратчайшего пути, см. лекцию 9 (Разные алгоритмы на графах).

    10.7.14. Доказать, что класс множеств, задаваемых регулярными выражениями, не изменился бы, если бы мы разрешили использовать не только объединение, но и отрицание (а следовательно, и пересечение - оно выражается через объединение и отрицание).

    Решение. Для автоматов переход к отрицанию очевиден.

    Замечание. На практике важную роль играет число состояний автомата. Оказывается, что тут все не так просто, и переход от источника к автомату требует экспоненциального роста числа состояний. Подробное рассмотрение связанных с этим теоретических и практических вопросов - дело особое (см. книгу Ахо, Ульмана и Сети о компиляторах).

    10.8. Суффиксные деревья

    До сих про наши программы сначала получали образец, который надо искать, а потом текст, в котором надо искать. В следующих задачах все наоборот.

    10.8.1. Программа получает на вход слово $$Y$$ длины $$m$$ и может его обрабатывать (пока без ограничений на время и память). Затем она получает слово $$X$$ длины $$n$$ и должна сообщить, является ли оно подсловом слова $$Y$$. При этом число операций при обработке слова $$X$$ должно быть порядка $$n$$ (не превосходить $$cn$$, где константа $$c$$ может зависеть от размера алфавита). Как написать такую программу?

    Решение. Пока не накладывается никаких ограничений на время и память при обработке $$Y$$, это не представляет труда. Именно, надо склеить все подслова слова $$Y$$ в дерево, объединив слова с общими началами (как мы это делали, распознавая вхождения нескольких образцов). Например, для $$Y=ababc$$ получится такое дерево подслов (на ребре написана буква, которая добавляется при движении по этому ребру; вершины находятся во взаимно однозначном соответствии с подсловами слова $$Y$$ ):

    Пусть такое дерево построено. После этого, читая слово $$X$$ слева направо, мы прослеживаем $$X$$ в дереве, начав с корня; слово $$X$$ будет подсловом слова $$Y$$, если при этом мы не выйдем за пределы дерева.

    Заметим, что аналогичная конструкция годится для любого множества слов $$U$$, а не только для множества всех подслов данного слова: после того как соответствующее дерево построено, мы можем про любое слово $$X$$ определить его принадлежность к $$U$$ за время, пропорциональное длине $$X$$. (Надо только дополнительно хранить в вершине дерева информацию, принадлежит ли соответствующее ей слово множеству $$U$$ или лишь является началом другого слова, принадлежащего $$U$$.)

    10.8.2. Решить предыдущую задачу с дополнительным ограничением: объем используемой памяти пропорционален длине слова $$Y$$.

    Решение. Прежний способ не годится: число вершин дерева равно числу подслов слова $$Y$$, а у слова длины $$m$$ число подслов может быть порядка $$m^2$$, а не $$m$$. Однако мы можем "сжать" наше дерево, оставив вершинами лишь точки ветвления (где больше одного сына). Тогда на ребрах дерева надо написать уже не буквы, а куски слова $$Y$$.

    Вот что получится при сжатии нашего примера:

    Будем считать (здесь и далее), что последняя буква слова $$Y$$ больше в нем не встречается. (Этого всегда можно достичь, дописав дополнительный фиктивный символ.) Тогда листья сжатого дерева соответствуют концам слова $$Y$$, а внутренние вершины (точки ветвления) - таким подсловам $$s$$ слова $$Y$$, которые встречаются в $$Y$$ несколько раз, и притом с разными буквами после $$s$$.

    У каждой внутренней вершины (не листа) сжатого дерева есть не менее двух сыновей. В деревьях с такими свойствами число внутренних вершин не превосходит числа листьев. (В самом деле, при движении слева направо в каждой точке ветвления добавляется новый путь к листу.) Поскольку листьев $$m$$, всего вершин не более $$2m$$, и мы уложимся в линейную по $$m$$ память, если будем экономно хранить пометки на ребрах. Каждая такая пометка является подсловом слова $$Y$$, и потому достаточно указывать координату ее начала и конца в $$Y$$. Это не помешает впоследствии прослеживать произвольное слово $$X$$ в этом дереве буква за буквой, просто в некоторые моменты мы будем находиться внутри ребер (и должны помнить, внутри какого ребра и в какой позиции мы находимся). При появлении новой буквы слова $$X$$ ее нужно сравнить с соответствующей буквой пометки этого ребра (что можно сделать за $$O(1)$$ действий, так как координату этой буквы мы знаем.)

    Построенное нами сжатое дерево называют сжатым суффиксным деревом } слова $$Y$$ (концы слова называют "суффиксами").

    10.8.3. Показать, что построение сжатого суффиксного дерева можно выполнить за время $$O(m^2)$$ с использованием $$O(m)$$ памяти.

    Решение. Будем добавлять в суффиксное дерево суффиксы по очереди. Добавление очередного суффикса делается так же, как и проверка принадлежности: мы читаем его буква за буквой и прокладываем путь в дереве. В некоторый момент добавляемый суффикс выйдет за пределы дерева (напомним, что мы считаем, что последний символ слова уникален).

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

    Гораздо более сложной задачей является построение сжатого суффиксного дерева за линейное время (вместо квадратичного, как в предыдущей задаче). Чтобы изложить алгоритм МакКрейта, который решает эту задачу, нам понадобятся некоторые приготовления.

    Для начала опишем более подробно структуру дерева, которое мы используем, и операции с ним.

    Мы рассматриваем деревья с корнем, на ребрах которых написаны слова (пометки); все пометки являются подсловами некоторого заранее фиксированного слова $$Y$$. При этом выполнены такие свойства:

  • каждая внутренняя вершина имеет хотя бы двух сыновей;
  • пометки на ребрах, выходящих из данной вершины, начинаются на разные буквы.
    •

    Каждой вершине $$v$$ такого дерева соответствует слово, которое записано на пути от корня $$r$$ к вершине $$v$$. Будем обозначать это слово $$s(v)$$. Обозначим пометку на ребре, ведущем к $$v$$, через $$l(v)$$, а отца вершины $$v$$ - через $$f(v)$$. Тогда $$s(r)=\Lambda$$ (пустое слово), а$$s(v)=s(f(v))+l(v),$$ для любой вершины $$v\ne r$$ (знак " $$+$$ " обозначает соединение строк).

    Помимо вершин дерева, мы будем рассматривать позиции в нем, которые могут быть расположены в вершинах, а также "внутри ребер" (разделяя пометку этого ребра на две части). Формально говоря, позиция представляет собой пару $$(v,k)$$, где $$v$$ - вершина (отличная от корня), а $$k$$ - целое число в промежутке $$[0, |l(v)|)$$, указывающее, на сколько букв надо вернуться от $$v$$ к корню. Здесь $$|l(v)|$$ - длина пометки $$l(v)$$ ; значение $$k=l(v)$$ соответствовало бы предыдущей вершине и потому не допускается. К числу позиций мы добавляем также пару $$(r,0)$$, соответствующую корню дерева. Каждой позиции $$p=(v,k)$$ соответствует слово $$s(p)$$, которое получается удалением $$k$$ последних символов из $$s(v)$$.

    Пусть $$p$$ - произвольная позиция в дереве, а $$w$$ - слово. Пройти вдоль $$w$$, начиная с $$p$$, означает найти другую позицию $$q$$, для которой $$s(q)=s(p)+w$$. Если такая позиция есть, то (при описанном способе хранения пометок, когда указываются координаты их начала и конца внутри $$Y$$ ) ее можно найти за время, пропорциональное длине слова $$w$$. Если такой позиции нет, то в какой-то момент мы "свернем с пути"; в этот момент можно пополнить дерево, сделав отсутствующую в дереве часть слова $$w$$ пометкой на пути к новому листу. Надо только, чтобы эта пометка была подсловом слова $$Y$$ (при нашем способе хранения пометок); это будет гарантировано, если прослеживаемое слово $$w$$ является подсловом слова $$Y$$.

    Заметим, что при этом может образоваться новая вершина (если развилка оказалась внутри ребра), а может и не образоваться (если развилка оказалась в вершине). Число действий при такой модификации пропорционально длине пройденной части слова (длина непройденной не важна).

    Оказывается, что навигацию в дереве можно ускорить, если заранее известно, что она будет успешной.

    10.8.4. Пусть для данной позиции $$p$$ и слова $$w$$ заранее известно, что в дереве есть позиция $$q$$, для которой $$s(q)=s(p)+w$$. Показать, что позицию $$q$$ можно найти за время, пропорциональное числу ребер дерева на пути от $$p$$ к $$q$$. (Это число может быть значительно меньше длины слова $$w$$, если пометки на ребрах длинные.)

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

    Подведем итоги. Рассмотренный способ хранения деревьев позволяет (для фиксированного слова $$Y$$ )

  • создать дерево из одного корня [ $$O(1)$$ ];
  • найти отца любой вершины (кроме корня) [ $$O(1)$$ ];
  • узнать пометку любой вершины (кроме корня), то есть пометку ведущего к ней ребра [ $$O(1)$$ ];
  • пройти из любой позиции $$p$$ вдоль любого слова $$w$$, если заранее известно, что мы не выйдем из дерева; результатом является позиция $$q$$ в дереве, для которой $$s(q)=s(p)+w$$ [ O (число ребер на пути)];
  • добавить слово $$w$$, начав с позиции $$p$$ ; если при этом слово $$w$$ является подсловом $$Y$$, а в дереве нет позиции $$q$$, для которой $$s(q)=s(p)+w$$, то дерево меняется и такая позиция $$q$$ создается (она будет листом) [ O (число букв в w, не вошедших в l(q) ];
  • наконец, для любого слова $$X$$ можно выяснить, найдется ли в дереве позиция $$q$$, для которой $$s(q)=X$$ [ $$O(|X|)$$ ].
    •

    В квадратных скобках указано число действий при выполнении соответствующих операций.

    Еще мы будем хранить в вершинах дерева " суффиксные ссылки " (в каждой вершине будет не более одной ссылки на другую вершину), но сначала надо объяснить, что это такое.

    Начнем с полного (не сжатого) суффиксного дерева для слова $$Y$$. Каждой его вершине (кроме корня) отвечает некоторое непустое подслово слова $$Y$$. Если мы отрежем у этого подслова последнюю букву, то в дереве спустимся на один шаг к корню. Но что будет, если мы отрежем первую букву? Снова получится подслово, но оно уже будет совсем в другом месте дерева.

    Вот как выглядят эти переходы в нашем примере (отрезание первой буквы соответствует пунктирной стрелке):

    Эти стрелки мы будем называть суффиксными ссылками, поскольку они соответствуют переходу от слова к его суффиксу на единицу меньшей длины. Они определены для всех вершин, кроме корня.

    Формально можно сказать так. Пусть $$w'$$ означает слово $$w$$ без первой буквы ( $$w'$$ определено для любого непустого слова $$w$$ ). Тогда суффиксная ссылка ведет из вершины $$p$$ в вершину $$q$$, если $$s(q)=s(p)'$$ (напомним, что $$s(u)$$ - слово, соответствующее вершине $$u$$ ).

    10.8.5. Как связаны суффиксные ссылки двух соседних вершин (отца и сына)?

    Ответ. Они указывают на соседние вершины, и буква на соединяющем их ребре та же самая.

    10.8.6. Доказать, что при переходе к сжатому суффиксному дереву ссылки по-прежнему идут из вершины в вершину (а не внутрь ребер).

    Решение. В самом деле, по нашему предположению последняя буква слова больше в нем не встречается, поэтому из листа ссылка ведет в лист. А если вершина (отличная от корня) является точкой ветвления, то соответствующее ей слово $$s$$ встречается с различными буквами после него. Другими словами, для некоторых букв $$a$$ и $$b$$ слова $$sa$$ и $$sb$$ являются подсловами слова $$Y$$. Отрезав от них первую букву, получим слова $$s'a$$ и $$s'b$$, которые также являются подсловами слова $$Y$$, поэтому и $$s'$$ является точкой ветвления.

    Вот что получится для нашего примера:

    Теперь мы уже готовы к изложению алгоритма МакКрейта. Сжатое суффиксное дерево строим постепенно, добавляя к нему суффиксы по мере уменьшения их длины. Обозначим через $$Y_i$$ суффикс, начинающийся с $$i$$ -ой буквы слова $$Y$$. (Таким образом, $$Y_1=Y$$, а $$Y_m$$ состоит из одной буквы.) После $$i$$ шагов построения наше дерево будет хранить $$Y_1,\ldots,Y_i$$.

    10.8.7. Показать, что суффиксные ссылки в таком дереве определены корректно (ведут в другую вершину того же дерева) для всех вершин, кроме, возможно, последнего добавленного листа (соответствующего слову $$Y_i$$ ) и его отца.

    Решение. В самом деле, суффиксная ссылка из листа $$Y_j$$ ведет в лист $$Y_{j+1}$$, и потому ей есть куда вести. Рассмотрим теперь внутреннюю вершину $$v$$, не являющуюся отцом последнего листа. Пусть в ней разветвляются два пути в листья $$Y_j$$ и $$Y_k$$. Без ограничения общности можно считать, что $$j,k<i$$ (если один из путей ведет в $$Y_i$$, то его можно заменить другим, ведь вершина $$v$$ по предположению не последняя развилка на этом пути). Отрезав от этих путей первый символ, получим пути в листья $$Y_{j+1}$$ и $$Y_{k+1}$$ ; эти пути присутствуют в дереве (поскольку $$j+1$$ и $$k+1$$ не превосходят $$i$$ ), а точка их развилки будет концом суффиксной ссылки вершины $$v$$.

    Суффиксные ссылки для листьев нам не понадобятся, и вычислять мы их не будем, а для всех остальных вершин дерева мы их будем вычислять и хранить. Более точно, после $$i$$ шагов алгоритма

  • в дереве хранятся слова $$Y_1,\ldots Y_i$$ (и все их начала);
  • адрес листа, соответствующего последнему добавленному суффиксу ( $$Y_i$$ ) хранится в переменной $$\textit{last}$$ ;
  • для всех внутренних вершин дерева, кроме, быть может, отца вершины $$\textit{last}$$, хранится правильная суффиксная ссылка.
    •

    Надо понять, как поддерживать это при добавлении очередного суффикса. Можно, не мудрствуя лукаво, добавлять $$Y_{i+1}$$ буква за буквой, начиная с корня дерева. (Именно так мы раньше и делали, и это требовало квадратичного времени.)

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

    Оба варианта предполагают, что отец $$u$$ листа $$\textit{last}$$ не совпадает с корнем. (Если совпадает, нам придется добавлять $$Y_{i+1}$$ от корня.) Пусть $$\textit{tail}$$ - пометка листа $$\textit{last}$$, а $$\textit{head}=s(u)$$ ; другими словами, слово $$\textit{head}$$ соответствует вершине $$u$$. Тогда$$Y_i = \textit{head}+\textit{tail}.$$ Отрезая первую букву, получаем$$Y_{i+1}=\textit{head}\,'+\textit{tail}.$$

    Заметим, что $$\textit{head}\,'$$ заведомо не выходит за пределы дерева. В самом деле, $$\textit{u}$$ было точкой ветвления, поэтому помимо листа $$Y_i$$ через точку $$u$$ проходил и лист $$Y_j$$ с $$j<i$$. Тогда $$Y_j$$ начинается на $$\textit{head}$$, а $$Y_{j+1}$$ начинается на $$\textit{head}\,'$$ и уже есть в дереве.

    Поэтому мы можем сначала проследить $$\textit{head}\,'$$ (найти позицию $$v$$, для которой $$s(v)=\textit{head}\,'$$ ), а потом уже добавить $$\textit{tail}$$, начиная с $$v$$.

    Первый способ оптимизации: $$\textit{head}\,'$$ заведомо есть в дереве.

    Эта оптимизация никак не использует суффиксных ссылок. Второй способ оптимизации их использует и позволяет (в том случае, когда применим) обойтись без прослеживания $$Y_{i+1}$$ от корня (как ускоренного, так и обычного). Пусть на пути к листу $$\textit{last}$$, представляющему суффикс $$Y_i$$, имеется вершина $$v$$, у которой суффиксная ссылка указывает на вершину $$w$$, так что $$s(w)=s(v)'$$. Пусть $$p$$ - слово на пути от $$v$$ к $$\textit{last}$$.

    Тогда

    $$Y_{i}=s(v)+p,\quad Y_{i+1}=Y_{i}'=s(v)'+p= s(w)+p,$$

    и для добавления $$Y_{i+1}$$ в дерево достаточно добавить слово $$p$$, начиная с вершины $$w$$.

    Второй способ оптимизации сочетается с первым: отрезок слова $$p$$ от $$v$$ до отца листа $$\textit{last}$$ можно проходить с уверенностью, что мы не выйдем за пределы дерева.

    Итак, мы можем описать действия, выполняемые при добавление очередного суффикса $$Y_{i+1}$$ в дерево, следующим образом.

    Второй способ оптимизации: пользуемся суффиксной ссылкой вершины на пути к $$\textit{last}$$.

    Пусть $$u$$ - отец листа $$\textit{last}$$, соответствующего последнему уже добавленному суффиксу $$Y_i$$.

    Случай 1: $$u$$ есть корень дерева. Тогда ни одна из оптимизаций не применима, и мы добавляем $$Y_{i+1}$$, начиная от корня.

    Случай 2: $$u$$ не есть корень дерева, но отец $$u$$ есть корень дерева (лист $$\textit{last}$$ находится на высоте $$2$$ ). Тогда $$Y_i=\textit{head}+\textit{tail}$$, где $$\textit{head}$$ и $$\textit{tail}$$ - пометки вершин $$u$$ и $$\textit{last}$$. Мы применяем первую оптимизацию и прослеживаем $$\textit{head}\,'$$ с гарантией до некоторой позиции $$z$$, а потом добавляем $$\textit{tail}$$ от $$z$$.

    Случай 3: $$u$$ не есть корень дерева и его отец $$v$$ также не есть корень дерева. Тогда для $$v$$ имеется суффиксная ссылка на некоторую вершину $$w$$, и $$s(w)=s(v)'$$. Пусть $$\textit{pretail}$$ - пометка вершины $$u$$, а $$\textit{tail}$$ - пометка листа $$\textit{last}$$, при этом $$Y_i=s(v)+\textit{pretail}+\textit{tail}$$ и потому $$Y_{i+1}=Y_i'=s(w)+\textit{pretail}+\textit{tail}$$. Остается проследить $$\textit{pretail}$$ от вершины $$w$$ с гарантией, получив некоторую позицию $$z$$, а потом добавить $$\textit{tail}$$ от вершины $$z$$.

    Остается еще понять, как поддерживать структуру суффиксных ссылок (адрес нового листа у нас получается при добавлении сам собой, так что с ним проблем нет) и оценить число действий при выполнении этих процедур последовательно для всех суффиксов.

    Начнем с суффиксных ссылок. По правилам они должны быть у всех внутренних вершин, кроме отца только что добавленного листа. Поэтому нам надо заботиться об отце листа $$\textit{last}$$, соответствующего $$Y_i$$ (этот лист перестал быть "только что добавленным"; напротив, единственная новая вершина как раз является отцом только что добавленного листа и в ней суффиксная ссылка не нужна). Это актуально в случаях 2 и 3, но в этих случаях по ходу дела была найдена нужная вершина $$z$$, куда и будет направлена суффиксная ссылка из $$u$$. Строго говоря, $$z$$ могла быть не вершиной, а позицией, но тогда после добавления она станет вершиной (отцом только что добавленного листа) - ведь в новом дереве $$u$$ уже не является отцом последнего листа, и потому суффиксная ссылка из $$u$$, как было доказано, должна вести в вершину. (Другими словами, в случаях 2 и 3, если позиция $$z$$ была внутри ребра, то в ней ребро разрезается.)

    Все сказанное можно условно записать в виде такого алгоритма добавления суффикса $$Y_{i+1}$$:

    { дерево содержит суффиксы Y1,...,Yi
  s(last)=Yi
  имеются корректные суффиксные ссылки для всех
  внутренних вершин, кроме отца листа last} 
u :=  отец листа last;
tail := пометка листа last;
Yi=s(u)+tail 
if u=корень дерева then begin
| {Yi+1=tail'}  
| добавить tail', начиная с корня,
|    полученный лист поместить в last
end else begin}
| v := отец вершины u;
| pretail := пометка вершины u;
| {Yi=s(v)+pretail}+tail}
| if v = корень дерева then begin
| | {Yi+1=pretail'+tail} 
| | проследить pretail' из корня в z
| end else begin
| | w := суффиксная ссылка вершины v;
| | s(w)=s(v)', Yi+1=s(w)+pretail+tail} 
| | проследить pretail из w в z
| end;
| {осталось добавить tail из z и ссылку из u в z}
| if позиция z является вершиной then begin
| | поместить в u ссылку на z;
| | добавить tail, начиная с z,
| |     полученный лист поместить в last;
| end else begin
| добавить tail, начиная с z,
|     полученный лист поместить в last;
| поместить в u ссылку на отца листа last;
| end
end;

    Осталось оценить число действий, которые выполняются при последовательном добавлении суффиксов $$Y_1,\ldots, Y_m$$. При добавлении каждого следующего суффикса выполняется конечное число действий, если не считать действий при "прослеживании" и "добавлении". Нам надо установить, что общее число действий есть $$O(m)$$ ; для этого достаточно отдельно доказать, что суммарное число действий при всех прослеживаниях есть $$O(m)$$ и суммарное число действий при всех добавлениях есть $$O(m)$$. (Заметим, что некоторые прослеживания или добавления могут быть долгими - но это компенсируется другими.)

    Прослеживания. Длительность прослеживания пропорциональна числу $$k$$ задействованных в нем ребер, но при этом высота последнего добавленного листа (число ребер на пути к нему) увеличивается на $$k-O(1)$$ (по сравнению с предыдущим добавленным листом). Чтобы убедиться в этом, достаточно заметить, что в третьем случае высота вершины $$s(w)$$ может быть меньше высоты вершины $$s(v)$$ разве что на единицу, поскольку суффиксные ссылки из всех вершин на пути к $$v$$ (не считая корня, где нет суффиксной ссылки) ведут в вершины на пути к $$w$$. Поскольку высота любого листа ограничена числом $$m$$, заключаем, что общая длительность всех прослеживаний есть $$O(m)$$.

    Добавления. Рассуждаем аналогично, но следим не за высотой последнего листа, а за длиной его пометки. При добавлении слова $$\textit{tail}$$ (или $$\textit{tail}\,'$$ ) число действий пропорционально числу просмотренных букв, но каждая просмотренная буква (кроме, быть может, одной) уменьшает длину пометки хотя бы на единицу: в пометке остаются лишь непросмотренные буквы (не считая первой). Поэтому на все добавления уходит в общей сложности $$O(m)$$ действий.

    Тем самым мы доказали, что описанный алгоритм строит сжатое суффиксное дерево слова $$Y$$ длины $$m$$ за $$O(m)$$ действий. После этого для любого слова $$X$$ длины $$n$$ можно за $$O(n)$$ действий выяснить, является ли $$X$$ подсловом слова $$Y$$.

    10.8.8. Как модифицировать алгоритм построения суффиксного дерева, чтобы не только узнавать, является ли данное слово $$X$$ подсловом слова $$Y$$, но и (если является) указывать место, где оно встречается (одно из таких мест, если их несколько)? Время построения должно оставаться $$O(|Y|)$$, время поиска подслова - $$O(|X|)$$.

    Решение. Каждая вершина сжатого суффиксного дерева соответствует некоторому подслову слова $$Y$$ ; в момент, когда эта вершина была добавлена в дерево, известно, в каком месте есть такое подслово, и можно записать в вершине, где соответствующее подслово кончается.

    10.8.9. Как модифицировать этот алгоритм, чтобы для каждого подслова можно было бы указывать его первое (самое левое) вхождение?

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

    10.8.10. Как модифицировать этот алгоритм, чтобы для каждого подслова можно было бы указывать его последнее (самое правое) вхождение?

    Указание. Если при каждом проходе корректировать информацию вдоль пути, это будет долго; быстрее построить дерево, затем вновь его обойти и для каждой вершины вычислить момент последнего появления соответствующего подслова.

    10.8.11. Как использовать сжатое суффиксное дерево, чтобы для данного слова $$Y$$ за время $$O(|Y|)$$ найти самое длинное подслово, которое входит в $$Y$$ более одного раза?

    Решение. Такое подслово является внутренней вершиной суффиксного дерева, поэтому достаточно из всех его вершин взять ту, которой соответствует самое длинное слово. Для этого достаточно обойти все его вершины (длину можно вычислять по мере обхода, складывая длины пометок на ребрах).

    На практике можно использовать также и другой способ нахождения самого длинного подслова, входящего дважды, - так называемый массив суффиксов. А именно, будем рассматривать число $$i$$ как "код" конца слова, начинающего с $$i$$ -ой буквы. Введем на кодах порядок, соответствующий лексикографическому (словарному) порядку на словах: код $$i$$ предшествует коду $$j$$, если конец слова, начинающийся с $$i$$, в лексикографическом порядке идет раньше конца слова, начинающегося с $$j$$. После этого отсортируем коды в соответствии с этим порядком, получив некоторую перестановку массива $$1,2,3,\ldots,m$$ (где $$m$$ - длина исходного слова $$Y$$ ). Если какое-то слово $$X$$ входит в слово $$Y$$ дважды, то оно является началом двух концов слова $$Y$$. При этом эти концы можно выбрать соседними в лексикографическом порядке, поскольку все промежуточные слова тоже начинаются на $$X$$. Значит, достаточно для всех соседних концов посмотреть, сколько начальных букв у них совпадает, и взять максимум.

    Этот способ требует меньше памяти (нам нужен лишь один массив из целых чисел той же длины, что исходное слово), но может требовать большого времени: во-первых, сортировка сама по себе требует порядка $$m log m$$ сравнений, во-вторых, каждое сравнение может длиться долго, если совпадающий кусок большой. Но в случаях, когда длинных совпадающих кусков мало, такой алгоритм работает неплохо.

    10.8.12. Применить один из таких алгоритмов к любимой книге и объяснить результат.

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

    Страницы:

    10.1. Простейший пример

    10.1.1. Имеется последовательность символов $${x[1]}\ldots{x[n]}$$. Определить, имеются ли в ней идущие друг за другом символы abcd. (Другими словами, требуется выяснить, есть ли в слове $${x[1]}\ldots{x[n]}$$ подслово abcd.)

    Решение. Имеется примерно n (если быть точным, n-3 ) позиций, на которых может находиться искомое подслово в исходном слове. Для каждой из позиций можно проверить, действительно ли там оно находится, сравнив четыре символа. Однако есть более эффективный способ. Читая слово $${x[1]}\ldots{x[n]}$$ слева направо, мы ожидаем появления буквы a. Как только она появилась, мы ищем за ней букву b, затем c, и, наконец, d. Если наши ожидания оправдываются, то слово abcd обнаружено. Если же какая-то из нужных букв не появляется, мы оказываемся у разбитого корыта и начинаем все сначала.

    Этот простой алгоритм можно описать в разных терминах. Используя терминологию так называемых конечных автоматов, можно сказать, что при чтении слова x слева направо мы в каждый момент находимся в одном из следующих состояний: "начальное" (0), "сразу после a " (1), "сразу после ab " (2), "сразу после abc " (3) и "сразу после abcd " (4). Читая очередную букву, мы переходим в следующее состояние по правилу, указанному в таблице.

    Правила перехода для конечного автомата
    Текущее состояние Очередная буква Новое состояние
    0 a 1
    0 кроме а 0
    1 b 2
    1 a 1
    1 кроме a, b 0
    2 c 3
    2 a 1
    2 кроме a, c 0
    3 d 4
    3 a 1
    3 кроме a, d 0

    Как только мы попадем в состояние 4, работа заканчивается.

    Наглядно выполнение алгоритма можно представить себе так: фишка двигается из кружка в кружок по стрелкам; стрелка выбирается так, чтобы надпись на ней соответствовала очередной букве входного слова. Чтобы этот процесс был успешным, нужно, чтобы для каждой буквы была ровно одна подходящая стрелка из любого кружка.

    Соответствующая программа очевидна (мы указываем новое состояние, даже если оно совпадает со старым; эти строки можно опустить):

    i:=1; state:=0;
{i - первая непрочитанная буква, state - состояние}
while (i <> n+1) and (state <> 4) do begin
| if state = 0 then begin
| | if x[i] = a then begin
| | | state:= 1;
| | end else begin
| | | state:= 0;
| | end;
| end else if state = 1 then begin
| | if x[i] = b then begin
| | | state:= 2;
| | end else if x[i] = a then begin
| | | state:= 1;
| | end else begin
| | | state:= 0;
| | end;
| end else if state = 2 then begin
| | if x[i] = c then begin
| | | state:= 3;
| | end else if x[i] = a then begin
| | | state:= 1;
| | end else begin
| | | state:= 0;
| | end;
| end else if state = 3 then begin
| | if x[i] = d then begin
| | | state:= 4;
| | end else if x[i] = a then begin
| | | state:= 1;
| | end else begin
| | | state:= 0;
| | end;
| end;
end;
answer := (state = 4);

    Иными словами, мы в каждый момент храним информацию о том, какое максимальное начало нашего образца abcd является концом прочитанной части. (Его длина и есть то " состояние", о котором шла речь.)

    Терминология, нами используемая, такова. Слово - это любая последовательность символов из некоторого фиксированного конечного множества. Это множество называется алфавитом, его элементы - буквами. Если отбросить несколько букв с конца слова, останется другое слово, называемое началом первого. Любое слово также считается своим началом. Конец слова - то, что останется, если отбросить несколько первых букв. Любое слово считается своим концом. Подслово - то, что останется, если отбросить буквы и с начала, и с конца. (Другими словами, подслова - это концы начал, или, что то же, начала концов.)

    В терминах индуктивных функций (см. раздел 1.3.) ситуацию можно описать так: рассмотрим функцию на словах, которая принимает два значения "истина" и "ложь" и истинна на словах, имеющих abcd своим подсловом. Эта функция не является индуктивной, но имеет индуктивное расширение$${x} \mapsto \text{длина максимального начала слова {abcd}, являющегося концом {x}}.$$

    10.2. Повторения в образце - источник проблем

    10.2.1. Можно ли в предыдущих рассуждениях заменить слово abcd на произвольное слово?

    Решение. Нет, и проблемы связаны с тем, что в образце могут быть повторяющиеся буквы. Пусть, например, мы ищем вхождения слова ababc. Вот появилась буква a, за ней идет b, за ней идет a, затем снова b. В этот момент мы с нетерпением ждем буквы c. Однако - к нашему разочарованию - вместо нее появляется другая буква, и наш образец ababc не обнаружен. Однако нас может ожидать утешительный приз: если вместо c появилась буква a, то не все потеряно: за ней могут последовать буквы b и c, и образец-таки будет найден.

    Вот картинка, поясняющая сказанное:$${\setlength{\tabcolsep}{.8\tabcolsep} \begin{tabular}{llllllllllllll} x y z a b a b a b c \ldots\leftarrowвходное слово\\ a b a b c \leftarrowмы ждали образца здесь\\ a b a b c \leftarrowа он оказался здесь\\ \end{tabular}$$ Таким образом, к моменту$${\setlength{\tabcolsep}{.8\tabcolsep} \begin{tabular}{lllllll|lllllll} x y z a b a b \leftarrowвходное слово\\ a b a b c \leftarrowмы ждали образца здесь\\ a b a b c \leftarrowа он оказался здесь\\ \end{tabular}$$ есть два возможных положения образца, каждое из которых подлежит проверке. Тем не менее по-прежнему возможен конечный автомат, читающий входное слово буква за буквой и переходящий из состояния в состояние в зависимости от прочитанных букв.

    10.2.2. Указать состояния соответствующего автомата и таблицу перехода (новое состояние в зависимости от старого и читаемой буквы).

    Решение. По-прежнему состояния будут соответствовать наибольшему началу образца, являющемуся концом прочитанной части слова. Их будет шесть: 0, 1 (a), 2 (ab), 3 (aba), 4 (abab), 5 (ababc). Таблица перехода такая.

    Правила перехода для конечного автомата
    Текущее состояние Очередная буква Новое состояние
    0 a 1 (a)
    0 кроме а 0
    1 (a) b 2 (ab)
    1 (a) a 1 (a)
    1 (a) кроме a, b 0
    2 (ab) a 3 (aba)
    2 (ab) кроме a 0
    3 (aba) b 4 (abab)
    3 (aba) a 1 (a)
    3 (aba) кроме a, b 0
    4 (abab) c 5 (ababc)
    4 (abab) a 3 (aba)
    4 (abab) кроме a, c 0

    Для проверки посмотрим, к примеру, на вторую снизу строку. Если прочитанная часть кончалась на abab, а затем появилась буква a, то теперь прочитанная часть кончается на ababa. Наибольшее начало образца ( ababc ), являющееся ее концом - это aba.

    Философский вопрос: мы говорили, что трудность состоит в том, что есть несколько возможных положений образца, каждое из которых может оказаться истинным. Им соответствуют несколько начал образца, являющихся концами входного слова. Но конечный автомат помнит лишь самое длинное из них. Как же остальные?

    Философский ответ. Дело в том, что самое длинное из них определяет все остальные - это его концы, одновременно являющиеся его началами.

    Не составляет труда для любого конкретного образца написать программу, осуществляющую поиск этого образца описанным способом. Однако хотелось бы написать программу, которая ищет произвольный образец в произвольном слове. Это можно делать в два этапа: сначала по образцу строится таблица переходов конечного автомата, а затем читается входное слово и состояние преобразуется в соответствии с этой таблицей. Подобный метод часто используется для более сложных задач поиска (см. далее), но для поиска подслова существует более простой и эффективный алгоритм, называемый алгоритмом Кнута-Морриса-Пратта. (Ранее сходные идеи были предложены Ю.В. Матиясевичем.) Но прежде нам понадобятся некоторые вспомогательные утверждения.

    10.3. Вспомогательные утверждения

    Для произвольного слова $$X$$ рассмотрим все его начала, одновременно являющиеся его концами, и выберем из них самое длинное. (Не считая, конечно, самого слова $$X$$.) Будем обозначать его $$l(X)$$.

    Примеры: $$l({aba})={a}$$, $$l({abab})={ab}$$, $$l({ababa})={aba}$$, $$l({abc}) = \text{пустое слово}$$

    10.3.1. Доказать, что все слова $$l(X)$$, $$l(l(X))$$, $$l(l(l(X)))$$ и т.д. являются началами слова $$X$$.

    Решение. Каждое из них (согласно определению) является началом предыдущего.

    По той же причине все они являются концами слова $$X$$.

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

    Решение. Каждое слово короче предыдущего.

    10.3.3. Доказать, что любое слово, одновременно являющееся началом и концом слова $$X$$ (кроме самого $$X$$ ) входит в последовательность $$l(X), l(l(X)),\ldots$$

    Решение. Пусть слово $$Y$$ есть одновременно начало и конец $$X$$. Слово $$l(X)$$ - самое длинное из таких слов, так что $$Y$$ не длиннее $$l(X)$$. Оба эти слова являются началами $$X$$, поэтому более короткое из них является началом более длинного: $$Y$$ есть начало $$l(X)$$. Аналогично, $$Y$$ есть конец $$l(X)$$. Рассуждая по индукции, можно предполагать, что утверждение задачи верно для всех слов короче $$X$$, в частности, для слова $$l(X)$$. Так что слово $$Y$$, являющееся концом и началом $$l(X)$$, либо равно $$l(X)$$, либо входит в последовательность $$l(l(X)), l(l(l(X))),\dots$$, что и требовалось доказать.

    10.4. Алгоритм Кнута-Морриса-Пратта

    Алгоритм Кнута-Морриса-Пратта (КМП) получает на вход слово$${X}= {x[1]x[2]}\ldots{x[n]}$$ и просматривает его слева направо буква за буквой, заполняя при этом массив натуральных чисел $${l[1]}\ldots{l[n]}$$, где$${l[i]} = \text{длина слова }l({x[1]}\ldots{x[i]})$$ (функция $$l$$ определена в предыдущем пункте). Словами: l[i] есть длина наибольшего начала слова $${x[1]}\ldots{x[i]}$$, одновременно являющегося его концом.

    10.4.1. Какое отношение все это имеет к поиску подслова? Другими словами, как использовать алгоритм КМП для определения того, является ли слово A подсловом слова B?

    Решение. Применим алгоритм КМП к слову A\#B, где \# - специальная буква, не встречающаяся ни в A, ни в B. Слово A является подсловом слова B тогда и только тогда, когда среди чисел в массиве l будет число, равное длине слова A.

    10.4.2. Описать алгоритм заполнения таблицы $${l[1]}\ldots{l[n]}$$.

    Решение. Предположим, что первые i значений $${l[1]}\ldots{l[i]}$$ уже найдены. Мы читаем очередную букву слова (т.е. x[i+1] ) и должны вычислить l[i+1].

    Другими словами, нас интересуют начала $$Z$$ слова $${x[1]}\ldots{x[i+1]}$$, одновременно являющиеся его концами - из них нам надо выбрать самое длинное. Откуда берутся эти начала? Каждое из них (не считая пустого) получается из некоторого слова $$Z'$$ приписыванием буквы x[i+1]. Слово $$Z'$$ является началом и концом слова $${x[1]}\ldots{x[i]}$$. Однако не любое слово, являющееся началом и концом слова $${x[1]}\ldots{x[i]}$$, годится - надо, чтобы за ним следовала буква x[i+1].

    Получаем такой рецепт отыскания слова $$Z$$. Рассмотрим все начала слова $${x[1]}\ldots{x[i]}$$, являющиеся одновременно его концами. Из них выберем подходящие - те, за которыми идет буква $${x[i+1]}$$. Из подходящих выберем самое длинное. Приписав в его конец x[i+1], получим искомое слово $$Z$$.

    Теперь пора воспользоваться сделанными нами приготовлениями и вспомнить, что все слова, являющиеся одновременно началами и концами данного слова, можно получить повторными применениями к нему функции $$l$$ из предыдущего раздела. Вот что получается:

    i:=1; l[1]:= 0;
{таблица l[1]..l[i] заполнена правильно}
while i <> n do begin
| len := l[i]
| {len - длина начала слова x[1]..x[i], которое является
|    его концом; все более длинные начала оказались
|    неподходящими}
| while (x[len+1] <> x[i+1]) and (len > 0) do begin
| | {начало не подходит, применяем к нему функцию l}
| | len := l[len];
| end;
| {нашли подходящее или убедились в отсутствии}
| if x[len+1] = x[i+1] do begin
| | {x[1]..x[len] - самое длинное подходящее начало}
| | l[i+1] := len+1;
| end else begin
| | {подходящих нет}
| | l[i+1] := 0;
| end;
| i := i+1;
end;

    10.4.3. Доказать, что число действий в приведенном только что алгоритме не превосходит $$C{n}$$ для некоторой константы $$C$$.

    Решение. Это не вполне очевидно: обработка каждой очередной буквы может потребовать многих итераций во внутреннем цикле. Однако каждая такая итерация уменьшает len по крайней мере на 1, и в этом случае l[i+1] окажется заметно меньше l[i]. С другой стороны, при увеличении i на единицу величина l[i] может возрасти не более чем на 1, так что часто и сильно убывать она не может - иначе убывание не будет скомпенсировано возрастанием.

    Более точно, можно записать неравенство$${l[i+1]} \le {l[i]} - \hbox{(число итераций на {i}-м шаге)} + {1}$$ или$$\hbox{(число итераций на {i}-м шаге)}\le{l[i]}-{l[i+1]} + {1}.$$ Остается сложить эти неравенства по всем i и получить оценку сверху для общего числа итераций.

    10.4.4. Будем использовать этот алгоритм, чтобы выяснить, является ли слово X длины n подсловом слова Y длины m. (Как это делать с помощью специального разделителя \#, описано выше.) При этом число действий будет не более $$C({n}+{m})$$, и используемая память тоже. Придумать, как обойтись памятью не более $$C{n}$$ (что может быть существенно меньше, если искомый образец короткий, а слово, в котором его ищут - длинное).

    Решение. Применяем алгоритм КМП к слову $${A#B}$$. При этом вычисление значений $${l[1]},\ldots,{l[n]}$$ проводим для слова X длины n и запоминаем эти значения. Дальше мы помним только значение l[i] для текущего i - кроме него и кроме таблицы $${l[1]}\ldots{l[n]}$$, нам для вычислений ничего не нужно.

    На практике слова X и Y могут не находиться подряд, поэтому просмотр слова X и затем слова Y удобно оформить в виде разных циклов. Это избавляет также от хлопот с разделителем.

    10.4.5. Написать соответствующий алгоритм (проверяющий, является ли слово $${X}={x[1]}\ldots{x[n]}$$ подсловом слова $${Y}={y[1]}\ldots{y[m]}$$ ).

    Решение. Сначала вычисляем таблицу $${l[1]}\ldots{l[n]}$$ как раньше. Затем пишем такую программу:

    j:=0; len:=0;
{len - длина максимального начала слова X, одновременно
       являющегося концом слова y[1]..y[j]}
while (len <> n) and (j <> m) do begin
| while (x[len+1] <> y[j+1]) and (len > 0) do begin
| | {начало не подходит, применяем к нему функцию l}
| | len := l[len];
| end;
| {нашли подходящее или убедились в отсутствии}
| if x[len+1] = y[j+1] do begin
| | {x[1]..x[len] - самое длинное подходящее начало}
| | len := len+1;
| end else begin
| | {подходящих нет}
| | len := 0;
| end;
| j := j+1;
end;
{если len=n, слово X встретилось; иначе мы дошли до конца
   слова Y, так и не встретив X}

    10.5. Алгоритм Бойера- Мура

    Этот алгоритм делает то, что на первый взгляд кажется невозможным: в типичной ситуации он читает лишь небольшую часть всех букв слова, в котором ищется заданный образец. Как так может быть? Идея проста. Пусть, например, мы ищем образец abcd. Посмотрим на четвертую букву слова: если, к примеру, это буква e, то нет никакой необходимости читать первые три буквы. (В самом деле, в образце буквы e нет, поэтому он может начаться не раньше пятой буквы.)

    Мы приведем самый простой вариант этого алгоритма, который не гарантирует быстрой работы во всех случаях. Пусть $${x[1]}\ldots{x[n]}$$ - образец, который надо искать. Для каждого символа s найдем самое правое его вхождение в слово X, то есть наибольшее k, при котором $${x[k]}={s}$$. Эти сведения будем хранить в массиве pos[s] ; если символ s вовсе не встречается, то нам будет удобно положить $${pos[s]}={0}$$ (мы увидим дальше, почему).

    10.5.1. Как заполнить массив pos?

    Решение.

    положить все pos[s] равными 0
for i:=1 to n do begin
  pos[x[i]]:=i;
end;

    В процессе поиска мы будем хранить в переменной last номер буквы в слове, против которой стоит последняя буква образца. Вначале $${last} = {n}$$ (длина образца), затем last постепенно увеличивается.

    last:=n;
{все предыдущие положения образца уже проверены}
while last <= m do begin {слово не кончилось}
| if x[n] <> y[last] then begin {последние буквы разные}
| | last := last + (n - pos[y[last]]);
| | {n - pos[y[last]]  - это минимальный сдвиг образца,
| |    при котором напротив y[last] встанет такая же
| |    буква в образце. Если такой буквы нет вообще,
| |    то сдвигаем на всю длину образца}
| end else begin
| | если нынешнее положение подходит, т.е. если
| | x[1]..x[n] = y[last-n+1]..y[last],
| | то сообщить о совпадении;
| | last := last+1;
| end;
end;

    Знатоки рекомендуют проверку совпадения проводить справа налево, т.е. начиная с последней буквы образца (в которой совпадение заведомо есть). Можно также немного сэкономить, произведя вычитание заранее и храня не pos[s], а n-pos[s], т.е. число букв в образце справа от последнего вхождения буквы s.

    Возможны разные модификации этого алгоритма. Например, можно строку last:=last+1 заменить на last:=last+(n-u), где u - координата второго справа вхождения буквы x[n] в образец.

    10.5.2. Как проще всего учесть это в программе?

    Решение. При построении таблицы pos написать

    for i:=1 to n-1 do...

    (далее как раньше), а в основной программе вместо last:=last+1 написать

    last:= last+n-pos[y[last]];

    Приведенный нами упрощенный вариант алгоритма Бойера-Мура в некоторых случаях требует существенно больше n действий (число действий порядка mn ), проигрывая алгоритму Кнута-Морриса-Пратта.

    10.5.3. Привести пример ситуации, в которой образец не входит в слово, но алгоритму требуется порядка mn действий, чтобы это установить.

    Решение. Пусть образец имеет вид $${baaa}\ldots{aa}$$, а само слово состоит только из букв a. Тогда на каждом шаге несоответствие выясняется лишь в последний момент.

    Настоящий (не упрощенный) алгоритм Бойера-Мура гарантирует, что число действий не превосходит $$C({m}+{n})$$ в худшем случае. Он использует идеи, близкие к идеям алгоритма Кнута-Морриса-Пратта. Представим себе, что мы сравнивали образец со входным словом, идя справа налево. При этом некоторый кусок $$Z$$ (являющийся концом образца) совпал, а затем обнаружилось различие: перед $$Z$$ в образце стоит не то, что во входном слове. Что можно сказать в этот момент о входном слове? В нем обнаружен фрагмент, равный $$Z$$, а перед ним стоит не та буква, что в образце. Эта информация может позволить сдвинуть образец на несколько позиций вправо без риска пропустить его вхождение. Эти сдвиги следует вычислить заранее для каждого конца $$Z$$ нашего образца. Как говорят знатоки, все это (вычисление таблицы сдвигов и ее использование) можно уложить в $$C( m+ n)$$ действий.

    10.6. Алгоритм Рабина

    Этот алгоритм основан на простой идее. Представим себе, что в слове длины $$m$$ мы ищем образец длины $$n$$. Вырежем окошечко размера $$n$$ и будем двигать его по входному слову. Нас интересует, не совпадает ли слово в окошечке с заданным образцом. Сравнивать по буквам долго. Вместо этого фиксируем некоторую функцию, определенную на словах длины $$n$$. Если значения этой функции на слове в окошечке и на образце различны, то совпадения нет. Только если значения одинаковы, нужно проверять совпадение по буквам.

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

    10.6.1. Привести пример удобной для вычисления функции.

    Решение. Заменим все буквы в слове и образце их номерами, представляющими собой целые числа. Тогда удобной функцией является сумма цифр. (При сдвиге окошечка нужно добавить новое число и вычесть пропавшее.)

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

    10.6.2. Привести пример семейства удобных функций.

    Решение. Выберем некоторое число $$p$$ (желательно простое, смотри далее) и некоторый вычет $$x$$ по модулю $$p$$. Каждое слово длины $$n$$ будем рассматривать как последовательность целых чисел (заменив буквы кодами). Эти числа будем рассматривать как коэффициенты многочлена степени $$n-1$$ и вычислим значение этого многочлена по модулю $$p$$ в точке $$x$$. Это и будет одна из функций семейства (для каждой пары $$p$$ и $$x$$ получается, таким образом, своя функция). Сдвиг окошка на $$1$$ соответствует вычитанию старшего члена ( $$x^{n-1}$$ следует вычислить заранее), умножению на $$x$$ и добавлению свободного члена.

    Следующее соображение говорит в пользу того, что совпадения не слишком вероятны. Пусть число $$p$$ фиксировано и к тому же простое, а $$X$$ и $$Y$$ - два различных слова длины $$n$$. Тогда им соответствуют различные многочлены (мы предполагаем, что коды всех букв различны - это возможно, если $$p$$ больше числа букв алфавита). Совпадение значений функции означает, что в точке $$x$$ эти два различных многочлена совпадают, то есть их разность обращается в $$0$$. Разность есть многочлен степени $$n-1$$ и имеет не более $$n-1$$ корней. Таким образом, если $$n$$ много меньше $$p$$, то случайному $$x$$ мало шансов попасть в неудачную точку.

    10.7. Более сложные образцы и автоматы

    Мы можем искать не конкретное слово, а подслова заданного вида. Например, можно искать слова вида a?b, где вместо ? может стоять любая буква (иными словами, нас интересует буква b на расстоянии $$2$$ после буквы a ).

    10.7.1. Указать конечный автомат, проверяющий, есть ли во входном слове фрагмент вида a?b.

    Решение. Читая слово, следует помнить, есть ли буква a на последнем месте и на предпоследнем - пока не встретим искомый фрагмент. Автомат имеет состояния 00, 01, 10, 11, их смысл таков:$$\begin{tabular}{rl} 00 на предпоследнем и последнем местах нет {a}\\ 01 на предпоследнем нет, на последнем есть\\ 10 не предпоследнем есть, на последнем нет\\ 11 есть и там, и там \end{tabular}$$ Таблица переходов автомата:$$\raisebox{\depth}{\begin{tabular}{|c|c|c|} \hline Текущее Очередная Новое \\ состояние буква состояние \\ \hline 00 a 01 \\ 00 не a 00 \\ 01 a 11 \\ 01 не a 10 \\ 10 a 01 \\ 10 b найдено \\ 10 не {a} и не {b} 00 \\ 11 a11 \\ 11 b найдено \\ 11 не a и не b 10 \\ \hline \end{tabular}}$$

    Другой стандартный знак в образце - это звездочка ( * ), на место которой может быть подставлено любое слово. Например, образец ab*cd означает, что мы ищем подслово ab, за которым следует что угодно, а затем (на любом расстоянии) идет cd.

    10.7.2. Указать конечный автомат, проверяющий, есть ли во входном слове образец ab*cd (в описанном только что смысле).

    Решение.$$\raisebox{\depth}{\begin{tabular}{|c|c|c|} \hline Текущее Очередная Новое \\ состояние буква состояние \\ \hline начальное {a} {a} \\ начальное не {a} начальное \\ a {b} {ab} \\ a {a} {a} \\ a не {a} и не {b} начальное \\ {ab} {c} {abc} \\ {ab} не {c} {ab} \\ {abc} {d} найдено \\ {abc} {c} {abc} \\ {abc} не {c} и не {d} {ab} \\ \hline \end{tabular}}$$

    Еще один вид поиска - это поиск любого из слов некоторого списка.

    10.7.3. Дан список слов $$X_1,\ldots,X_k$$ и слово $$Y$$. Определить, входит ли хотя бы одно из слов $$X_i$$ в слово $$Y$$ (как подслово). Количество действий не должно превосходить константы, умноженной на суммарную длину всех слов (из списка и того, в котором происходит поиск).

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

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

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

    Склеим все образцы в дерево, объединив их совпадающие начальные участки. Например, набору образцов

    Формально говоря, вершинами дерева являются все начала всех образцов, а сыновья вершины получаются приписыванием буквы.

    Читая входное слово, мы двигаемся по этому дереву: текущая вершина - это наибольшая (самая правая) из вершин, являющихся концом прочитанной части ( $${}={}$$ наибольший конец прочитанной части, являющийся началом одного из образцов).

    Определим функцию $$l$$, аргументами и значениями которой являются вершины дерева. Именно, $$l(P) = {}$$ наибольшая вершина дерева, являющаяся концом $$P$$. (Напомним, вершины дерева - это слова.) Нам понадобится такое утверждение:

    10.7.4. Пусть $$P$$ - вершина дерева. Доказать, что множество всех вершин, являющихся концами $$P$$, равно $$\{l(P), l(l(P)),\ldots\}$$

    Решение. См. доказательство аналогичного утверждения для алгоритма Кнута-Морриса-Пратта.

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

    Остается понять, как для каждой вершины дерева вычислить указатель на значение функции $$l$$ в этой вершине. Это делается как раньше, при этом значения $$l$$ для более коротких слов используются при вычислении очередного значения функции $$l$$. Это означает, что вершины дерева следует просматривать в порядке возрастания их длины. Нетрудно понять, что все это можно уложить в требуемое число действий (хотя константа зависит от числа букв в алфавите). Относящиеся к этому подробности см. в лекции 9.

    Можно поинтересоваться, какие свойства слов распознаются с помощью конечных автоматов. Оказывается, что существует просто описываемый класс образцов, задающий все такие свойства - класс регулярных выражений.

    Пусть фиксирован конечный алфавит $$\Gamma$$, не содержащий символов $$\Lambda$$, $$\varepsilon$$, (, ), * и | (они будут использоваться для построения регулярных выражений и не должны перемешиваться с буквами). Регулярные выражения строятся по таким правилам:

  • буква алфавита Г - регулярное выражение;
  • символы $$\Lambda,$$ $$\varepsilon$$ - регулярные выражения
  • если A,B,C,...,E - регулярные выражения, то (ABC...E) - регулярное выражение;
  • если A,B,C,...,E - регулярные выражения, то (A|B|C|...|E) - регулярное выражение;
  • если A - регулярное выражение, то A* - регулярное выражение.
    •

    Каждое регулярное выражение задает множество слов в алфавите $$\Gamma$$ по таким правилам:

  • букве соответствует одноэлементное множество, состоящее из однобуквенного слова, состоящего из этой буквы;
  • символу $$\varepsilon$$ соответствует пустое множество, а символу $$\Lambda$$ - одноэлементное множество, единственным элементом которого является пустое слово;
  • регулярному выражению (ABC...E) соответствует множество всех слов, которые можно получить, если к слову из A приписать слово из B, затем из C,..., затем из E
  • регулярному выражению (A|B|C|...|E) соответствует объединение множеств, соответствующих выражениям A,B,C,...,E ;
  • регулярному выражению A{*} соответствует итерация множества, соответствующего выражению A, то есть множество всех слов, которые можно так разрезать на куски, что каждый кусок принадлежит множеству, соответствующему выражению A. (В частности, пустое слово всегда содержится в A*.)
    •

    Множества, соответствующие регулярным выражениям, Называются регулярными. Вот несколько примеров:$$\begin{tabular}{ll} Выражение Множество \\[1ex] % {(a|b)*} все слова из букв {a} и {b}\\ {(aa)*} слова из четного числа букв {a}\\ {(}\Lambda{|a|b|aa|ab|ba|bb)} % ??? пробел после запятой? все слова длины не более 2 из букв {a}, {b} \end{tabular}$$

    10.7.5. Написать регулярное выражение, которому соответствует множество всех слов из букв a и b, в которых число букв a четно.

    Решение. Выражение b* задает все слова без буквы a, а выражение $${(b*}\,{a}\,{b*}\,{a}\,{b*)}$$ - все слова ровно с двумя буквами a. Остается объединить эти множества, а потом применить итерацию:$${(}\,{(b*}\,{a}\,{b*}\,{a}\,{b*)}\,|\,{b*}\,{)*}$$ Другой вариант ответа:$${(b*}\,{a}\,{b*}\,{a)} {*}\,{b*}$$

    10.7.6. Написать регулярное выражение, которое задает множество всех слов из букв $${a},{b},{c}$$, в которых слово bac является подсловом.

    Решение. $${((a|b|c)*}\,{bac}\,{(a|b|c)*)}$$

    10.7.7. Написать регулярное выражение, которое задает множество всех слов из букв $${a},{b},{c}$$, в которых слово bac не является подсловом.

    Указание. Эта задача сложнее предыдущей; видимо, самый простой способ ее решить - перейти к конечным автоматам и вернуться обратно (см. ниже задачу 10.7.14.).

    Теперь задачу о поиске образца в слове можно переформулировать так: проверить, принадлежит ли слово множеству, соответствующему данному регулярному выражению.

    10.7.8. Какие выражения соответствуют образцам a?b и ab*cd, рассмотренным ранее? (В образце символ * используется не в том смысле, что в регулярных выражениях!) Предполагается, что алфавит содержит буквы $${a},{b},{c},{d},{e}$$.

    Решение.

    ((a|b|c|d|e)*a(a|b|c|d|e)b(a|b|c|d|e)*)
((a|b|c|d|e)*ab(a|b|c|d|e)*cd(a|b|c|d|e)*)

    10.7.9. Доказать, что для всякого регулярного выражения можно построить конечный автомат, который распознает соответствующее этому выражению множество слов.

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

    Будем двигаться различными способами из Н в К, читая буквы по дороге (на тех стрелках, где они есть). Каждому пути из Н в К, таким образом, соответствует некоторое слово. А источнику в целом соответствует множество слов - тех слов, которые можно прочесть на путях из Н в К.

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

    Мы будем строить конечный автомат по регулярному выражению в два приема. Сначала мы построим источник, которому соответствует то же самое множество слов. Затем для произвольного источника построим автомат, который проверяет, принадлежит ли слово соответствующему множеству.

    10.7.10. По регулярному выражению построить источник, задающий то же множество.

    Решение. Индукция по построению регулярного выражения. Буквам соответствуют графы из одной стрелки. Объединение реализуется так:

    Нарисована картинка для объединения трех множеств, прямоугольники - это источники, им соответствующие; указаны начальные и конечные вершины. На новых стрелках (их $$6$$ ) букв не написано.

    Конкатенации соответствует картинка

    Наконец, итерации соответствует картинка

    10.7.11. Дан источник. Построить конечный автомат, проверяющий, принадлежит ли входное слово соответствующему множеству (то есть можно ли прочесть это слово, идя из Н в К).

    Решение. Состояниями автомата будут множества вершин источника. Именно, прочтя некоторое начало $$X$$ входного слова, мы будем помнить множество всех вершин источника, в которые можно пройти из начальной, прочитав на пути слово $$X$$.

    Тем самым задача решена.

    Оказывается, что регулярные выражения, автоматы и источники распознают одни и те же множества. Чтобы убедиться в этом, нам осталось решить такую задачу:

    10.7.12. Дан источник. Построить регулярное выражение, задающее то же множество, что и этот источник.

    Решение. Пусть источник имеет вершины $$1,\ldots,k$$. Будем считать, что $$1$$ - это начало, а $$k$$ - конец. Через $$D_{i,j,s}$$ обозначим множество всех слов, которые можно прочесть на пути из $$i$$ в $$j$$, если в качестве промежуточных пунктов разрешается использовать только вершины $$1,\ldots,s$$. Согласно определению, источнику соответствует множество $$D_{1,k,k}$$.

    Индукцией по $$s$$ будем доказывать регулярность всех множеств $$D_{i,j,s}$$ при всех $$i$$ и $$j$$. При $$s=0$$ это очевидно (промежуточные вершины запрещены, поэтому каждое из множеств состоит только из букв).

    Из чего состоит множество $$D_{i,j,s+1}$$? Отметим на пути моменты, в которых он заходит в $$(s+1)$$ -ую вершину. При этом путь разбивается на части, каждая из которых уже не заходит в нее. Поэтому легко сообразить, что$$D_{i,j,s+1} = D_{i,j,s}\,|\, (D_{i,s+1,s}\;\;\; D_{s+1,s+1,s}{*}\;\;\; D_{s+1,j,s})$$ (вольность записи: мы используем для операций над множествами обозначения как для регулярных выражений). Остается воспользоваться предположением индукции.

    10.7.13. Где еще используется то же самое рассуждение?

    Ответ. В алгоритме Флойда вычисления цены кратчайшего пути, см. лекцию 9 (Разные алгоритмы на графах).

    10.7.14. Доказать, что класс множеств, задаваемых регулярными выражениями, не изменился бы, если бы мы разрешили использовать не только объединение, но и отрицание (а следовательно, и пересечение - оно выражается через объединение и отрицание).

    Решение. Для автоматов переход к отрицанию очевиден.

    Замечание. На практике важную роль играет число состояний автомата. Оказывается, что тут все не так просто, и переход от источника к автомату требует экспоненциального роста числа состояний. Подробное рассмотрение связанных с этим теоретических и практических вопросов - дело особое (см. книгу Ахо, Ульмана и Сети о компиляторах).

    10.8. Суффиксные деревья

    До сих про наши программы сначала получали образец, который надо искать, а потом текст, в котором надо искать. В следующих задачах все наоборот.

    10.8.1. Программа получает на вход слово $$Y$$ длины $$m$$ и может его обрабатывать (пока без ограничений на время и память). Затем она получает слово $$X$$ длины $$n$$ и должна сообщить, является ли оно подсловом слова $$Y$$. При этом число операций при обработке слова $$X$$ должно быть порядка $$n$$ (не превосходить $$cn$$, где константа $$c$$ может зависеть от размера алфавита). Как написать такую программу?

    Решение. Пока не накладывается никаких ограничений на время и память при обработке $$Y$$, это не представляет труда. Именно, надо склеить все подслова слова $$Y$$ в дерево, объединив слова с общими началами (как мы это делали, распознавая вхождения нескольких образцов). Например, для $$Y=ababc$$ получится такое дерево подслов (на ребре написана буква, которая добавляется при движении по этому ребру; вершины находятся во взаимно однозначном соответствии с подсловами слова $$Y$$ ):

    Пусть такое дерево построено. После этого, читая слово $$X$$ слева направо, мы прослеживаем $$X$$ в дереве, начав с корня; слово $$X$$ будет подсловом слова $$Y$$, если при этом мы не выйдем за пределы дерева.

    Заметим, что аналогичная конструкция годится для любого множества слов $$U$$, а не только для множества всех подслов данного слова: после того как соответствующее дерево построено, мы можем про любое слово $$X$$ определить его принадлежность к $$U$$ за время, пропорциональное длине $$X$$. (Надо только дополнительно хранить в вершине дерева информацию, принадлежит ли соответствующее ей слово множеству $$U$$ или лишь является началом другого слова, принадлежащего $$U$$.)

    10.8.2. Решить предыдущую задачу с дополнительным ограничением: объем используемой памяти пропорционален длине слова $$Y$$.

    Решение. Прежний способ не годится: число вершин дерева равно числу подслов слова $$Y$$, а у слова длины $$m$$ число подслов может быть порядка $$m^2$$, а не $$m$$. Однако мы можем "сжать" наше дерево, оставив вершинами лишь точки ветвления (где больше одного сына). Тогда на ребрах дерева надо написать уже не буквы, а куски слова $$Y$$.

    Вот что получится при сжатии нашего примера:

    Будем считать (здесь и далее), что последняя буква слова $$Y$$ больше в нем не встречается. (Этого всегда можно достичь, дописав дополнительный фиктивный символ.) Тогда листья сжатого дерева соответствуют концам слова $$Y$$, а внутренние вершины (точки ветвления) - таким подсловам $$s$$ слова $$Y$$, которые встречаются в $$Y$$ несколько раз, и притом с разными буквами после $$s$$.

    У каждой внутренней вершины (не листа) сжатого дерева есть не менее двух сыновей. В деревьях с такими свойствами число внутренних вершин не превосходит числа листьев. (В самом деле, при движении слева направо в каждой точке ветвления добавляется новый путь к листу.) Поскольку листьев $$m$$, всего вершин не более $$2m$$, и мы уложимся в линейную по $$m$$ память, если будем экономно хранить пометки на ребрах. Каждая такая пометка является подсловом слова $$Y$$, и потому достаточно указывать координату ее начала и конца в $$Y$$. Это не помешает впоследствии прослеживать произвольное слово $$X$$ в этом дереве буква за буквой, просто в некоторые моменты мы будем находиться внутри ребер (и должны помнить, внутри какого ребра и в какой позиции мы находимся). При появлении новой буквы слова $$X$$ ее нужно сравнить с соответствующей буквой пометки этого ребра (что можно сделать за $$O(1)$$ действий, так как координату этой буквы мы знаем.)

    Построенное нами сжатое дерево называют сжатым суффиксным деревом } слова $$Y$$ (концы слова называют "суффиксами").

    10.8.3. Показать, что построение сжатого суффиксного дерева можно выполнить за время $$O(m^2)$$ с использованием $$O(m)$$ памяти.

    Решение. Будем добавлять в суффиксное дерево суффиксы по очереди. Добавление очередного суффикса делается так же, как и проверка принадлежности: мы читаем его буква за буквой и прокладываем путь в дереве. В некоторый момент добавляемый суффикс выйдет за пределы дерева (напомним, что мы считаем, что последний символ слова уникален).

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

    Гораздо более сложной задачей является построение сжатого суффиксного дерева за линейное время (вместо квадратичного, как в предыдущей задаче). Чтобы изложить алгоритм МакКрейта, который решает эту задачу, нам понадобятся некоторые приготовления.

    Для начала опишем более подробно структуру дерева, которое мы используем, и операции с ним.

    Мы рассматриваем деревья с корнем, на ребрах которых написаны слова (пометки); все пометки являются подсловами некоторого заранее фиксированного слова $$Y$$. При этом выполнены такие свойства:

  • каждая внутренняя вершина имеет хотя бы двух сыновей;
  • пометки на ребрах, выходящих из данной вершины, начинаются на разные буквы.
    •

    Каждой вершине $$v$$ такого дерева соответствует слово, которое записано на пути от корня $$r$$ к вершине $$v$$. Будем обозначать это слово $$s(v)$$. Обозначим пометку на ребре, ведущем к $$v$$, через $$l(v)$$, а отца вершины $$v$$ - через $$f(v)$$. Тогда $$s(r)=\Lambda$$ (пустое слово), а$$s(v)=s(f(v))+l(v),$$ для любой вершины $$v\ne r$$ (знак " $$+$$ " обозначает соединение строк).

    Помимо вершин дерева, мы будем рассматривать позиции в нем, которые могут быть расположены в вершинах, а также "внутри ребер" (разделяя пометку этого ребра на две части). Формально говоря, позиция представляет собой пару $$(v,k)$$, где $$v$$ - вершина (отличная от корня), а $$k$$ - целое число в промежутке $$[0, |l(v)|)$$, указывающее, на сколько букв надо вернуться от $$v$$ к корню. Здесь $$|l(v)|$$ - длина пометки $$l(v)$$ ; значение $$k=l(v)$$ соответствовало бы предыдущей вершине и потому не допускается. К числу позиций мы добавляем также пару $$(r,0)$$, соответствующую корню дерева. Каждой позиции $$p=(v,k)$$ соответствует слово $$s(p)$$, которое получается удалением $$k$$ последних символов из $$s(v)$$.

    Пусть $$p$$ - произвольная позиция в дереве, а $$w$$ - слово. Пройти вдоль $$w$$, начиная с $$p$$, означает найти другую позицию $$q$$, для которой $$s(q)=s(p)+w$$. Если такая позиция есть, то (при описанном способе хранения пометок, когда указываются координаты их начала и конца внутри $$Y$$ ) ее можно найти за время, пропорциональное длине слова $$w$$. Если такой позиции нет, то в какой-то момент мы "свернем с пути"; в этот момент можно пополнить дерево, сделав отсутствующую в дереве часть слова $$w$$ пометкой на пути к новому листу. Надо только, чтобы эта пометка была подсловом слова $$Y$$ (при нашем способе хранения пометок); это будет гарантировано, если прослеживаемое слово $$w$$ является подсловом слова $$Y$$.

    Заметим, что при этом может образоваться новая вершина (если развилка оказалась внутри ребра), а может и не образоваться (если развилка оказалась в вершине). Число действий при такой модификации пропорционально длине пройденной части слова (длина непройденной не важна).

    Оказывается, что навигацию в дереве можно ускорить, если заранее известно, что она будет успешной.

    10.8.4. Пусть для данной позиции $$p$$ и слова $$w$$ заранее известно, что в дереве есть позиция $$q$$, для которой $$s(q)=s(p)+w$$. Показать, что позицию $$q$$ можно найти за время, пропорциональное числу ребер дерева на пути от $$p$$ к $$q$$. (Это число может быть значительно меньше длины слова $$w$$, если пометки на ребрах длинные.)

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

    Подведем итоги. Рассмотренный способ хранения деревьев позволяет (для фиксированного слова $$Y$$ )

  • создать дерево из одного корня [ $$O(1)$$ ];
  • найти отца любой вершины (кроме корня) [ $$O(1)$$ ];
  • узнать пометку любой вершины (кроме корня), то есть пометку ведущего к ней ребра [ $$O(1)$$ ];
  • пройти из любой позиции $$p$$ вдоль любого слова $$w$$, если заранее известно, что мы не выйдем из дерева; результатом является позиция $$q$$ в дереве, для которой $$s(q)=s(p)+w$$ [ O (число ребер на пути)];
  • добавить слово $$w$$, начав с позиции $$p$$ ; если при этом слово $$w$$ является подсловом $$Y$$, а в дереве нет позиции $$q$$, для которой $$s(q)=s(p)+w$$, то дерево меняется и такая позиция $$q$$ создается (она будет листом) [ O (число букв в w, не вошедших в l(q) ];
  • наконец, для любого слова $$X$$ можно выяснить, найдется ли в дереве позиция $$q$$, для которой $$s(q)=X$$ [ $$O(|X|)$$ ].
    •

    В квадратных скобках указано число действий при выполнении соответствующих операций.

    Еще мы будем хранить в вершинах дерева " суффиксные ссылки " (в каждой вершине будет не более одной ссылки на другую вершину), но сначала надо объяснить, что это такое.

    Начнем с полного (не сжатого) суффиксного дерева для слова $$Y$$. Каждой его вершине (кроме корня) отвечает некоторое непустое подслово слова $$Y$$. Если мы отрежем у этого подслова последнюю букву, то в дереве спустимся на один шаг к корню. Но что будет, если мы отрежем первую букву? Снова получится подслово, но оно уже будет совсем в другом месте дерева.

    Вот как выглядят эти переходы в нашем примере (отрезание первой буквы соответствует пунктирной стрелке):

    Эти стрелки мы будем называть суффиксными ссылками, поскольку они соответствуют переходу от слова к его суффиксу на единицу меньшей длины. Они определены для всех вершин, кроме корня.

    Формально можно сказать так. Пусть $$w'$$ означает слово $$w$$ без первой буквы ( $$w'$$ определено для любого непустого слова $$w$$ ). Тогда суффиксная ссылка ведет из вершины $$p$$ в вершину $$q$$, если $$s(q)=s(p)'$$ (напомним, что $$s(u)$$ - слово, соответствующее вершине $$u$$ ).

    10.8.5. Как связаны суффиксные ссылки двух соседних вершин (отца и сына)?

    Ответ. Они указывают на соседние вершины, и буква на соединяющем их ребре та же самая.

    10.8.6. Доказать, что при переходе к сжатому суффиксному дереву ссылки по-прежнему идут из вершины в вершину (а не внутрь ребер).

    Решение. В самом деле, по нашему предположению последняя буква слова больше в нем не встречается, поэтому из листа ссылка ведет в лист. А если вершина (отличная от корня) является точкой ветвления, то соответствующее ей слово $$s$$ встречается с различными буквами после него. Другими словами, для некоторых букв $$a$$ и $$b$$ слова $$sa$$ и $$sb$$ являются подсловами слова $$Y$$. Отрезав от них первую букву, получим слова $$s'a$$ и $$s'b$$, которые также являются подсловами слова $$Y$$, поэтому и $$s'$$ является точкой ветвления.

    Вот что получится для нашего примера:

    Теперь мы уже готовы к изложению алгоритма МакКрейта. Сжатое суффиксное дерево строим постепенно, добавляя к нему суффиксы по мере уменьшения их длины. Обозначим через $$Y_i$$ суффикс, начинающийся с $$i$$ -ой буквы слова $$Y$$. (Таким образом, $$Y_1=Y$$, а $$Y_m$$ состоит из одной буквы.) После $$i$$ шагов построения наше дерево будет хранить $$Y_1,\ldots,Y_i$$.

    10.8.7. Показать, что суффиксные ссылки в таком дереве определены корректно (ведут в другую вершину того же дерева) для всех вершин, кроме, возможно, последнего добавленного листа (соответствующего слову $$Y_i$$ ) и его отца.

    Решение. В самом деле, суффиксная ссылка из листа $$Y_j$$ ведет в лист $$Y_{j+1}$$, и потому ей есть куда вести. Рассмотрим теперь внутреннюю вершину $$v$$, не являющуюся отцом последнего листа. Пусть в ней разветвляются два пути в листья $$Y_j$$ и $$Y_k$$. Без ограничения общности можно считать, что $$j,k<i$$ (если один из путей ведет в $$Y_i$$, то его можно заменить другим, ведь вершина $$v$$ по предположению не последняя развилка на этом пути). Отрезав от этих путей первый символ, получим пути в листья $$Y_{j+1}$$ и $$Y_{k+1}$$ ; эти пути присутствуют в дереве (поскольку $$j+1$$ и $$k+1$$ не превосходят $$i$$ ), а точка их развилки будет концом суффиксной ссылки вершины $$v$$.

    Суффиксные ссылки для листьев нам не понадобятся, и вычислять мы их не будем, а для всех остальных вершин дерева мы их будем вычислять и хранить. Более точно, после $$i$$ шагов алгоритма

  • в дереве хранятся слова $$Y_1,\ldots Y_i$$ (и все их начала);
  • адрес листа, соответствующего последнему добавленному суффиксу ( $$Y_i$$ ) хранится в переменной $$\textit{last}$$ ;
  • для всех внутренних вершин дерева, кроме, быть может, отца вершины $$\textit{last}$$, хранится правильная суффиксная ссылка.
    •

    Надо понять, как поддерживать это при добавлении очередного суффикса. Можно, не мудрствуя лукаво, добавлять $$Y_{i+1}$$ буква за буквой, начиная с корня дерева. (Именно так мы раньше и делали, и это требовало квадратичного времени.)

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

    Оба варианта предполагают, что отец $$u$$ листа $$\textit{last}$$ не совпадает с корнем. (Если совпадает, нам придется добавлять $$Y_{i+1}$$ от корня.) Пусть $$\textit{tail}$$ - пометка листа $$\textit{last}$$, а $$\textit{head}=s(u)$$ ; другими словами, слово $$\textit{head}$$ соответствует вершине $$u$$. Тогда$$Y_i = \textit{head}+\textit{tail}.$$ Отрезая первую букву, получаем$$Y_{i+1}=\textit{head}\,'+\textit{tail}.$$

    Заметим, что $$\textit{head}\,'$$ заведомо не выходит за пределы дерева. В самом деле, $$\textit{u}$$ было точкой ветвления, поэтому помимо листа $$Y_i$$ через точку $$u$$ проходил и лист $$Y_j$$ с $$j<i$$. Тогда $$Y_j$$ начинается на $$\textit{head}$$, а $$Y_{j+1}$$ начинается на $$\textit{head}\,'$$ и уже есть в дереве.

    Поэтому мы можем сначала проследить $$\textit{head}\,'$$ (найти позицию $$v$$, для которой $$s(v)=\textit{head}\,'$$ ), а потом уже добавить $$\textit{tail}$$, начиная с $$v$$.

    Первый способ оптимизации: $$\textit{head}\,'$$ заведомо есть в дереве.

    Эта оптимизация никак не использует суффиксных ссылок. Второй способ оптимизации их использует и позволяет (в том случае, когда применим) обойтись без прослеживания $$Y_{i+1}$$ от корня (как ускоренного, так и обычного). Пусть на пути к листу $$\textit{last}$$, представляющему суффикс $$Y_i$$, имеется вершина $$v$$, у которой суффиксная ссылка указывает на вершину $$w$$, так что $$s(w)=s(v)'$$. Пусть $$p$$ - слово на пути от $$v$$ к $$\textit{last}$$.

    Тогда

    $$Y_{i}=s(v)+p,\quad Y_{i+1}=Y_{i}'=s(v)'+p= s(w)+p,$$

    и для добавления $$Y_{i+1}$$ в дерево достаточно добавить слово $$p$$, начиная с вершины $$w$$.

    Второй способ оптимизации сочетается с первым: отрезок слова $$p$$ от $$v$$ до отца листа $$\textit{last}$$ можно проходить с уверенностью, что мы не выйдем за пределы дерева.

    Итак, мы можем описать действия, выполняемые при добавление очередного суффикса $$Y_{i+1}$$ в дерево, следующим образом.

    Второй способ оптимизации: пользуемся суффиксной ссылкой вершины на пути к $$\textit{last}$$.

    Пусть $$u$$ - отец листа $$\textit{last}$$, соответствующего последнему уже добавленному суффиксу $$Y_i$$.

    Случай 1: $$u$$ есть корень дерева. Тогда ни одна из оптимизаций не применима, и мы добавляем $$Y_{i+1}$$, начиная от корня.

    Случай 2: $$u$$ не есть корень дерева, но отец $$u$$ есть корень дерева (лист $$\textit{last}$$ находится на высоте $$2$$ ). Тогда $$Y_i=\textit{head}+\textit{tail}$$, где $$\textit{head}$$ и $$\textit{tail}$$ - пометки вершин $$u$$ и $$\textit{last}$$. Мы применяем первую оптимизацию и прослеживаем $$\textit{head}\,'$$ с гарантией до некоторой позиции $$z$$, а потом добавляем $$\textit{tail}$$ от $$z$$.

    Случай 3: $$u$$ не есть корень дерева и его отец $$v$$ также не есть корень дерева. Тогда для $$v$$ имеется суффиксная ссылка на некоторую вершину $$w$$, и $$s(w)=s(v)'$$. Пусть $$\textit{pretail}$$ - пометка вершины $$u$$, а $$\textit{tail}$$ - пометка листа $$\textit{last}$$, при этом $$Y_i=s(v)+\textit{pretail}+\textit{tail}$$ и потому $$Y_{i+1}=Y_i'=s(w)+\textit{pretail}+\textit{tail}$$. Остается проследить $$\textit{pretail}$$ от вершины $$w$$ с гарантией, получив некоторую позицию $$z$$, а потом добавить $$\textit{tail}$$ от вершины $$z$$.

    Остается еще понять, как поддерживать структуру суффиксных ссылок (адрес нового листа у нас получается при добавлении сам собой, так что с ним проблем нет) и оценить число действий при выполнении этих процедур последовательно для всех суффиксов.

    Начнем с суффиксных ссылок. По правилам они должны быть у всех внутренних вершин, кроме отца только что добавленного листа. Поэтому нам надо заботиться об отце листа $$\textit{last}$$, соответствующего $$Y_i$$ (этот лист перестал быть "только что добавленным"; напротив, единственная новая вершина как раз является отцом только что добавленного листа и в ней суффиксная ссылка не нужна). Это актуально в случаях 2 и 3, но в этих случаях по ходу дела была найдена нужная вершина $$z$$, куда и будет направлена суффиксная ссылка из $$u$$. Строго говоря, $$z$$ могла быть не вершиной, а позицией, но тогда после добавления она станет вершиной (отцом только что добавленного листа) - ведь в новом дереве $$u$$ уже не является отцом последнего листа, и потому суффиксная ссылка из $$u$$, как было доказано, должна вести в вершину. (Другими словами, в случаях 2 и 3, если позиция $$z$$ была внутри ребра, то в ней ребро разрезается.)

    Все сказанное можно условно записать в виде такого алгоритма добавления суффикса $$Y_{i+1}$$:

    { дерево содержит суффиксы Y1,...,Yi
  s(last)=Yi
  имеются корректные суффиксные ссылки для всех
  внутренних вершин, кроме отца листа last} 
u :=  отец листа last;
tail := пометка листа last;
Yi=s(u)+tail 
if u=корень дерева then begin
| {Yi+1=tail'}  
| добавить tail', начиная с корня,
|    полученный лист поместить в last
end else begin}
| v := отец вершины u;
| pretail := пометка вершины u;
| {Yi=s(v)+pretail}+tail}
| if v = корень дерева then begin
| | {Yi+1=pretail'+tail} 
| | проследить pretail' из корня в z
| end else begin
| | w := суффиксная ссылка вершины v;
| | s(w)=s(v)', Yi+1=s(w)+pretail+tail} 
| | проследить pretail из w в z
| end;
| {осталось добавить tail из z и ссылку из u в z}
| if позиция z является вершиной then begin
| | поместить в u ссылку на z;
| | добавить tail, начиная с z,
| |     полученный лист поместить в last;
| end else begin
| добавить tail, начиная с z,
|     полученный лист поместить в last;
| поместить в u ссылку на отца листа last;
| end
end;

    Осталось оценить число действий, которые выполняются при последовательном добавлении суффиксов $$Y_1,\ldots, Y_m$$. При добавлении каждого следующего суффикса выполняется конечное число действий, если не считать действий при "прослеживании" и "добавлении". Нам надо установить, что общее число действий есть $$O(m)$$ ; для этого достаточно отдельно доказать, что суммарное число действий при всех прослеживаниях есть $$O(m)$$ и суммарное число действий при всех добавлениях есть $$O(m)$$. (Заметим, что некоторые прослеживания или добавления могут быть долгими - но это компенсируется другими.)

    Прослеживания. Длительность прослеживания пропорциональна числу $$k$$ задействованных в нем ребер, но при этом высота последнего добавленного листа (число ребер на пути к нему) увеличивается на $$k-O(1)$$ (по сравнению с предыдущим добавленным листом). Чтобы убедиться в этом, достаточно заметить, что в третьем случае высота вершины $$s(w)$$ может быть меньше высоты вершины $$s(v)$$ разве что на единицу, поскольку суффиксные ссылки из всех вершин на пути к $$v$$ (не считая корня, где нет суффиксной ссылки) ведут в вершины на пути к $$w$$. Поскольку высота любого листа ограничена числом $$m$$, заключаем, что общая длительность всех прослеживаний есть $$O(m)$$.

    Добавления. Рассуждаем аналогично, но следим не за высотой последнего листа, а за длиной его пометки. При добавлении слова $$\textit{tail}$$ (или $$\textit{tail}\,'$$ ) число действий пропорционально числу просмотренных букв, но каждая просмотренная буква (кроме, быть может, одной) уменьшает длину пометки хотя бы на единицу: в пометке остаются лишь непросмотренные буквы (не считая первой). Поэтому на все добавления уходит в общей сложности $$O(m)$$ действий.

    Тем самым мы доказали, что описанный алгоритм строит сжатое суффиксное дерево слова $$Y$$ длины $$m$$ за $$O(m)$$ действий. После этого для любого слова $$X$$ длины $$n$$ можно за $$O(n)$$ действий выяснить, является ли $$X$$ подсловом слова $$Y$$.

    10.8.8. Как модифицировать алгоритм построения суффиксного дерева, чтобы не только узнавать, является ли данное слово $$X$$ подсловом слова $$Y$$, но и (если является) указывать место, где оно встречается (одно из таких мест, если их несколько)? Время построения должно оставаться $$O(|Y|)$$, время поиска подслова - $$O(|X|)$$.

    Решение. Каждая вершина сжатого суффиксного дерева соответствует некоторому подслову слова $$Y$$ ; в момент, когда эта вершина была добавлена в дерево, известно, в каком месте есть такое подслово, и можно записать в вершине, где соответствующее подслово кончается.

    10.8.9. Как модифицировать этот алгоритм, чтобы для каждого подслова можно было бы указывать его первое (самое левое) вхождение?

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

    10.8.10. Как модифицировать этот алгоритм, чтобы для каждого подслова можно было бы указывать его последнее (самое правое) вхождение?

    Указание. Если при каждом проходе корректировать информацию вдоль пути, это будет долго; быстрее построить дерево, затем вновь его обойти и для каждой вершины вычислить момент последнего появления соответствующего подслова.

    10.8.11. Как использовать сжатое суффиксное дерево, чтобы для данного слова $$Y$$ за время $$O(|Y|)$$ найти самое длинное подслово, которое входит в $$Y$$ более одного раза?

    Решение. Такое подслово является внутренней вершиной суффиксного дерева, поэтому достаточно из всех его вершин взять ту, которой соответствует самое длинное слово. Для этого достаточно обойти все его вершины (длину можно вычислять по мере обхода, складывая длины пометок на ребрах).

    На практике можно использовать также и другой способ нахождения самого длинного подслова, входящего дважды, - так называемый массив суффиксов. А именно, будем рассматривать число $$i$$ как "код" конца слова, начинающего с $$i$$ -ой буквы. Введем на кодах порядок, соответствующий лексикографическому (словарному) порядку на словах: код $$i$$ предшествует коду $$j$$, если конец слова, начинающийся с $$i$$, в лексикографическом порядке идет раньше конца слова, начинающегося с $$j$$. После этого отсортируем коды в соответствии с этим порядком, получив некоторую перестановку массива $$1,2,3,\ldots,m$$ (где $$m$$ - длина исходного слова $$Y$$ ). Если какое-то слово $$X$$ входит в слово $$Y$$ дважды, то оно является началом двух концов слова $$Y$$. При этом эти концы можно выбрать соседними в лексикографическом порядке, поскольку все промежуточные слова тоже начинаются на $$X$$. Значит, достаточно для всех соседних концов посмотреть, сколько начальных букв у них совпадает, и взять максимум.

    Этот способ требует меньше памяти (нам нужен лишь один массив из целых чисел той же длины, что исходное слово), но может требовать большого времени: во-первых, сортировка сама по себе требует порядка $$m log m$$ сравнений, во-вторых, каждое сравнение может длиться долго, если совпадающий кусок большой. Но в случаях, когда длинных совпадающих кусков мало, такой алгоритм работает неплохо.

    10.8.12. Применить один из таких алгоритмов к любимой книге и объяснить результат.

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

    Предыдущее занятие Следующее занятие
    Вернуться к учебному плану
    ^