Изменения

|definition= '''Неявное суффиксное дерево''' (англ. ''implicit suffix tree, IST'') строки <tex>S</tex> {{---}} это суффиксное дерево, построенное для строки <tex>S</tex> без добавления защитного символа<tex>\$</tex>.}}

Алгоритм последовательно строит неявные суффиксные деревья для всех префиксов исходного текста <tex>S = s_{1}s_{2}...\ldots s_{n}</tex>. На <tex>i</tex>-ой итерации фазе неявное суффиксное дерево <tex>\tau_{i-1}</tex> для префикса <tex>s[1..\ldots i-1]</tex> достраивается до <tex>\tau_{i}</tex> для префикса <tex>s[1..\ldots i]</tex>. Будем спускаться от корня дерева до конца Достраивание происходит следующим образом: для каждого суффикса префикса подстроки <tex>s[1..\ldots i-1]</tex> необходимо спуститься от корня дерева до конца этого суффикса и дописывать к ним дописать символ <tex>s_{i}s_i</tex>. Не стоит забывать, что <tex>s_{i}</tex> является суффиксом <tex>s[1..i]</tex> , поэтому его тоже нужно добавить в дерево. <br>

Алгоритм состоит из <tex>n</tex> итераций так как в исходном тексте <tex>O(n)</tex> суффиксов, где <tex>n</tex> {{---}} длина текстафаз. На каждой фазе происходит продление всех суффиксов по порядкутекущего префикса строки, что требует <tex>O(n^2)</tex> времени. Следовательно, общая асимптотика алгоритма составляет <tex>O(n^3)</tex>.=== Псевдокод алгоритма за O(n³) ===<code style = "display: inline-block;"> '''for''' i = 1 .. n '''for''' j = 1 .. i treeExtend(s[j..i]) <font color=green>// добавление текущего суффикса работает за линейное время</font></code>'''Замечание:''' на первый взгляд, более логичным подходом кажется добавление всех суффиксов строки в дерево по очереди, получив сразу алгоритм со временем работы <tex>O(n^2)</tex>. Однако осуществить улучшение данного алгоритма до линейного времени работы будет намного сложней, хотя именно в этом и заключается суть [[Алгоритм МакКрейта | алгоритма МакКрейта]].

Ниже приведены возможные случаи, которые могут возникнуть при добавлении символа <tex>s_{i}</tex> ко всем суффиксам префикса <tex>s[1..\ldots i-1]</tex>.{| border="1" cellpadding="53" cellspacing="0" style="text-align:center" width=75%

|style="background:#ffffff"|Пусть суффикс <tex>s[k..\ldots i-1]</tex> заканчивается в листе. Добавим <tex>s_{i}</tex> в конец подстроки, которой помечено ребро, ведущее в этот лист.

|style="background:#ffffff" rowspan="2"|''2.1 Создание листаОтветвление''|style="background:#ffffff"|а) Пусть суффикс <tex>s[k..\ldots i-1]</tex> заканчивается в вершине, не являющейся листом, из которой нет пути по символу <tex>s_{i}</tex>. Создадим новую дугу новый лист, в который из текущей вершины ведёт дуга с началом в элементе <tex>s[i-1]</tex> и листом пометкой <tex>s_{i}</tex>.

|style="background:#ffffff"|''2.2 Ответвление''|style="background:#ffffff"|б) Пусть суффикс <tex>s[k..\ldots i-1]</tex> заканчивается на ребре, с меткой <tex>ts[1..p-1l \ldots r]</tex> совпадает с концом в позиции <tex>s[k..ip-1](l \leqslant p \leqslant r)</tex> и <tex>t_s_{p}\ne s_{i}</tex>. Разобьем текущее ребро новой вершиной на <tex>ts[1..l \ldots p-1]</tex> и <tex>ts[p..l\ldots r]</tex>, где <tex>l</tex> {{---}} длина метки ребра, и подвесим к ней еще одного ребенка с дугой, помеченной <tex>s_{i}</tex>.

|style="background:#ffffff"|''3 . Ничего не делать''|style="background:#ffffff"|Пусть суффикс <tex>s[k..\ldots i-1]</tex> заканчивается в вершине, из которой есть путь по <tex>s_{i}</tex>. Тогда ничего делать не надо.

|definition= Пусть <tex>x\alpha</tex> обозначает произвольную строку, где <tex>x</tex> {{---}} ее её первый символ, а <tex>\alpha</tex> {{---}} оставшаяся подстрока(возможно пустая). Если для внутренней вершины <tex>v</tex> с путевой меткой <tex>x\alpha</tex> существует другая вершина <tex>s(v)</tex> с путевой меткой <tex>\alpha</tex>, то ссылка из <tex>v</tex> в <tex>s(v)</tex> называется '''суффиксной ссылкой'''(англ.''suffix link'').}} 

