e-maxx_algo

; воспользуемся этим же приёмом и для построения массива .

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

и, . Разбивая каждую подстроку пополам, мы получаем две различных ситуации:

1) Первые половинки подстрок различались. Заметим, что тогда на предыдущем шаге эти первые половинки необходимо были соседними. В самом деле, классы эквивалентности не могли исчезать (а могут только

2) Первые половинки совпадали. Тогда вторые половинки могли как совпадать, так и различаться; при этом, если они различаются, то они совсем не обязательно должны были быть соседними на предыдущей итерации. Поэтому в этом случае нет простого способа определить . Для его определения надо поступить так же, как мы и

собираемся потом вычислять наибольший общий префикс для любых двух суффиксов: надо выполнить запрос минимума (RMQ) на соответствующем отрезке массива .

Оценим асимптотику такого алгоритма. Как мы видели при разборе этих двух случаев, только второй случай даёт увеличение числа классов эквивалентности. Иными словами, можно говорить о том, что каждый новый

класс эквивалентности появляется вместе с одним запросом RMQ. Поскольку всего классов эквивалентности может

Реализация:

int lcp[maxlen], lcpn[maxlen], lpos[maxlen], rpos[maxlen]; memset (lcp, 0, sizeof lcp);

for (int h=0; (1<<h)<n; ++h) { for (int i=0; i<n; ++i)

rpos[c[p[i]]] = i; for (int i=n-1; i>=0; --i) lpos[c[p[i]]] = i;

... все действия по построению суфф. массива, кроме последней

строки (memcpy) ...

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

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

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

этом случае надо просто ограничить значения по окончании работы алгоритма:

for (int i=0; i<n-1; ++i)

lcp[i] = min (lcp[i], min (n-p[i], n-p[i+1]));

Для любых двух суффиксов длину их наибольшего общего префикса теперь можно найти как минимум на соответствующем отрезке массива :

for (int i=0; i<n; ++i) pos[p[i]] = i;

rmq_build (lcp, n-1);

... поступил запрос (i,j) на нахождение LCP ...

int result = rmq (min(i,j), max(i,j)-1);

Количество различных подстрок

д. Фактически, мы берём очередной в порядке сортировки суффикс и смотрим, какие его префиксы дают новые подстроки. Тем самым мы, очевидно, не упустим из виду никакие из подстрок.

Задачи в online judges

Задачи, которые можно решить, используя суффиксный массив:

● UVA #10679 "I Love Strings!!!" [сложность: средняя]

Суффиксный автомат

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

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

На интуитивном уровне, суффиксный автомат можно понимать как сжатую информацию обо всех подстроках данной строки. Впечатляющим фактом является то, что суффиксный автомат содержит всю

Исторически, впервые линейность размера суффиксного автомата была открыта в 1983 г. Blumer и др., а в 1985

— 1986 гг. были представлены первые алгоритмы его построения за линейное время (Crochemore, Blumer и др.). Более подробно — см. список литературы в конце статьи.

На английском языке суффиксный автомат называется "suffix automaton" (во множественном числе — "suffix automata"), а ориентированный ациклический граф слов — "directed acyclic word graph" (или просто "DAWG").

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

Определение. Суффиксным автоматом для данной строки называется такой минимальный детерминированный конечный автомат, который принимает все суффиксы строки .

Расшифруем это определение.

●Суффиксный автомат представляет собой ориентированный ациклический граф, в котором вершины называются состояниями, а дуги графа — это переходы между этими состояниями.

● Одно из состояний называется начальным состоянием, и оно должно быть истоком графа (т.е. из него достижимы все остальные состояния).

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

●Одно или несколько состояний помечены как терминальные состояния. Если мы пройдём из

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

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

Простейшие свойства суффиксного автомата

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

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

Вкаждое состояние суффиксного автомата ведёт один или несколько путей из начального состояния. Будем говорить, что состоянию соответствует набор строк, соответствующих всем этим путям.

Примеры построенных суффиксных автоматов

Приведём примеры суффиксных автоматов, построенных для нескольких простых строк.

Начальное состояние мы будем обозначать здесь через , а терминальные состояния — отмечать звёздочкой. Для строки :

Для строки :

Для строки :

Для строки :

Для строки :

Для строки :

Для строки :

Алгоритм построения суффиксного автомата за линейное время

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

Позиции окончаний , их свойства и связь с суффиксным автоматом

Рассмотрим любую непустую подстроку строки . Тогда назовём множеством окончаний множество всех позиций в строке , в которых оканчиваются вхождения строки .

соответствует одно и то же состояние. Иными словами, число состояний в суффиксном автомате равно количеству классов -эквивалентности среди всех подстрок, плюс одно начальное состояние.

Каждому состоянию суффиксного автомата соответствуют одна или несколько подстрок, имеющих одно и то же значение .

Это утверждение мы примем как аксиому, и опишем алгоритм построения суффиксного автомата, исходя из этого предположения — как мы затем увидим, все требуемые свойства суффиксного автомата, кроме минимальности, будут выполнены. (А минимальность следует из теоремы Nerode — см. список литературы.)

Приведём также несколько простых, но важных утверждений касательно значений .

эквивалентными тогда и только тогда, когда строка встречается в строке только в виде суффикса строки .

Доказательство практически очевидно. В одну сторону: если и имеют одинаковые позиции окончаний вхождения,

то является суффиксом , и она присутствует в только в виде суффикса . В обратную сторону: если является суффиксом и входит только как этот суффикс, то их значения равны по определению.

Тогда это означает, что строки и оканчиваются в одном и том же месте, т.е. — суффикс . Но тогда каждое вхождение строки содержит на своём конце вхождение строки , что и означает, что его множество целиком вкладывается в множество .

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

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

Доказательство.

леммы очевидна. Пусть теперь количество строк больше одной.

Обозначим через длиннейшую, а через — кратчайшую строку в данном классе эквивалентности. Согласно лемме

Суффиксные ссылки

Лемма 4. Суффиксные ссылки образуют дерево, корнем которого является начальное состояние .

состояние, которому соответствуют строки строго меньшей длины (это следует из определения суффиксной ссылки и из леммы 3). Следовательно, двигаясь по суффиксным ссылкам, мы рано или поздно придём из состояния в начальное состояние , которому соответствует пустая строка.

либо не пересекаются, либо одно содержится в другом).

