Глава 10. Сопоставление с образцом.
Глава 10. Сопоставление с образцом.
10.1. Простейший пример.
10.1.1. Имеется последовательность символов x[1]..x[n]. Оп-
ределить, имеются ли в ней идущие друг за другом символы "abcd".
(Другими словами, требуется выяснить, есть ли в слове x[1]..x[n]
подслово "abcd".)
Решение. Имеется примерно n (если быть точным, n-3) позиций,
на которых может находиться искомое подслово в исходном слове.
Для каждой из позиций можно проверить, действительно ли там оно
находится, сравнив четыре символа. Однако есть более эффективный
способ. Читая слово x[1]..x[n] слева направо, мы ожидаем появле-
ния буквы 'a'. Как только она появилась, мы ждем за ней букву
'b', затем 'c', и, наконец, 'd'. Если наши ожидания оправдывают-
ся, то слово "abcd" обнаружено. Если же какая-то из нужных букв
не появляется, мы оказываемся у разбитого корыта и начинаем все
сначала.
Этот простой алгоритм можно описать в разных терминах. Ис-
пользуя терминологию так называемых конечных автоматов, можно
сказать, что при чтении слова x слева направо мы в каждый момент
находимся в одном из следующих состояний: "начальное" (0),
"сразу после a" (1), "сразу после ab" (2), "сразу после abc" (3)
и "сразу после abcd" (4). Читая очередную букву, мы переходим в
следующее состояние по правилу
Текущее Очередная Новое
состояние буква состояние
0 a 1
0 кроме a 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 ->длина максимального начала слова abcd, являющегося концом x
10.2. Повторения в образце - источник проблем.
10.2.1. Можно ли в предыдущих рассуждениях заменить слово
"abcd" на произвольное слово?
Решение. Нет, и проблемы связаны с тем, что в образце могут
быть повторяющиеся буквы. Пусть, например, мы ищем вхождения
слова "ababc". Вот появилась буква "a", за ней идет "b", за ней
идет "a", затем снова "b". В этот момент мы с нетерпением ждем
буквы "c". Однако - к нашему разочарованию - вместо нее появля-
ется другая буква, и наш образец "ababc" не обнаружен. Однако
нас может ожидать утешительный приз: если вместо "c" появилась
буква "a", то не все потеряно: за ней могут последовать буквы
"b" и "c", и образец-таки будет найден.
Вот картинка, поясняющая сказанное:
x y z a b a b a b c .... <- входное слово
a b a b c <- мы ждали образца здесь
a b a b c <- а он оказался здесь
Таким образом, к моменту
|
x y z a b a b | <- входное слово
|
a b a b | c <- мы ждали образца здесь
|
a b | a b c <- а он оказался здесь
|
есть два возможных положения образца, каждое из которых подлежит
проверке. Тем не менее по-прежнему возможен конечный автомат,
читающий входное слово буква за буквой и переходящий из состо-
яния в состояние в зависимости от прочитанных букв.
10.2.2. Указать состояния соответствующего автомата и таб-
лицу перехода (новое состояние в зависимости от старого и чита-
емой буквы).
Решение. По-прежнему состояния будут соответствовать на-
ибольшему началу образца, являющемуся концом прочитанной части
слова. Их будет шесть: 0, 1 ("a"), 2 ("ab"), 3 ("aba"), 4
("abab"), 5 ("ababc"). Таблица перехода:
Текущее Очередная Новое
состояние буква состояние
0 a 1 (a)
0 кроме a 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.) Будем обозначать его n(X).
Примеры: n(aba)=a, n(abab)=ab, n(ababa)=aba, n(abc) = пус-
тое слово.
10.3.1. Доказать, что все слова n(X), n(n(X)), n(n(n(X)))
и т.д. являются началами слова X.
Решение. Каждое из них (согласно определению) является на-
чалом предыдущего.
По той же причине все они являются концами слова X.
10.3.2. Доказать, что последовательность предыдущей задачи
обрывается (на пустом слове).
Решение. Каждое слово короче предыдущего.
Задача. Доказать, что любое слово, одновременно являющееся
началом и концом слова X (кроме самого X) входит в последова-
тельность n(X), n(n(X)),...
Решение. Пусть слово Y есть одновременно начало и конец X.
Слово n(X) - самое длинное из таких слов, так что Y не длиннее
n(X). Оба эти слова являются началами X, поэтому более короткое
из них является началом более длинного: Y есть начало n(X). Ана-
логично, Y есть конец n(X). Рассуждая по индукции, можно предпо-
лагать, что утверждение задачи верно для всех слов короче X, в
частности, для слова n(X). Так что слово Y, являющееся концом и
началом n(X), либо равно n(X), либо входит в последовательность
n(n(X)), n(n(n(X))), ..., что и требовалось доказать.
10.4. Алгоритм Кнута - Морриса - Пратта
Алгоритм Кнута - Морриса - Пратта (КМП) получает на вход
слово
X = x[1]x[2]...x[n]
и просматривает его слева направо буква за буквой, заполняя при
этом массив натуральных чисел l[1]..l[n], так что
l[i] = длина слова n(x[1]...x[i])
(функция n определена в предыдущем пункте). Словами: l[i] есть
длина наибольшего начала слова x[1]..x[i], одновременно являюще-
гося его концом.
10.4.1. Какое отношение все это имеет к поиску подслова?
Другими словами, как использовать алгоритм КМП для определения
того, является ли слово A подсловом слова B?
Решение. Применим алгоритм КМП к слову A#B, где # - специ-
альная буква, не встречающаяся ни в A, ни в B. Слово A является
подсловом слова B тогда и только тогда, когда среди чисел в мас-
сиве l будет число, равное длине слова A.
10.4.2. Описать алгоритм заполнения таблицы l[1]..l[n].
Решение. Предположим, что первые i значений l[1]..l[i] уже
найдены. Мы читаем очередную букву слова (т.е. x[i+1]) и должны
вычислить l[i+1].
1 i i+1
--------------------------------------------------------
| уже прочитанная часть X | |
--------------------------------------------------------
\-----------Z-----------/ \------------Z------------/
Другими словами, нас интересуют начала Z слова x[1]..x[i+1], од-
новременно являющиеся его концами - из них нам надо выбрать са-
мое длинное. Откуда берутся эти начала? Каждое из них получается
из некоторого слова Z' приписыванием буквы x[i+1]. Слово Z' яв-
ляется началом и концом слова x[1]..x[i]. Однако не любое слово,
являющееся началом и концом слова x[1]..x[i], годится - надо,
чтобы за ним следовала буква x[i+1].
Получаем такой рецепт отыскания слова Z. Рассмотрим все на-
чала слова x[1]..x[i], являющиеся одновременно его концами. Из
них выберем подходящие - те, за которыми идет буква x[i+1]. Из
подходящих выберем самое длинное. Приписав в его конец x[i+1],
получим искомое слово Z.
Теперь пора воспользоваться сделанными нами приготовлениями
и вспомнить, что все слова, являющиеся одновременно началами и
концами данного слова, можно получить повторными применениями к
нему функции n из предыдущего раздела. Вот что получается:
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
| | {начало оказалось неподходящим, применяем к нему n}
| | 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. Доказать, что число действий в приведенном только
что алгоритме не превосходит Cn для некоторой константы C.
Решение. Это не вполне очевидно: обработка каждой очередной
буквы может потребовать многих итераций во внутреннем цикле. Од-
нако каждая такая итерация уменьшает len по крайней мере на 1, и
в этом случае l[i+1] окажется заметно меньше l[i]. С другой сто-
роны, при увеличении i на единицу величина l[i] может возрасти
не более чем на 1, так что часто и сильно убывать она не может -
иначе убывание не будет скомпенсировано возрастанием.
Более точно, можно записать неравенство
l[i+1] <= l[i] - (число итераций на i-м шаге) + 1
или
(число итераций на i-м шаге) <= l[i] - l[i+1] + 1
и остается сложить эти неравества по всем i и получить оценку
сверху для общего числа итераций.
10.4.4. Будем использовать этот алгоритм, чтобы выяснить,
является ли слово X длины n подсловом слова Y длины m. (Как это
делать с помощью специального разделителя #, описано выше.) При
этом число действий будет не более C*(n+m), и используемая па-
мять тоже. Придумать, как обойтись памятью не более Cn (что мо-
жет быть существенно меньше, если искомый образец короткий, а
слово, в котором его ищут - длинное).
Решение. Применяем алгоритм КМП к слову A#B. При этом вы-
числение значений l[1],...,l[n] проводим для слова X длины m и
запоминаем эти значения. Дальше мы помним только значение l[i]
для текущего i - кроме него и кроме таблицы l[1]..l[n], нам для
вычислений ничего не нужно.
На практике слова X и Y могут не находиться подряд, поэтому
просмотр слова X и затем слова Y удобно оформить в виде разных
циклов. Это избавляет также от хлопот с разделителем.
10.4.5. Написать соответствующий алгоритм (проверяющий, яв-
ляется ли слово X=x[1]..x[n] подсловом слова Y=y[1]..y[m]).
Решение. Сначала вычисляем таблицу l[1]..l[n] как раньше.
Затем пишем такую программу:
j:=0; len:=0
{len - длина максимального начала слова X, одновременно
являющегося концом слова y[1]..j[j]}
while (len <> n) and (j <> m) do begin
| while (x[len+1] <> y[j+1]) and (len > 0) do begin
| | {начало оказалось неподходящим, применяем к нему n}
| | 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;
| i := i+1;
end;
{если len=n, слово X встретилось; иначе мы дошли до конца
слова Y, так и не встретив X}
10.5. Алгоритм Бойера - Мура
Этот алгоритм делает то, что на первый взгляд кажется не-
возможным: в типичной ситуации он читает лишь небольшую часть
всех букв слова, в котором ищется заданный образец. Как так мо-
жет быть? Идея проста. Пусть, например, мы ищем образец "abcd".
Посмотрим на четвертую букву слова: если, к примеру, это буква
"e", то нет никакой необходимости читать первые три буквы. (В
самом деле, в образце буквы "e" нет, поэтому он может начаться
не раньше пятой буквы.)
Мы приведем самую простой вариант этого алгоритма, который
не гарантирует быстрой работы во всех случаях. Пусть x[1]..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 = m
(длине образца), затем постепенно увеличивается.
last:=m;
{все предыдущие положения образца уже проверены}
while last <= m do begin {слово не кончилось}
| if x[m] <> y[last] then begin {последние буквы разные}
| | last := last + (m - pos[y[last]]);
| | {m - pos[y[last]] - это минимальный сдвиг образца,
| | при котором напротив y[last] встанет такая же
| | буква в образце. Если такой буквы нет вообще,
| | то сдвигаем на всю длину образца}
| end else begin
| | если нынешнее положение подходит, т.е. если
| | x[1]..x[m] = y[last-m+1]..y[last],
| | то сообщить о совпадении;
| | last := last+1;
| end;
end;
Знатоки рекомендуют проверку совпадения проводить справа налево,
т.е. начиная с последней буквы образца (в которой совпадение за-
ведомо есть). Можно также немного сэкономить, произведы вычита-
ние заранее и храня не pos[s], а m-pos[s], т.е. число букв в об-
разце справа от последнего вхождения буквы s.
Возможны разные модификации этого алгоритма. Например, мож-
но строку last:=last+1 заменить на last:=last+(m-u), где u - ко-
ордината второго справа вхождения буквы x[m] в образец.
10.5.2. Как проще всего учесть это в программе?
Решение. При построении таблицы pos написать
for i:=1 to n-1 do...
в основной программе вместо last:=last+1 написать
last:= last+m-pos[y[last]];
Приведенная нами упрощенный вариант алгоритма Бойера - Мура
в некоторых случаях требует существенно больше n действий (число
действий порядка mn), проигрывая алгоритму Кнута - Морриса -
Пратта.
10.5.3. Привести пример ситуации, в которой образец не вхо-
дит в слово, но авлгоритму требуется порядка mn действий, чтобы
это установить.
Решение. Пусть образец имеет вид baaa..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 и добавлению свободного члена.
Следующее соображение говорит в пользу того, что совпадения
не слишком вероятны. Пусть число 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 a 01
00 не a 01
01 a 11
01 не a 10
10 a 01
10 b найдено
10 не a и не b 00
11 a 11
11 b найдено
11 не a и не b 10
Другой стандартный знак в образце - это звездочка (*), на
место которой может быть подставлено любое слово. Например, об-
разец ab*cd означает, что мы ищем подслово ab, за которым следу-
ет что угодно, а затем (на любом расстоянии) следует cd.
10.7.2. Указать конечный автомат, проверяющий, есть ли во
входном слове образец ab*cd (в описанном только что смысле).
Решение.
Старое состояние Очередная буква Новое состояние
нач a a
нач не a нач
a b ab
a a a
a не a и не b нач
ab c abc
ab не c ab
abc d найдено
abc c abc
abc не с и не d ab
Еще один вид поиска - это поиск любого из слово некоторого
списка.
10.7.3. Дан список слов X[1],...,X[k] и слово Y. Опреде-
лить, входит ли хотя бы одно из слов X[i] в слово Y (как подсло-
во). Количество действий не должно превосходить константы, умно-
женной на суммарную длину всех слов (из списка и того, в котором
происходит поиск).
Решение. Очевидный способ состоит в том, чтобы каждое слово
из списка проверять отдельно (с помощью одного из рассмотренных
алгоритмов). Однако при этом мы не укладываемся в заданное число
действий (из-за умножения k на длину слова Y).
Посмотрим на дело с другой стороны. Каждому образцу из
списка соответствует конечный автомат с некоторым множество сос-
тояний. Их можно объединить в один автомат, множеством состояний
которого будет произведение множеств состояний всех тех автома-
тов. Это - очень большое множество. Однако на самом деле
большинство его элементов недоступны (не могут появиться при
чтении входного слова) и за счет этого получается экономия. При-
мерно эту идею (но в измененном виде) мы и будем использовать.
Вспомним алгоритм Кнута - Морриса - Пратта. В нем, читая
входное слово, мы хранили наибольшее начало образца, являющееся
концом прочитанной части. Теперь нам следует хранить для каждого
из образцов наибольшее его начало, являющееся концом прочитанной
части. Решающим оказывается такое замечание: достаточно хранить
самое длинное из них - все остальные по нему восстанавливаются
(как наибольшие начала образцов, являющиеся его концами).
Склеим все образцы в дерево, объединив их совпадающие на-
чальные участки. Например, набору образцов
{aaa, aab, abab}
соответствует дерево
a/ *
a a / b
* --- * --- * --- *
\b a b
\ * --- * --- *
Формально говоря, вершинами дерева являются все начала всех об-
разцов, а сыновья вершины получаются приписыванием буквы.
Читая входное слово, мы двигаемся по этому дереву: текущая вер-
шина - это наибольшая (самая правая) из вершин, являющихся кон-
цом прочитанной части (=наибольший конец прочитанной части, яв-
ляющийся началом одного из образцов).
Определим функцию n, аргументами и значениями которой являются
вершины дерева. Именно, n(P) = наибольшая вершина дерева, явля-
ющаяся концом P. (Напомним, вершины дерева - это слова.) Нам по-
надобится такое утверждение:
10.7.4. Пусть P - вершина дерева. Докажите, что множество
всех вершин, являющихся концами P, равно {n(P), n(n(P)),...}
Решение. См. доказательство аналогичного утверждения для
алгоритма Кнута - Морриса - Пратта.
Теперь ясно, что нужно делать, находясь в вершине P и читая
букву y входного слова. Надо просматривать последовательно вер-
шины P, n(P), n(n(P)) и т.д., пока не обнаружится такая, из ко-
торой выходит стрелка с буквой y. Та вершина, в которую эта
стрелка ведет, и будет нашим следующим положением.
Остается понять, как для каждой вершины дерева вычислить
указатель на значение функции n в этой вершине. Это делается как
раньше, при этом значения n для более коротких слов используются
при вычислении очередного значения функции n. Это означает, что
вершины дерева следует просматривать в порядке возрастания их
длины. Нетрудно понять, что все это можно уложить в требуемое
число действий (хотя константа зависит от числа букв в алфави-
те). Относящиеся к этому подробности см. в главе об алгоритмах
на графах.
Можно поинтересоваться, какие свойства слов можно распозна-
вать с помощью конечных автоматов. Оказывается, что существует
просто описываемый класс образцов, задающий все такие свойства -
класс регулярных выражений.
Определение. Пусть фикисирован конечный алфавит Г, не со-
держащий символов 'l', 'e', '(', ')', '*' и '|' (они будут ис-
пользоваться для построения регулярных выражений и не должны пе-
ремешиваться с буквами). Регулярные выражения строятся по таким
правилам:
(а) буква алфавита Г - регулярное выражение;
(б) символы 'l', 'e' - регулярные выражения;
(в) если A,B,C,..,E - регулярные выражения, то (ABC...E) -
регулярное выражение.
(г) если A,B,C,..,E - регулярные выражения, то
(A|B|C|...|E) - регулярное выражение.
(д) если A - регулярное выражение, то A* - регулярное выра-
жение.
Каждое регулярное выражение задает множество слов в алфавите Г
по таким правилам:
(а) букве соответствует одноэлементное множество, состоящее
из однобуквенного слова, состоящего из этой буквы;
(б) символу 'e' соответствует пустое множество, а символу
'l' - одноэлементное множество, единственным элементом
которого является пустое слово;
(в) регулярному выражению (ABC...E) соответствует множество
всех слов, которые можно получить, если к слову из A
приписать слово из B, затем из C,..., затем из E ("кон-
катенация" множеств);
(г) регулярному выражению (A|B|C|...|E) соответствует
объединение множеств, соответствующих выражениям
A,B,C,..,E;
(д) регулярному выражению A* соответствует "итерация" мно-
жества, соответствующего выражению A, то есть множество
всех слов, которые можно так разрезать на куски, что
каждый кусок принадлежит множеству, соответствующему
выражению A. (В частности, пустое слово всегда содер-
жится в A*.)
Примеры
Выражение Множество
(a|b)* все слова из букв a и b
(aa)* все слова из четного числа букв a
(l|a|b|aa|ab|ba|bb) любое слово из не более чем 2 букв a,b
10.7.5. Написать регулярное выражение, которому соот-
ветствует множество всех слов из букв a и b, в которых число
букв a четно.
Решение. Выражение b* задает все слова без a, а выражение
(b* a b* a b*)
- все слова ровно с двумя буквами a. Остается объединить эти
множества, а потом применить итерацию:
((b* a b* a b*) | b*)*
10.7.6. Написать регулярное выражение, которое задает мно-
жество всех слов из букв a,b,c, в которых слово bac является
подсловом.
Решение. ((a|b|c)* bac (a|b|c)*)
Теперь задачу о поиске образца в слове можно переформулиро-
вать так: проверить, принадлежит ли слово множеству, соот-
ветствующему данному регулярному выражению.
10.7.7. Какие выражения соответствуют образцам 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.8. Доказать, что для всякого регулярного выражения
можно построить конечный автомат, который распознает соот-
ветствующее этому выражению множество слов.
Решение. Нам потребуется новое понятие - понятие источника
(или недетерминированного конечного автомата). Представим себе
ориентированный граф - картинку из нескольких точек (вершин) и
некоторых стрелок, соединяющих эти точки (ребер). Пусть на неко-
торых ребрах написаны буквы (не обязательно на всех). Пусть так-
же среди вершин выбраны две - начальная Н и конечная К. Такая
картинка называется источником.
Будем двигаться различными способами из Н в К, читая буквы
по дороге (на тех стрелках, где они есть). Каждому пути из Н в
К, таким образом, соответствует некоторое слово. А источнику в
целом соответствует множество слов - тех слов, которые можно
прочесть на путях из Н в К.
Замечание. Если нарисовать состояния конечного автомата в
виде точек, а переходы при чтении букв изобразить в виде стре-
лок, то станет ясно, что конечный автомат - это частный случай
источника.
Мы будем строить конечный автомат по регулярному выражению
в два приема. Сначала мы построим источник, которому соот-
ветствует то же самое множество слов. Затем для произвольного
источника построим автомат, который проверяет, принадлежит ли
слово соответствующему множеству.
10.7.9. По регулярному выражению построить источник, зада-
ющий то же множество.
Решение. Индукция по построению регулярного выражения. Бук-
вам соответствуют графы из одной стрелки. Объединение реализует-
ся так:
|---------|
---->|*Н1 К1*|->---
/ |---------| \
/ |---------| \
* --------->|*Н2 К2*|--->-----* К
Н \ |---------| /
\ |---------| /
--->|*Н3 К3*|--->--
|---------|
Нарисована картинка для объединения трех множеств, прямо-
угольники - это источники, соответствующие им; указаны начальные
и конечные вершины. На новых стрелках (их 6) букв не написано.
Конкатенации соответствует картинка
|--------| |--------| |--------|
Н*--->|*Н1 К1*|---->----|*Н2 К2*| ---->----|*Н3 К3*|-->--*К
|--------| |--------| |--------|
Наконец, итерации соответствует картинка
Н*--------->----------*----------->----------*К
/ \
/ \
| |
V ^
| |
-------------
| *Н1 К1* |
-------------
10.7.10. Дан источник. Построить конечный автомат, проверя-
ющий, принадлежит ли входное слово множеству, соответствующему
источнику (т.е. можно ли прочесть это слово, идя из Н в К).
Решение. Состояниями автомата будут множества вершин источ-
ника. Именно, прочтя некоторое начало X входного слова, мы будем
помнить множество всех вершин источника, в которые можно пройти
из начальной, прочитав на пути слово X.
Оказывается, что регулярные выражения, автоматы и источники
распознают одни и те же множества. Чтобы убедиться в этом, нам
осталось решить такую задачу:
10.7.11. Дан источник. Построить регулярное выражение, за-
дающее то же множество, что и этот источник.
Решение. (Сообщено участниками просеминара по логике.)
Пусть источник имеет вершины 1..k. Будем считать, что 1 - это
начало, а k - конец. Через D[i,j, s] обозначим множество всех
слов, которые можно прочесть на пути из i в j, если в качестве
промежуточных пунктов разрешается использовать только вершины
1,...,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.12. Где еще используется то же самое рассуждение?
Ответ. В алгоритме Флойда вычисления цены кратчайшего пути,
см. главу 9 (Некоторые алгоритмы на графах).
10.7.13. Доказать, что класс множеств, задаваемых регуляр-
ными выражениями, не изменился бы, если бы мы разрешили ис-
пользовать не только объединение, но и отрицание (а следова-
тельно, и пересечение - оно выражается через объединение и отри-
цание).
Решение. Для автоматов переход к отрицанию очевиден.
Замечание. На практике важную роль играет число состояний
автомата. Оказывается, что тут все не так просто, и переход о
источника к автомату требует экспоненциального роста числа сос-
тояний. Подробное рассмотрение связанных с этим теоретических и
практических вопросов - дело особое.
[ Назад ]
[ Оглавление ]
[ Далее ]