Рассмотрим внутренную внутреннюю вершину <tex>v</tex> с путевой меткой <tex>ts[j \ldots i..j]</tex>. Так как эта вершина внутренняя, ее её путевая метка ветвится справа в исходной строке. Тогда очевидно подстрока <tex>ts[ij+1..j\ldots i]</tex> тоже ветвится справа в исходной строке, и ей соответствует некоторая внутренняя вершина <tex>u</tex>. По определению суффиксная ссылка вершины <tex>v </tex> ведет ведёт в <tex> u</tex>.

=== Построение Использование суффиксных ссылок ===[[Файл:ExampleUkkonen7.png|300px|thumb|right|Использование суффиксных ссылок.]] Рассмотрим применение суффиксных ссылок. Пусть только что был продлён суффикс <tex>s[j \ldots i-1]</tex> до суффикса <tex>s[j \ldots i]</tex>. Теперь с помощью построенных ссылок можно найти конец суффикса <tex>s[j+1 \ldots i-1]</tex> в суффиксном дереве, чтобы продлить его до суффикса <tex>s[j+1 \ldots i]</tex>. Для этого надо пройти вверх по дереву до ближайшей внутренней вершины <tex>v</tex>, в которую ведёт путь, помеченный <tex>s[j \ldots r]</tex>. У вершины <tex>v</tex> точно есть суффиксная ссылка (о том, как строятся суффиксные ссылки, будет сказано позже, а пока можно просто поверить). Эта суффиксная ссылка ведёт в вершину <tex>u</tex>, которой соответствует путь, помеченный подстрокой <tex>s[j+1 \ldots r]</tex>. Теперь от вершины <tex>u</tex> следует пройти вниз по дереву к концу суффикса <tex>s[j+1 \ldots i-1]</tex> и продлить его до суффикса <tex>s[j+1 \ldots i]</tex>.

