Жанр: Учеба
Программирование в теоремах и задачах
...ют вершины, доступные из данной.
Для этого случая задачи о кратчайших путях приведенные в
предыдущем разделе алгоритмы - не наилучшие. В самом деле, более
быстрая рекурсивная программа решения этой задачи приведена в
главе 7 (Рекурсия), а нерекурсивная - в главе 6 (Типы данных).
Сейчас нас интересует такая задача: не просто перечислить все
вершины, доступные из данной, но перечислить их в определенном
порядке. Два популярных случая - поиск в ширину и в глубину.
Поиск в ширину: надо перечислить все вершины ориентированного
графа, доступные из данной, в порядке увеличения длины пути
от нее. (Тем самым мы решим задачу о кратчайших путях, кода цены
ребер равны 1 или бесконечны.)
9.2.1. Придумать алгоритм решения этой задачи с числом
действий не более C*(число ребер, выходящих из интересующих нас
вершин).
Решение. Эта задача рассматривалась в главе 6 (Типы данных),
6.3.7 - 6.3.8. Здесь мы приведём подробное решение. Пусть
num[i] - количество ребер, выходящих из i, out[i][1],...,
out[i][num[i]] - вершины, куда ведут ребра. Вот программа, приведённая
ранее:
procedure Доступные (i: integer);
| {напечатать все вершины, доступные из i, включая i}
| var X: подмножество 1..n;
| P: подмножество 1..n;
| q, v, w: 1..n;
| k: integer;
begin
| ...сделать X, P пустыми;
| writeln (i);
| ...добавить i к X, P;
| {(1) P = множество напечатанных вершин; P содержит i;
| (2) напечатаны только доступные из i вершины;
| (3) X - подмножество P;
| (4) все напечатанные вершины, из которых выходит
| ребро в ненапечатанную вершину, принадлежат X}
| while X непусто do begin
| | ...взять какой-нибудь элемент X в v;
| | for k := 1 to num [v] do begin
| | | w := out [v][k];
| | | if w не принадлежит P then begin
| | | | writeln (w);
| | | | добавить w в P;
| | | | добавить w в X
| | | end;
| | end;
| end;
end;
Тогда нам было безразлично, какой именно элемент множества X выбирается.
Если мы будем считать X очередью (первым пришел - пермым
ушел), то эта программа напечатает все вершины, доступные из
i, в порядке возрастания их расстояния от i (числа ребер на
кратчайшем пути из i). Докажем это.
Обозначим через V(k) множество всех вершин, расстояние которых
от i (в описанном смысле) равно k. Имеет место такое соотношение:
V(k+1) = (концы ребер с началами в V(k))-V(0)-V(1)-...-V(k)
(знак "-" обозначает вычитание множеств). Докажем, что для любого
k=0,1,2... в ходе работы программы будет такой момент (после
очередной итерации цикла while), когда
в очереди стоят все элементы V(k) и только они
напечатаны все элементы V(1),...,V(k)
(Для k=0 - это состояние перед циклом.) Рассуждая по индукции,
предположим, что в очереди скопились все элементы V(k). Они будут
просматривать в цикле, пока не кончатся (поскольку новые
элементы добавляются в конец, они не перемешаются со старыми).
Концы ведущих из них ребер, если они уже не напечатаны, печатаются
и ставятся в очередь - то есть всё как в записанном выше
соотношении для V(k+1). Так что когда все старые элементы кончатся,
в очереди будут стоять все элементы V(k+1).
Поиск в глубину.
Рассматривая поиск в глубину, удобно представлять себе ориетированный
граф как образ дерева. Более точно, пусть есть ориентированный
граф, одна из вершин которого выделена. Будем полагать,
что все вершины доступны из выделенной по ориентированным
путям. Построим дерево, которое можно было бы назвать "универсальным
накрытием" нашего графа. Его корнем будет выделенная
вершина графа. Из корня выходят те же стрелки, что и в графе -
их концы будут сыновьями корня. Из них в дереве выходят те же
стрелки, что и в графе и так далее. Разница между графом и деревом
в том, что пути в графе, ведущие в одну и ту же вершину, в
дереве "расклеены". В других терминах: вершина дерева - это путь
в графе, выходящий из корня. Ее сыновья - это пути, продолженные
на одно ребро. Заметим, что дерево бесконечно, если в графе есть
ориентированные циклы.
Имеется естетвенное отображение дерева в граф (вершин в
вершины). При этом каждая вершина графа имеет столько прообразов,
сколько путей в нее ведет. Поэтому обход дерева (посещение
его вершин в том или ином порядке) одновременно является и обходом
графа - только каждая вершина посещается многократно.
Будем предполагать, что для каждой вершины графа выходящие
из нее ребра упорядочены (напрмиер, пронумерованы). Тем самым
для каждой вершины дерева выходящие из нее ребра также упорядочены.
Будем обходить дерево так: сначала корень, а потом поддеревья
(в порядке ведущих в них ребер). Такой обход дерева
рассматривался нами в главе о рекурсии. Ему соответствует обход
графа. Если выкинуть из этого обхода повторные посещения уже посещенных
вершин, то получится то, что называется "поиск в глубину".
Другими словами: на путях, выходящих из выделенной вершины,
введем порядок: путь предшествует своему продолжению; если два
пути расходятся в некоторой вершине, то меньшим считается тот,
который выходит из нее по меньшему ребру. Вершины теперь упорядочиваются
в соответствии с минимальными путями, в них ведущими.
Обход вершин графа ы указанном порядке называется поиском в глубину.
9.2.2. Написать программу поиска в глубину.
Указание. Возьмем программу обхода дерева (корень - левое
поддерево - правое поддерево) из главы о рекурсии или из гравы
об устранении рекурсии и используем ее применительно к обстоятельствам.
Главное изменение: не надо посещать вершины повторно.
Так что если мы попали в уже посещенную вершину, то можно с
ней ничего не делать. (Если путь не минимален среди ведущих в
данную вершину, то и все его продолжения не минимальны - их
просматривать не надо).
Замечание. Существуют две возможности устранения рекурсии в
программе обхода дерева. Можно хранить в стеке корни подлежащих
посещению поддеревьев (как это делалось в главе об устранении
рекурсии). А можно применять метод из главы об обходе дерева, то
есть реализовать операции "вверх_налево", "вправо" и "вниз".
Чтобы их реализовать, необходимо хранить в стеке путь из корня к
текущей вершине. Оба способа - примерно одинаковой сложности, и
в конкретной ситуации любой из них может оказаться более удобным.
Поиск в глубину лежит в основе многих алгоритмов на графах,
порой в несколько модифицированном виде.
9.2.3. Неориентированный граф называется двудольным, если
его можно раскрасить в два цвета так, что концы любого ребра -
разного цвета. Составить алгоритм проверки, является ли заданный
граф двудольным (число действий не провосходит C*(число ребер +
число вершин).
Указание. (а) Каждую связную компоненту можно раскрашивать
отдельно. (б) Выбрав цвет одной вершины и обходя ее связную компоненту,
мы определяем единственно возможный цвет остальных.
Замечание. В этой задаче безразлично, производить поиск в
ширину или в глубину.
9.2.4. Составить нерекурсивный алгоритм топологической сортировки
ориентированного графа без циклов. (См. задачу 7.4.2 в
главе о рекурсии.)
Решение. Предположим, что граф имеет вершины с номерами
1..n, для каждой вершины i известно число num[i] выходящих из
нее ребер и номера вершин dest[i][1],..., dest[i][num[i]], в которые
эти ребра ведут. Будем условно считать, что ребра перечислены
"слева направо": левее то ребро, у которого номер меньше.
Нам надо напечатать все вершины в таком порядке, чтобы конец любого
ребра был напечатан перед его началом. Мы предполагаем, что
в графе нет ориентированных циклов - иначе такое невозможно.
Для начала добавим к графу вершину 0, из которой ребра ведут
в вершины 1,...,n. Если ее удастся напечатать с соблюдением
правил, то тем самым все вершины будут напечатаны.
Алгоритм хранит путь, выходящий из нулевой вершины и идущий
по ребрам графа. Переменная l отводится для длины этого пути.
Путь образован вершинами vert[1],..., vert[l] и ребрами,
имеющими номера edge[1]...edge[l]. Номер edge[s] относится к нумерации
ребер, выходящих из вершины vert[s]. Тем самым для всех
s должны выполняться неравенство
edge[s] "= num[vert[s]]
и равенство
vert[s+1] = dest [vert[s]] [edge[s]]
Впрочем, для последнего ребра мы сделаем исключение, разрешив
ему указывать "в пустоту", т.е. разрешим
edge[l] равняться num[vert[l]]+1.
В процессе работы алгоритм будет печатать номера вершин,
при этом соблюдая требование "вершина напечатана только после
тех вершин, в которые из нее ведут ребра". Наконец, будет выполняться
такое требование:
(И) вершины пути, кроме последней (т.е. vert[1]..vert[l])
не напечатаны, но свернув с пути налево, мы немедленно
упираемся в напечатанную вершину
Вот что получается:
l:=1; vert[1]:=0; edge[1]:=1;
while not( (l=1) and (edge[1]=n+1)) do begin
| if edge[l]=num[vert[l]]+1 then begin
| | {путь кончается в пустоте, поэтому все вершины,
| | следующие за vert[l], напечатаны - можно
| | печатать vert[l]}
| | writeln (vert[l]);
| | l:=l-1; edge[l]:=egde[l]+1;
| end else begin
| | {edge[l] "= num[vert[l]], путь кончается в
| | вершине}
| | lastvert:= dest[vert[l]][edge[l]]; {последняя}
| | if lastvert напечатана then begin
| | | edge[l]:=edge[l]+1;
| | end else begin
| | | l:=l+1; vert[l]:=lastvert; edge[l]:=1;
| | end;
| end;
end;
{путь сразу же ведет в пустоту, поэтому все вершины
левее, то есть 1..n, напечатаны}
9.2.4. Доказать, что если в графе нет циклов, то этот алгоритм
заканчивает работу.
Решение. Пусть это не так. Каждая вершина может печататься
только один раз, тако что с некоторого момента вершины не печатаются.
В графе без циклов длина пути ограничена (вершина не может
входить дважды), поэтому подождав еще, мы можем дождаться
момента, после которого путь не удлиняется. После этого может
разве что увеличиваться edge[l] - но и это не беспредельно.
Глава 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;
{все предыдущие положения о
...Закладка в соц.сетях