что вкупе с предыдущей леммой и доказывает наше утверждение: дерево суффиксных ссылок по сути своей есть дерево вкладывающихся множеств .

Приведём пример дерева суффиксных ссылок в суффиксном автомате, построенном для строки :

Промежуточный итог

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

с корнем в , причём это дерево, по сути, является деревом отношений включения между множествами .

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

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

Алгоритм построения суффиксного автомата за линейное время

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

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

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

и обозначим через номер состояния, на котором это произошло.

●Если ни разу не случилось, что переход по букве уже имелся, и мы так и дошли до фиктивного состояния (в

которое мы попали по суффиксной ссылке из начального состояния ), то мы можем просто присвоить и выйти.

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

●Теперь у нас два случая в зависимости от того, или нет.

●Если , то мы можем просто присвоить и выйти.

●В противном случае, всё несколько сложнее. Необходимо произвести "клонирование" состояния : создать

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

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

как терминальное. Легко понять, что тем самым мы пометим состояния, соответствующие всем суффиксам строки , что нам и требовалось.

В следующем разделе мы подробно рассмотрим каждый шаг алгоритма и покажем его корректность.

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

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

Доказательство корректности алгоритма

когда , переход будем называть несплошным.

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

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

●Алгоритм начинается с того, что мы создаём новое состояние , которому будет соответствовать вся строка . Понятно, почему мы обязаны создать новое состояние — т.к. вместе с добавлением нового символа возникает новый класс эквивалентности — это класс строк, оканчивающихся на добавляемом символе .

●После создания нового состояния алгоритм проходится по суффиксным ссылкам, начиная с состояния,

соответствующего всей строке , и пытается добавить переход по символу в состояние . Тем самым, мы приписываем к каждому суффиксу строки символ . Но добавлять новые переходы мы можем только в том

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

●Самый простой случай — если мы так и дошли до фиктивного состояния , добавив везде по новому переходу вдоль символа . Это означает, что символ в строке ранее не встречался. Мы успешно добавили все переходы, осталось только проставить суффиксную ссылку у состояния — она, очевидно, должна быть равна , поскольку состоянию в данном случае соответствуют все суффиксы строки .

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

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

этом случае всё просто, никакого расщепления производить не надо, и мы просто проводим суффиксную ссылку

подстроки большей длины. Нам ничего не остаётся, кроме как произвести "расщепление" состояния : разбить отрезок строк, соответствующих ей, на два подотрезка, так что первый будет заканчиваться как раз длиной .

После клонирования мы проводим суффиксную ссылку из в — то, ради чего мы и производили клонирование.

Остался последний шаг — перенаправить некоторые входящие в переходы, перенаправив их на . Какие именно входящие переходы надо перенаправить? Достаточно перенаправить только переходы, соответствующие

Доказательство линейного числа операций

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

при памяти. Впрочем, если алфавит достаточно мал, то можно, пожертвовав памятью,

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

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

Если мы рассмотрим все части алгоритма, то он содержит три места, линейная асимптотика которых не очевидна:

●Первое место — это проход по суффиксным ссылкам от состояния с добавлением рёбер по символу .

●Второе место — копирование переходов при клонировании состояния в новое состояние .

●Третье место — перенаправление переходов, ведущих в , на .

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

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

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

а, значит, и позиция как суффикса строки монотонно возрастает с каждой итерацией. При этом, если перед

Таким образом, каждая итерация этого цикла приводит к тому, что позиция строки

как суффикса всей текущей строки будет монотонно увеличиваться. Следовательно, всего этот цикл не мог отработать более итераций, что и требовалось доказать.

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

Реализация алгоритма

struct state {

int len, link; map<char,int> next;

};

Сам суффиксный автомат будем хранить в виде массива этих структур . Как доказывается в следующем разделе, если — это максимально возможная в программе длина строки, то достаточно завести память под состояний. Также мы храним переменную — состояние, соответствующее всей строке на данный момент.

const int MAXLEN = 100000; state st[MAXLEN*2];

int sz, last;

Приведём функцию, инициализирующую суффиксный автомат (создающую автомат с единственным начальным состоянием):

void sa_init() {

sz = last = 0; st[0].len = 0; st[0].link = -1; ++sz;

/* // этот код нужен, только если автомат строится много раз для

разных строк:

for (int i=0; i<MAXLEN*2; ++i) st[i].next.clear();

*/

}

Наконец, приведём реализацию основной функции — которая добавляет очередной символ в конец текущей строки, перестраивая соответствующим образом автомат:

void sa_extend (char c) { int cur = sz++;

st[cur].len = st[last].len + 1; int p;

for (p=last; p!=-1 && !st[p].next.count(c); p=st[p].link) st[p].next[c] = cur;

if (p == -1)

st[cur].link = 0;

else {

int q = st[p].next[c];

if (st[p].len + 1 == st[q].len) st[cur].link = q;

else {

int clone = sz++; st[clone].len = st[p].len + 1; st[clone].next = st[q].next; st[clone].link = st[q].link;

for (; p!=-1 && st[p].next[c]==q; p=st[p].link) st[p].next[c] = clone;

st[q].link = st[cur].link = clone;

}

}

last = cur;

}