Заметим Можно заметить, что в процессе построения суффиксного дерева уже построенные суффиксные ссылки никак не изменяются. Опишем процесс построения суффиксной ссылки для новой созданной внутренней вершины. Пусть в результате очередного продления была создана новая внутренняя вершина подстрока <tex>v s[j+1 \ldots i-1]</tex> с путевой меткой является суффиксом подстроки <tex>ts[j \ldots i..j-1]</tex>. Перейдем к следущему шагу текущей фазыСледовательно, на котором после перехода по суффиксной ссылке в дерево будет добавлен суффикс вершину, помеченную путевой меткой <tex>ts[ij+1..j\ldots r]</tex> соответствующий вершине , можно дойти до места, которому соответствует метка <tex>us[r+1 \ldots i-1]</tex> (возможно до продления суффикс оканчивался , сравнивая не символы на ребрерёбрах, но в этом случае а лишь длину ребра по рассуждениям аналогичным [[#l1|Лемме 1]] будет создана новая внутрення вершина)первому символу рассматриваемой части подстроки и длину самой этой подстроки. По определению суффиксная ссылка из вершины <tex>v</tex> ведет в <tex>u</tex>Таким образом можно спускаться вниз сразу на целое ребро.

=== Использование Построение суффиксных ссылок ===

Опишем как искать концы суффиксов в деревеЛегко увидеть, которые нужно продлить. Пусть мы только что продлили суффикс <tex>t[iв процессе построения суффиксного дерева уже построенные суффиксные ссылки никак не изменяются.Поэтому осталось сказать, как построить суффиксные ссылки для созданных вершин.j]Рассмотрим новую внутреннюю вершину </tex>. Найдем с помощью построенных ссылок конец суффикса <tex>t[i+1..j]v</tex>. Пройдем вверх по дереву от конца , которая была создана в результате продления суффикса <tex>ts[i..j]</tex> до ближайшей внутренней вершины <tex>v</tex>. Ей соответствует некоторая подстрока <tex>t[\ldots i..k-1]</tex>. У Вместо того, чтобы искать, куда должна указывать суффиксная ссылка вершины <tex>v</tex> есть суффиксная ссылка, так как ссылка поднимаясь от корня дерева для новой внутренней вершины строится внутри фазы ее создания. Пусть суффиксная ссылка ведет в вершину <tex>u</tex>этого, которой соответствует подстрока перейдем к продлению следующего суффикса <tex>ts[j+1 \ldots i+-1..k]</tex>. Теперь пройдем от И в этот момент можно проставить суффиксную ссылку для вершины <tex>uv</tex> пройдем вниз по дереву. Она будет указывать либо на существующую вершину, если следующий суффикс закончился в ней, читая текст <tex>t[k+1либо на новую созданную.То есть суффиксные ссылки будут обновляться с запаздыванием.j]</tex>Внимательно посмотрев на все три правила продления суффиксов, можно осознать, и придем к концу суффикса что для вершины <tex>t[i+1..j]v </tex>точно найдётся на следующей фазе внутренняя вершина, в которую должна вести суффиксная ссылка.

==== Оценка числа переходов ====

|definition= '''Глубиной вершины''' <tex>d(v)</tex> назовем число ребер рёбер на пути от корня до вершины <tex>v</tex>.}}

Пусть мы переходим из вершины [[Файл:ExampleUkkonen8.png|200px|center|]] Заметим, что на пути <tex> v A</tex> с путевой меткой в дереве по суффиксу <tex>ts[j+1 \ldots i..j]</tex> по суффиксной ссылке в не более чем на одну вершину меньше, чем на пути <tex> u B</tex> с путевой меткой по суффиксу <tex>ts[j \ldots i+1..j]</tex> Определим множество . Каждой вершине <tex> A v</tex> как множество вершин на пути от корня до <tex> u B</tex>, исключая корень. Множество соответствует вершина <tex> B u</tex> определим как множество вершин на пути от корня до <tex> v A</tex>, исключая кореньв которую ведёт суффиксная ссылка. Если длина первого ребра на пути от корня до <tex> v </tex> равна единице, то выкинем из множества <tex>B</tex> Разница в одну вершинувозникает, если первому ребру в которую ведет это ребро. Итого по построению получаем: пути <tex>|A| = d(u)B</tex>, соответсвует метка из одного символа <tex>|B| \ge d(v) - 1s_{j}</tex>. Теперь заметим, что тогда суффиксная ссылка из любой вершины множества <tex>B</tex> ведет , в некоторую вершину множества <tex> A</tex>которую ведёт это ребро, и очевидно суффиксные ссылки из разных вершин ведут будет вести в разные вершины, поэтому <tex>|A| \ge |B|</tex>, а значит <tex>d(u) \ge d(v) - 1</tex>корень.

Число переходов по ребрам внутри фазы номер Если в какой-то момент работы алгоритма Укконена будет создан лист с меткой <tex>i</tex> не превышает (для суффикса, начинающегося в позиции <tex>4ii</tex> строки <tex>S</tex>), он останется листом во всех последовательных деревьях, созданных алгоритмом. <br>

Оценим количество переходов по ребрам при поиске конца суффиксаЭто верно потому, что у алгоритма нет механизма продолжения листового ребра дальше текущего листа. Переход до ближайшей внутренней вершины уменьшает высоту на Если есть лист с суффиксом <tex>1i</tex>. Переход по суффиксной ссылке уменьшает высоту не более чем на <tex>, правило продолжения 1</tex> (по [[#l4|Лемме 4]]). Значит в течение одной фазы вверх мы переходим не более будет применяться для продолжения <tex> 2i i</tex> разна всех последующих фазах. Но внутри одной фазы начальная глубина не меньше конечной (так как длины суффиксов убывают до <tex>1</tex>), поэтому вниз мы могли пройти не более <tex> 2i </tex> ребер. Итого получаем оценку <tex> 4i </tex>

{{Лемма|id=l2|about= Псевдокод ==Правило 3 заканчивает дело<code style |statement= "display: inline-block;"> string s int n struct node int lВ любой фазе, rесли правило продления 3 применяется в продолжении суффикса, par, link mapначинающего в позиции <tex>j<char,int/tex> next node (int l=0, int r=0, int par=-1) : l(l), rоно же и будет применяться во всех дальнейших продолжениях (r), par(par), link(-от <tex>j+1</tex> по <tex>i</tex>) {} int len() return r - l int &get (char c) if !nextдо конца фазы.count(c) next[c] |proof= -1 return next[c] node t[MAXN] int sz struct state int v, pos state (int v, int pos) : v(v), pos(pos) {} state ptr (0При использовании правила продолжения 3 путь, 0) state go (state st, int l, int r) while l помеченный < r if st.pos == t[st.v].len() st = state (t[st.v].get( tex>s[l] ), 0); if st.v == j \ldots i-1 return st else if s[ t[st.v].l + st.pos ] != s[l] return state (-1</tex> в текущем дереве, -1) if r-l должен продолжаться символом <tex>i< t[st.v].len() - st.pos return state (st.v/tex>, st.pos + r-l) l += t[st.v].len() - st.pos st.pos = t[st.v].len() return st int split (state st) if st.pos == t[st.v].len() return st.v if st.pos == 0 return t[st.v].par node v = t[st.v] int id = sz++ t[id] = node (v.lи точно так же продолжается путь, v.l+st.pos, v.par) t[v.par].get( s[v.l] ) = id t[id].get( помеченный <tex>s[v.lj+st.pos] ) = st.v t[st.v].par = id t[st.v].l += st.pos return id int get_link (int v) if t[v].link != -1 return t[v].link if t[v].par == \ldots i-1 return 0 int to = get_link (t[v].par) return t[v].link = split (go (state(to</tex>,t[to].len())поэтому правило 3 применяется в продолжениях <tex>j+1, t[v].l \ j+ (t[v].par==0)2, \ldots, t[v]i</tex>.r)) }} void tree_extend (int pos) for(;;) state nptr = go (ptrКогда используется 3-е правило продления суффикса, posникакой работы делать не нужно, pos+1) if nptrтак как требуемый суффикс уже в дереве есть. Поэтому можно заканчивать текущую итерацию после первого же использования этого правила.v != -1 ptr = nptr return int mid = split (ptr) int leaf = sz++ tТак как лист навсегда останется листом, можно задать метку ребра ведущего в этот лист как <tex>s[leafj \ldots x] = node (pos</tex>, nгде <tex>x</tex> {{---}} ссылка на переменную, mid) t[mid]хранящую конец текущей подстроки.getНа следующих итерациях к этому ребру может применяться правило ответвления, но при этом будет меняться только левый( s[pos] начальный) = leaf ptrиндекс <tex>j</tex>.v = get_link Таким образом мы сможем удлинять все суффиксы, заканчивающиеся в листах за <tex>O(mid) ptr.pos = t[ptr.v].len() if !mid break void build_tree() sz = 1 for (int i=0; i<n; ++i) tree_extend (i)</codetex>.

Следовательно, на каждой фазе <tex>i</tex> алгоритм реально работает с суффиксами в диапазоне от <tex>j^*</tex> до <tex>k,\ k \leqslant i</tex>, а не от <tex>1</tex> до <tex>i</tex>. Действительно, если суффикс <tex>s[j \ldots i-2]</tex> был продлён до суффикса <tex>s[j \ldots i-1]</tex> на прошлой фазе по правилу 1, то он и дальше будет продлеваться по правилу 1 (о чём говорит [[#l1 | лемма]]). Если он был продлён по правилу 2, то была создана новая листовая вершина, значит, на текущей фазе <tex> i </tex> этот суффикс будет продлён до суффикса <tex>s[j \ldots i]</tex> по листовой вершине. Поэтому после применения правила 3 на суффиксе <tex>s[k \ldots i]</tex> текущую фазу можно завершить, а следующую начать сразу с <tex>j^* == Итоговая линейная оценка ==k</tex>.

Оценим время === Итоговая оценка времени работы алгоритма при использовании всех вышеперечисленных эвристик.===

Все неявные продления листов суммарно можно выполнить за В течение работы алгоритма создается не более <tex>O(n)</tex> (вершин по [[Сжатое_суффиксное_дерево#l1Количество_вершин |по Лемме 1лемме о размере суффиксного дерева для строки]]). Все суффиксы, которые заканчиваются в листах, благодаря [[#l2l1|По Лемме 2первой лемме]] алгоритм делает на каждой итерации мы увеличиваем на текущий символ по умолчанию за <tex>O(1)</tex>. Текущая фаза алгоритма будет продолжаться, пока не более будет использовано правило продления 3. Сначала неявно продлятся все листовые суффиксы, а потом по правилам 2.а) и 2.б) будет создано несколько новых внутренних вершин. Так как вершин не может быть создано больше, чем их есть, то амортизационно на каждой фазе будет создано <tex>2nO(1)</tex> явных продленийвершин. При использовании суффиксных ссылокТак как мы на каждой фазе начинаем добавление суффикса не с корня, как показано а с индекса <tex>j*</tex>, на котором в прошлой фазе было применено правило 3, то используя немного модифицированный вариант [[#l5|Лемме 5леммы о числе переходов внутри фазы]] время на продление равно константе плюс время пропорциональное числу ребернетрудно показать, пройденных при спуске что суммарное число переходов по деревурёбрам за все <tex>n</tex> фаз равно <tex>O(n)</tex>.

Оценим суммарное число таких переходов по ребрамТаким образом, при использовании всех приведённых эвристик алгоритм Укконена работает за <tex>O(n)</tex>.

Первое явное продолжение == Минусы алгоритма Укконена ==Несмотря на то, что данный алгоритм является одним из самых простых в любой фазе понимании алгоритмов для построения суффиксных деревьев и использует online подход, у него есть серьёзные недостатки, из-за которых его нечасто используют на практике:# Размер суффиксного дерева сильно превосходит входные данные, поэтому при очень больших входных данных алгоритм Укконена сталкивается с проблемой ''memory bottleneck problem''(кроме первойдругое её название ''thrashing'') начинается с продолжения, которое было последним явным в предыдущей фазе<ref>[http://dspace.library.uvic.ca:8080/bitstream/handle/1828/2901/ThesisBarsky16july.pdf?sequence=1 Marina Barsky {{---}} Suffix trees for very large inputs. Поэтому текущаю вершинная глубина не изменяется при переходе к следущей фазе]</ref>. Как было показано в # Для несложных задач, таких как поиск подстроки, проще и эффективней использовать другие алгоритмы (например поиск подстроки с помощью [[#l5Префикс-функция |Лемме 5префикс-функции]]).# При внимательном просмотре видно, каждое продление представляет собой переход не более чем что на самом деле алгоритм работает за время <tex>2O(n \cdot |\Sigma|)</tex> единицы глубины вверх, а затем несколько переходов внизиспользуя столько же памяти, каждый из которых увеличивает глубину так как для ответа на запрос о существовании перехода по текущему символу за <tex>O(1)</tex>необходимо хранить линейное количество информации от размера алфавита в каждой вершине. Поэтому, если алфавит очень большой требуется чрезмерный объём памяти. Так как максимальная глубина не превосходит Можно сэкономить на памяти, храня в каждой вершине только те символы, по которым из неё есть переходы, но тогда поиск перехода будет занимать <tex>nO(\log |\Sigma|)</tex>времени.# Константное время на одну итерацию {{---}} это амортизированная оценка, а количество явных продлений не превышает в худшем случае одна фаза может выполняться за <tex>2nO(n)</tex>времени. Например, то по рассуждениям аналогичным [алгоритм Дэни Бреслауера и Джузеппе Итальяно<ref>[https://books.google.ru/books?id=sGDXz53FwM4C&lpg=PP11&ots=utJ8jnql5h&dq=Dany%20Breslauer%2C%20Giuseppe%20F.%20Italiano%3A%20Near%20Real-Time%20Suffix%20Tree%20Construction%20via%20the%20Fringe%20Marked%20Ancestor%20Problem.&hl=ru&pg=PA156#l5|Лемме 5v=onepage&q&f=false Dany Breslauer, Giuseppe F. Italiano {{---}} Near Real-Time Suffix Tree Construction via the Fringe Marked Ancestor Problem.]] суммарное число таких переходов имеет порядок </ref>, хоть и строит дерево за <tex>O(n \log \log n)</tex>, но на одну итерацию в худшем случае тратит <tex>O(\log \log n)</tex>времени.# На сегодняшний день существуют кэш-эффективные алгоритмы, превосходящие алгоритм Укконена на современных процессорах<ref>[https://www.google.ru/url?sa=t&rct=j&q=&esrc=s&source=web&cd=6&ved=0CFMQFjAF&url=http%3A%2F%2Fwww.researchgate.net%2Fprofile%2FYuanyuan_Tian%2Fpublication%2F30848628_Practical_methods_for_constructing_suffix_trees%2Flinks%2F0046352b38e5dc849e000000.pdf&ei=Bh4sVZL8EIausAHujoDoBg&usg=AFQjCNEAr63t7zZnWZPKYIZLjQQInbelSg&sig2=jAPs1IULJvJZt8xwx5PYtA&bvm=bv.90491159,d.bGg&cad=rja Yuanyuan Tian, Sandeep Tata, Richard A. Hankins, Jignesh M. Patel {{---}} Practical methods for constructing suffix trees.]</ref>.# Также алгоритм предполагает, что дерево полностью должно быть загружено в оперативную память. Если же требуется работать с большими размерами данных, то становится не так тривиально модифицировать алгоритм, чтобы он не хранил всё дерево в ней<ref>[http://arxiv.org/pdf/1012.4074.pdf Woong-Kee Loh, Yang-Sae Moon, Wookey Lee {{---}} A fast divide-and-conquer algorithm for indexing human genome sequences.]</ref>.

* [[Алгоритм Фарача| Алгоритм Фараx-Колтона]]* [[Суффиксный бор]] ==Примечания== <references />

== Источники информации ==

* [http://habrahabr.ru/post/111675/ Habrahabr — {{---}} Построение суффиксного дерева: алгоритм Укконена]