Викиконспекты - Вклад участника [ru]

Анализ свойств регулярных языков (пустота, совпадение, включение, конечность, подсчёт числа слов)

2015-11-02T18:48:41Z

Nastyastanchul:

Для различных операций с [[Регулярные языки: два определения и их эквивалентность|регулярными языками]] (англ. ''regular language'') полезно знать некоторые их свойства. Как правило, в доказательствах этих свойств используется факт из теоремы Клини об эквивалентности [[Детерминированные_конечные_автоматы#Автоматные_языки | автоматных]] и [[Регулярные языки:_два определения_и_их_эквивалентность#REG1 | регулярных]] языков.

== Пустота регулярного языка ==

{{Определение
|id=empty
|definition=
[[Регулярные языки: два определения и их эквивалентность|Регулярный язык]] называется '''пустым''' (англ ''empty''), если он не содержит ни одного слова.
}}

Язык, содержащий хотя бы одно слово, назовём '''непустым'''.

{{Теорема
|id=
regEmpty
|statement=
Регулярный язык является непустым тогда и только тогда, когда в любом задающем его автомате существует путь из стартового состояния в какое-либо из терминальных.

|proof=
<tex>\Rightarrow</tex>

Пусть язык содержит слово <tex>w</tex>. Любой [[Детерминированные конечные автоматы| детерминированный конечный автомат]] <tex>A</tex>, задающий этот язык, должен допускать <tex>w</tex>. Тогда при переходе из стартового состояния <tex>A</tex> по символам <tex>w</tex> получится путь, оканчивающийся в одном из терминальных состояний.

<tex>\Leftarrow</tex>
Пусть в автомате существует путь из стартового состояния в одно из допускающих. Рассмотрим последовательность символов на переходах, образующих этот путь. Строка из этой последовательности допускается автоматом, а значит, принадлежит языку.
}}

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

Для определения пустоты языка по соответствующему ему автомату проще всего использовать алгоритм [[Обход в глубину, цвета вершин|обхода в глубину]]. Язык не является пустым тогда и только тогда, когда при поиске из стартового состояния автомата окажется достижимой хотя бы одна терминальная вершина.

== Совпадение регулярных языков ==

{{Определение
|id=equal
|definition=
Два [[Регулярные языки: два определения и их эквивалентность|регулярных языка]] '''совпадают''', если любое слово или содержится в обоих языках, или не содержится ни в одном из них.
}}

Для проверки совпадения языков достаточно запустить алгоритм проверки [[Эквивалентность_состояний_ДКА|эквивалентности]] задающих их автоматов.

== Включение одного регулярного языка в другой ==

{{Определение
|id=inclusion
|definition=
[[Регулярные языки: два определения и их эквивалентность|Регулярный язык]] <tex>L_{1}</tex> '''входит (включается)''' в регулярный язык <tex>L_{2}</tex>, если любое слово, принадлежащее <tex>L_{1}</tex>, принадлежит <tex>L_{2}</tex>.
}}

Пусть автомат <tex>M_1</tex> задаёт язык <tex>L_1</tex>, а автомат <tex>M_2</tex> — язык <tex>L_1 \cap L_2</tex>. Для проверки включения <tex>L_1</tex> в <tex>L_2</tex> достаточно проверить [[Эквивалентность_состояний_ДКА|эквивалентность]] <tex>M_1</tex> и <tex>M_2</tex>.

== Конечность регулярного языка, подсчёт числа слов ==

{{Определение
|id=finite
|definition=
[[Регулярные языки: два определения и их эквивалентность|Регулярный язык]] называется '''конечным''', если принадлежащее ему множество слов конечно.
}}

{{Теорема
|id=
regFinite
|statement=
[[Детерминированные конечные автоматы|Детерминированный конечный автомат]] <tex>A_{1}</tex> задаёт конечный язык тогда и только тогда, когда в <tex>A_{1}</tex> не существует состояния <tex>v</tex>, для которого выполняются три условия:
* <tex>v</tex> достижимо из стартового состояния <tex>s</tex>;
* из <tex>v</tex> достижимо какое-либо из допускающих состояний;
* из <tex>v</tex> по одному или более переходам достижимо <tex>v</tex>.

|proof=
Пусть такое состояние <tex>v</tex> существует, а строки <tex>x, y, z</tex> таковы, что <tex>\langle s, xyz \rangle \vdash ^{*} \langle v, yz \rangle \vdash ^{*} \langle v, z \rangle \vdash ^{*} \langle t, \epsilon \rangle</tex>, <tex>t</tex> — допускающее, <tex>y</tex> — непустая. Рассмотрим строки вида <tex>xy^{k}z, k \in \mathbb{N}</tex>. Их бесконечное количество, и все они, как легко увидеть, допускаются автоматом. Значит, язык бесконечен.

Пусть такого состояния не существует. Тогда любой путь из стартового состояния в какое-либо из допускающих является простым. Количество слов в языке равно количеству таких путей; количество путей, в свою очередь, ограничено <tex>n! | \Sigma |^{n-1}</tex>, где <tex>n</tex> — количество состояний автомата: <tex>n!</tex> — количество перестановок состояний, <tex>| \Sigma |^{n-1}</tex> — количество совокупностей переходов по символам между ними. Таким образом, язык конечен.
}}

=== Алгоритм нахождения числа слов в языке ===

Доказанное утверждение позволяет свести задачу поиска числа слов в языке к поиску количества различных путей в ациклическом графе. Сначала с помощью [[Обход в глубину, цвета вершин|обхода в глубину]] по обратным рёбрам определим '''полезные''' состояния, из которых достижимо хотя бы одно допускающее. Затем найдём любой цикл, состояния которого полезны, достижимый из старта; при нахождении констатируем бесконечность языка. Пусть язык конечен; тогда отсортируем автомат [[Использование обхода в глубину для топологической сортировки|топологически]]. Введём функцию <tex>\mathrm{paths} (v)</tex>, задающую число различных путей из <tex>s</tex> в <tex>v</tex>; <tex>\mathrm{paths} (s) = 1</tex>. Заметим, что если известны значения <tex>\mathrm{paths} (u)</tex> для всех <tex>u</tex>, из которых существует переход в <tex>v</tex>, то <tex>\mathrm{paths} (v) = \sum\limits_{u}\mathrm{paths} (u)</tex>. Количеством слов в языке будет сумма <tex>\mathrm{paths} (t)</tex> для всех допускающих <tex>t</tex>.

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

* ''Хопкрофт Д., Мотвани Р., Ульман Д.'' Введение в теорию автоматов, языков и вычислений, 2-е изд. / Пер. с англ. — Москва: Издательский дом «Вильямс», 2002. — с. 169-177: ISBN 5-8459-0261-4 (рус.)

[[Категория: Теория формальных языков]]
[[Категория: Автоматы и регулярные языки]]

Анализ свойств регулярных языков (пустота, совпадение, включение, конечность, подсчёт числа слов)

2015-10-13T14:25:10Z

Nastyastanchul:

Для различных операций с [[Регулярные языки: два определения и их эквивалентность|регулярными языками]] (англ. ''regular language'') полезно знать некоторые их свойства. Как правило, в доказательствах этих свойств используется факт из теоремы Клини о эквивалентности [[Детерминированные_конечные_автоматы#Автоматные_языки | автоматных]] и [[Регулярные языки:_два определения_и_их_эквивалентность#REG1 | регулярных]] языков.

== Пустота регулярного языка ==

{{Определение
|id=empty
|definition=
[[Регулярные языки: два определения и их эквивалентность|Регулярный язык]] называется '''пустым''' (англ ''empty''), если он не содержит ни одного слова.
}}

Язык, содержащий хотя бы одно слово, назовём '''непустым'''.

{{Теорема
|id=
regEmpty
|statement=
Регулярный язык является непустым тогда и только тогда, когда в любом задающем его автомате существует путь из стартового состояния в какое-либо из терминальных.

|proof=
<tex>\Rightarrow</tex>

Пусть язык содержит слово <tex>w</tex>. Любой [[Детерминированные конечные автоматы| детерминированный конечный автомат]] <tex>A</tex>, задающий этот язык, должен допускать <tex>w</tex>. Тогда при переходе из стартового состояния <tex>A</tex> по символам <tex>w</tex> получится путь, оканчивающийся в одном из терминальных состояний.

<tex>\Leftarrow</tex>
Пусть в автомате существует путь из стартового состояния в одно из допускающих. Рассмотрим последовательность символов на переходах, образующих этот путь. Строка из этой последовательности допускается автоматом, а значит, принадлежит языку.
}}

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

Для определения пустоты языка по соответствующему ему автомату проще всего использовать алгоритм [[Обход в глубину, цвета вершин|обхода в глубину]]. Язык не является пустым тогда и только тогда, когда при поиске из стартового состояния автомата окажется достижимой хотя бы одна терминальная вершина.

== Совпадение регулярных языков ==

{{Определение
|id=equal
|definition=
Два [[Регулярные языки: два определения и их эквивалентность|регулярных языка]] '''совпадают''', если любое слово или содержится в обоих языках, или не содержится ни в одном из них.
}}

Для проверки совпадения языков достаточно запустить алгоритм проверки [[Эквивалентность_состояний_ДКА|эквивалентности]] задающих их автоматов.

== Включение одного регулярного языка в другой ==

{{Определение
|id=inclusion
|definition=
[[Регулярные языки: два определения и их эквивалентность|Регулярный язык]] <tex>L_{1}</tex> '''входит (включается)''' в регулярный язык <tex>L_{2}</tex>, если любое слово, принадлежащее <tex>L_{1}</tex>, принадлежит <tex>L_{2}</tex>.
}}

Пусть автомат <tex>M_1</tex> задаёт язык <tex>L_1</tex>, а автомат <tex>M_2</tex> — язык <tex>L_1 \cap L_2</tex>. Для проверки включения <tex>L_1</tex> в <tex>L_2</tex> достаточно проверить [[Эквивалентность_состояний_ДКА|эквивалентность]] <tex>M_1</tex> и <tex>M_2</tex>.

== Конечность регулярного языка, подсчёт числа слов ==

{{Определение
|id=finite
|definition=
[[Регулярные языки: два определения и их эквивалентность|Регулярный язык]] называется '''конечным''', если принадлежащее ему множество слов конечно.
}}

{{Теорема
|id=
regFinite
|statement=
[[Детерминированные конечные автоматы|Детерминированный конечный автомат]] <tex>A_{1}</tex> задаёт конечный язык тогда и только тогда, когда в <tex>A_{1}</tex> не существует состояния <tex>v</tex>, для которого выполняются три условия:
* <tex>v</tex> достижимо из стартового состояния <tex>s</tex>;
* из <tex>v</tex> достижимо какое-либо из допускающих состояний;
* из <tex>v</tex> по одному или более переходам достижимо <tex>v</tex>.

|proof=
Пусть такое состояние <tex>v</tex> существует, а строки <tex>x, y, z</tex> таковы, что <tex>\langle s, xyz \rangle \vdash ^{*} \langle v, yz \rangle \vdash ^{*} \langle v, z \rangle \vdash ^{*} \langle t, \epsilon \rangle</tex>, <tex>t</tex> — допускающее, <tex>y</tex> — непустая. Рассмотрим строки вида <tex>xy^{k}z, k \in \mathbb{N}</tex>. Их бесконечное количество, и все они, как легко увидеть, допускаются автоматом. Значит, язык бесконечен.

Пусть такого состояния не существует. Тогда любой путь из стартового состояния в какое-либо из допускающих является простым. Количество слов в языке равно количеству таких путей; количество путей, в свою очередь, ограничено <tex>n! | \Sigma |^{n-1}</tex>, где <tex>n</tex> — количество состояний автомата: <tex>n!</tex> — количество перестановок состояний, <tex>| \Sigma |^{n-1}</tex> — количество совокупностей переходов по символам между ними. Таким образом, язык конечен.
}}

=== Алгоритм нахождения числа слов в языке ===

Доказанное утверждение позволяет свести задачу поиска числа слов в языке к поиску количества различных путей в ациклическом графе. Сначала с помощью [[Обход в глубину, цвета вершин|обхода в глубину]] по обратным рёбрам определим '''полезные''' состояния, из которых достижимо хотя бы одно допускающее. Затем найдём любой цикл, состояния которого полезны, достижимый из старта; при нахождении констатируем бесконечность языка. Пусть язык конечен; тогда отсортируем автомат [[Использование обхода в глубину для топологической сортировки|топологически]]. Введём функцию <tex>\mathrm{paths} (v)</tex>, задающую число различных путей из <tex>s</tex> в <tex>v</tex>; <tex>\mathrm{paths} (s) = 1</tex>. Заметим, что если известны значения <tex>\mathrm{paths} (u)</tex> для всех <tex>u</tex>, из которых существует переход в <tex>v</tex>, то <tex>\mathrm{paths} (v) = \sum\limits_{u}\mathrm{paths} (u)</tex>. Количеством слов в языке будет сумма <tex>\mathrm{paths} (t)</tex> для всех допускающих <tex>t</tex>.

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

* ''Хопкрофт Д., Мотвани Р., Ульман Д.'' Введение в теорию автоматов, языков и вычислений, 2-е изд. / Пер. с англ. — Москва: Издательский дом «Вильямс», 2002. — с. 169-177: ISBN 5-8459-0261-4 (рус.)

[[Категория: Теория формальных языков]]
[[Категория: Автоматы и регулярные языки]]

Анализ свойств регулярных языков (пустота, совпадение, включение, конечность, подсчёт числа слов)

2015-10-13T14:23:55Z

Nastyastanchul:

Для различных операций с [[Регулярные языки: два определения и их эквивалентность|регулярными языками]] (англ. ''regular language'') полезно знать некоторые их свойства. Как правило, в доказательствах этих свойств используется факт эквивалентности [[Детерминированные_конечные_автоматы#Автоматные_языки | автоматных]] и [[Регулярные языки:_два определения_и_их_эквивалентность#REG1 | регулярных]] языков.

== Пустота регулярного языка ==

{{Определение
|id=empty
|definition=
[[Регулярные языки: два определения и их эквивалентность|Регулярный язык]] называется '''пустым''' (англ ''empty''), если он не содержит ни одного слова.
}}

Язык, содержащий хотя бы одно слово, назовём '''непустым'''.

{{Теорема
|id=
regEmpty
|statement=
Регулярный язык является непустым тогда и только тогда, когда в любом задающем его автомате существует путь из стартового состояния в какое-либо из терминальных.

|proof=
<tex>\Rightarrow</tex>

Пусть язык содержит слово <tex>w</tex>. Любой [[Детерминированные конечные автоматы| детерминированный конечный автомат]] <tex>A</tex>, задающий этот язык, должен допускать <tex>w</tex>. Тогда при переходе из стартового состояния <tex>A</tex> по символам <tex>w</tex> получится путь, оканчивающийся в одном из терминальных состояний.

<tex>\Leftarrow</tex>
Пусть в автомате существует путь из стартового состояния в одно из допускающих. Рассмотрим последовательность символов на переходах, образующих этот путь. Строка из этой последовательности допускается автоматом, а значит, принадлежит языку.
}}

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

Для определения пустоты языка по соответствующему ему автомату проще всего использовать алгоритм [[Обход в глубину, цвета вершин|обхода в глубину]]. Язык не является пустым тогда и только тогда, когда при поиске из стартового состояния автомата окажется достижимой хотя бы одна терминальная вершина.

== Совпадение регулярных языков ==

{{Определение
|id=equal
|definition=
Два [[Регулярные языки: два определения и их эквивалентность|регулярных языка]] '''совпадают''', если любое слово или содержится в обоих языках, или не содержится ни в одном из них.
}}

Для проверки совпадения языков достаточно запустить алгоритм проверки [[Эквивалентность_состояний_ДКА|эквивалентности]] задающих их автоматов.

== Включение одного регулярного языка в другой ==

{{Определение
|id=inclusion
|definition=
[[Регулярные языки: два определения и их эквивалентность|Регулярный язык]] <tex>L_{1}</tex> '''входит (включается)''' в регулярный язык <tex>L_{2}</tex>, если любое слово, принадлежащее <tex>L_{1}</tex>, принадлежит <tex>L_{2}</tex>.
}}

Пусть автомат <tex>M_1</tex> задаёт язык <tex>L_1</tex>, а автомат <tex>M_2</tex> — язык <tex>L_1 \cap L_2</tex>. Для проверки включения <tex>L_1</tex> в <tex>L_2</tex> достаточно проверить [[Эквивалентность_состояний_ДКА|эквивалентность]] <tex>M_1</tex> и <tex>M_2</tex>.

== Конечность регулярного языка, подсчёт числа слов ==

{{Определение
|id=finite
|definition=
[[Регулярные языки: два определения и их эквивалентность|Регулярный язык]] называется '''конечным''', если принадлежащее ему множество слов конечно.
}}

{{Теорема
|id=
regFinite
|statement=
[[Детерминированные конечные автоматы|Детерминированный конечный автомат]] <tex>A_{1}</tex> задаёт конечный язык тогда и только тогда, когда в <tex>A_{1}</tex> не существует состояния <tex>v</tex>, для которого выполняются три условия:
* <tex>v</tex> достижимо из стартового состояния <tex>s</tex>;
* из <tex>v</tex> достижимо какое-либо из допускающих состояний;
* из <tex>v</tex> по одному или более переходам достижимо <tex>v</tex>.

|proof=
Пусть такое состояние <tex>v</tex> существует, а строки <tex>x, y, z</tex> таковы, что <tex>\langle s, xyz \rangle \vdash ^{*} \langle v, yz \rangle \vdash ^{*} \langle v, z \rangle \vdash ^{*} \langle t, \epsilon \rangle</tex>, <tex>t</tex> — допускающее, <tex>y</tex> — непустая. Рассмотрим строки вида <tex>xy^{k}z, k \in \mathbb{N}</tex>. Их бесконечное количество, и все они, как легко увидеть, допускаются автоматом. Значит, язык бесконечен.

Пусть такого состояния не существует. Тогда любой путь из стартового состояния в какое-либо из допускающих является простым. Количество слов в языке равно количеству таких путей; количество путей, в свою очередь, ограничено <tex>n! | \Sigma |^{n-1}</tex>, где <tex>n</tex> — количество состояний автомата: <tex>n!</tex> — количество перестановок состояний, <tex>| \Sigma |^{n-1}</tex> — количество совокупностей переходов по символам между ними. Таким образом, язык конечен.
}}

=== Алгоритм нахождения числа слов в языке ===

Доказанное утверждение позволяет свести задачу поиска числа слов в языке к поиску количества различных путей в ациклическом графе. Сначала с помощью [[Обход в глубину, цвета вершин|обхода в глубину]] по обратным рёбрам определим '''полезные''' состояния, из которых достижимо хотя бы одно допускающее. Затем найдём любой цикл, состояния которого полезны, достижимый из старта; при нахождении констатируем бесконечность языка. Пусть язык конечен; тогда отсортируем автомат [[Использование обхода в глубину для топологической сортировки|топологически]]. Введём функцию <tex>\mathrm{paths} (v)</tex>, задающую число различных путей из <tex>s</tex> в <tex>v</tex>; <tex>\mathrm{paths} (s) = 1</tex>. Заметим, что если известны значения <tex>\mathrm{paths} (u)</tex> для всех <tex>u</tex>, из которых существует переход в <tex>v</tex>, то <tex>\mathrm{paths} (v) = \sum\limits_{u}\mathrm{paths} (u)</tex>. Количеством слов в языке будет сумма <tex>\mathrm{paths} (t)</tex> для всех допускающих <tex>t</tex>.

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

* ''Хопкрофт Д., Мотвани Р., Ульман Д.'' Введение в теорию автоматов, языков и вычислений, 2-е изд. / Пер. с англ. — Москва: Издательский дом «Вильямс», 2002. — с. 169-177: ISBN 5-8459-0261-4 (рус.)

[[Категория: Теория формальных языков]]
[[Категория: Автоматы и регулярные языки]]

Анализ свойств регулярных языков (пустота, совпадение, включение, конечность, подсчёт числа слов)

2015-10-13T07:05:46Z

Nastyastanchul: /* Литература */

Для различных операций с [[Регулярные языки: два определения и их эквивалентность|регулярными языками]] полезно знать некоторые их свойства. Как правило, в доказательствах этих свойств используется факт эквивалентности автоматных и регулярных языков.

== Пустота регулярного языка ==

{{Определение
|id=empty
|definition=
[[Регулярные языки: два определения и их эквивалентность|Регулярный язык]] называется '''пустым''', если он не содержит ни одного слова.
}}

Язык, содержащий хотя бы одно слово, назовём '''непустым'''.

{{Теорема
|id=
regEmpty
|statement=
Регулярный язык является непустым тогда и только тогда, когда в любом задающем его автомате существует путь из стартового состояния в какое-либо из терминальных.

|proof=
<tex>\Rightarrow</tex>

Пусть язык содержит слово <tex>w</tex>. Любой [[Детерминированные конечные автоматы| детерминированный конечный автомат]] <tex>A</tex>, задающий этот язык, должен допускать <tex>w</tex>. Тогда при переходе из стартового состояния <tex>A</tex> по символам <tex>w</tex> получится путь, оканчивающийся в одном из терминальных состояний.

<tex>\Leftarrow</tex>
Пусть в автомате существует путь из стартового состояния в одно из допускающих. Рассмотрим последовательность символов на переходах, образующих этот путь. Строка из этой последовательности допускается автоматом, а значит, принадлежит языку.
}}

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

Для определения пустоты языка по соответствующему ему автомату проще всего использовать алгоритм [[Обход в глубину, цвета вершин|обхода в глубину]]. Язык не является пустым тогда и только тогда, когда при поиске из стартового состояния автомата окажется достижимой хотя бы одна терминальная вершина.

== Совпадение регулярных языков ==

{{Определение
|id=equal
|definition=
Два [[Регулярные языки: два определения и их эквивалентность|регулярных языка]] '''совпадают''', если любое слово или содержится в обоих языках, или не содержится ни в одном из них.
}}

Для проверки совпадения языков достаточно запустить алгоритм проверки [[Эквивалентность_состояний_ДКА|эквивалентности]] задающих их автоматов.

== Включение одного регулярного языка в другой ==

{{Определение
|id=inclusion
|definition=
[[Регулярные языки: два определения и их эквивалентность|Регулярный язык]] <tex>L_{1}</tex> '''входит (включается)''' в регулярный язык <tex>L_{2}</tex>, если любое слово, принадлежащее <tex>L_{1}</tex>, принадлежит <tex>L_{2}</tex>.
}}

Пусть автомат <tex>M_1</tex> задаёт язык <tex>L_1</tex>, а автомат <tex>M_2</tex> — язык <tex>L_1 \cap L_2</tex>. Для проверки включения <tex>L_1</tex> в <tex>L_2</tex> достаточно проверить [[Эквивалентность_состояний_ДКА|эквивалентность]] <tex>M_1</tex> и <tex>M_2</tex>.

== Конечность регулярного языка, подсчёт числа слов ==

{{Определение
|id=finite
|definition=
[[Регулярные языки: два определения и их эквивалентность|Регулярный язык]] называется '''конечным''', если принадлежащее ему множество слов конечно.
}}

{{Теорема
|id=
regFinite
|statement=
[[Детерминированные конечные автоматы|Детерминированный конечный автомат]] <tex>A_{1}</tex> задаёт конечный язык тогда и только тогда, когда в <tex>A_{1}</tex> не существует состояния <tex>v</tex>, для которого выполняются три условия:
* <tex>v</tex> достижимо из стартового состояния <tex>s</tex>;
* из <tex>v</tex> достижимо какое-либо из допускающих состояний;
* из <tex>v</tex> по одному или более переходам достижимо <tex>v</tex>.

|proof=
Пусть такое состояние <tex>v</tex> существует, а строки <tex>x, y, z</tex> таковы, что <tex>\langle s, xyz \rangle \vdash ^{*} \langle v, yz \rangle \vdash ^{*} \langle v, z \rangle \vdash ^{*} \langle t, \epsilon \rangle</tex>, <tex>t</tex> — допускающее, <tex>y</tex> — непустая. Рассмотрим строки вида <tex>xy^{k}z, k \in \mathbb{N}</tex>. Их бесконечное количество, и все они, как легко увидеть, допускаются автоматом. Значит, язык бесконечен.

Пусть такого состояния не существует. Тогда любой путь из стартового состояния в какое-либо из допускающих является простым. Количество слов в языке равно количеству таких путей; количество путей, в свою очередь, ограничено <tex>n! | \Sigma |^{n-1}</tex>, где <tex>n</tex> — количество состояний автомата: <tex>n!</tex> — количество перестановок состояний, <tex>| \Sigma |^{n-1}</tex> — количество совокупностей переходов по символам между ними. Таким образом, язык конечен.
}}

=== Алгоритм нахождения числа слов в языке ===

Доказанное утверждение позволяет свести задачу поиска числа слов в языке к поиску количества различных путей в ациклическом графе. Сначала с помощью [[Обход в глубину, цвета вершин|обхода в глубину]] по обратным рёбрам определим '''полезные''' состояния, из которых достижимо хотя бы одно допускающее. Затем найдём любой цикл, состояния которого полезны, достижимый из старта; при нахождении констатируем бесконечность языка. Пусть язык конечен; тогда отсортируем автомат [[Использование обхода в глубину для топологической сортировки|топологически]]. Введём функцию <tex>\mathrm{paths} (v)</tex>, задающую число различных путей из <tex>s</tex> в <tex>v</tex>; <tex>\mathrm{paths} (s) = 1</tex>. Заметим, что если известны значения <tex>\mathrm{paths} (u)</tex> для всех <tex>u</tex>, из которых существует переход в <tex>v</tex>, то <tex>\mathrm{paths} (v) = \sum\limits_{u}\mathrm{paths} (u)</tex>. Количеством слов в языке будет сумма <tex>\mathrm{paths} (t)</tex> для всех допускающих <tex>t</tex>.

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

* ''Хопкрофт Д., Мотвани Р., Ульман Д.'' Введение в теорию автоматов, языков и вычислений, 2-е изд. / Пер. с англ. — Москва: Издательский дом «Вильямс», 2002. — с. 169-177: ISBN 5-8459-0261-4 (рус.)

[[Категория: Теория формальных языков]]
[[Категория: Автоматы и регулярные языки]]

Анализ свойств регулярных языков (пустота, совпадение, включение, конечность, подсчёт числа слов)

2015-10-13T07:03:01Z

Nastyastanchul:

Для различных операций с [[Регулярные языки: два определения и их эквивалентность|регулярными языками]] полезно знать некоторые их свойства. Как правило, в доказательствах этих свойств используется факт эквивалентности автоматных и регулярных языков.

== Пустота регулярного языка ==

{{Определение
|id=empty
|definition=
[[Регулярные языки: два определения и их эквивалентность|Регулярный язык]] называется '''пустым''', если он не содержит ни одного слова.
}}

Язык, содержащий хотя бы одно слово, назовём '''непустым'''.

{{Теорема
|id=
regEmpty
|statement=
Регулярный язык является непустым тогда и только тогда, когда в любом задающем его автомате существует путь из стартового состояния в какое-либо из терминальных.

|proof=
<tex>\Rightarrow</tex>

Пусть язык содержит слово <tex>w</tex>. Любой [[Детерминированные конечные автоматы| детерминированный конечный автомат]] <tex>A</tex>, задающий этот язык, должен допускать <tex>w</tex>. Тогда при переходе из стартового состояния <tex>A</tex> по символам <tex>w</tex> получится путь, оканчивающийся в одном из терминальных состояний.

<tex>\Leftarrow</tex>
Пусть в автомате существует путь из стартового состояния в одно из допускающих. Рассмотрим последовательность символов на переходах, образующих этот путь. Строка из этой последовательности допускается автоматом, а значит, принадлежит языку.
}}

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

Для определения пустоты языка по соответствующему ему автомату проще всего использовать алгоритм [[Обход в глубину, цвета вершин|обхода в глубину]]. Язык не является пустым тогда и только тогда, когда при поиске из стартового состояния автомата окажется достижимой хотя бы одна терминальная вершина.

== Совпадение регулярных языков ==

{{Определение
|id=equal
|definition=
Два [[Регулярные языки: два определения и их эквивалентность|регулярных языка]] '''совпадают''', если любое слово или содержится в обоих языках, или не содержится ни в одном из них.
}}

Для проверки совпадения языков достаточно запустить алгоритм проверки [[Эквивалентность_состояний_ДКА|эквивалентности]] задающих их автоматов.

== Включение одного регулярного языка в другой ==

{{Определение
|id=inclusion
|definition=
[[Регулярные языки: два определения и их эквивалентность|Регулярный язык]] <tex>L_{1}</tex> '''входит (включается)''' в регулярный язык <tex>L_{2}</tex>, если любое слово, принадлежащее <tex>L_{1}</tex>, принадлежит <tex>L_{2}</tex>.
}}

Пусть автомат <tex>M_1</tex> задаёт язык <tex>L_1</tex>, а автомат <tex>M_2</tex> — язык <tex>L_1 \cap L_2</tex>. Для проверки включения <tex>L_1</tex> в <tex>L_2</tex> достаточно проверить [[Эквивалентность_состояний_ДКА|эквивалентность]] <tex>M_1</tex> и <tex>M_2</tex>.

== Конечность регулярного языка, подсчёт числа слов ==

{{Определение
|id=finite
|definition=
[[Регулярные языки: два определения и их эквивалентность|Регулярный язык]] называется '''конечным''', если принадлежащее ему множество слов конечно.
}}

{{Теорема
|id=
regFinite
|statement=
[[Детерминированные конечные автоматы|Детерминированный конечный автомат]] <tex>A_{1}</tex> задаёт конечный язык тогда и только тогда, когда в <tex>A_{1}</tex> не существует состояния <tex>v</tex>, для которого выполняются три условия:
* <tex>v</tex> достижимо из стартового состояния <tex>s</tex>;
* из <tex>v</tex> достижимо какое-либо из допускающих состояний;
* из <tex>v</tex> по одному или более переходам достижимо <tex>v</tex>.

|proof=
Пусть такое состояние <tex>v</tex> существует, а строки <tex>x, y, z</tex> таковы, что <tex>\langle s, xyz \rangle \vdash ^{*} \langle v, yz \rangle \vdash ^{*} \langle v, z \rangle \vdash ^{*} \langle t, \epsilon \rangle</tex>, <tex>t</tex> — допускающее, <tex>y</tex> — непустая. Рассмотрим строки вида <tex>xy^{k}z, k \in \mathbb{N}</tex>. Их бесконечное количество, и все они, как легко увидеть, допускаются автоматом. Значит, язык бесконечен.

Пусть такого состояния не существует. Тогда любой путь из стартового состояния в какое-либо из допускающих является простым. Количество слов в языке равно количеству таких путей; количество путей, в свою очередь, ограничено <tex>n! | \Sigma |^{n-1}</tex>, где <tex>n</tex> — количество состояний автомата: <tex>n!</tex> — количество перестановок состояний, <tex>| \Sigma |^{n-1}</tex> — количество совокупностей переходов по символам между ними. Таким образом, язык конечен.
}}

=== Алгоритм нахождения числа слов в языке ===

Доказанное утверждение позволяет свести задачу поиска числа слов в языке к поиску количества различных путей в ациклическом графе. Сначала с помощью [[Обход в глубину, цвета вершин|обхода в глубину]] по обратным рёбрам определим '''полезные''' состояния, из которых достижимо хотя бы одно допускающее. Затем найдём любой цикл, состояния которого полезны, достижимый из старта; при нахождении констатируем бесконечность языка. Пусть язык конечен; тогда отсортируем автомат [[Использование обхода в глубину для топологической сортировки|топологически]]. Введём функцию <tex>\mathrm{paths} (v)</tex>, задающую число различных путей из <tex>s</tex> в <tex>v</tex>; <tex>\mathrm{paths} (s) = 1</tex>. Заметим, что если известны значения <tex>\mathrm{paths} (u)</tex> для всех <tex>u</tex>, из которых существует переход в <tex>v</tex>, то <tex>\mathrm{paths} (v) = \sum\limits_{u}\mathrm{paths} (u)</tex>. Количеством слов в языке будет сумма <tex>\mathrm{paths} (t)</tex> для всех допускающих <tex>t</tex>.

== Литература ==

* ''Хопкрофт Д., Мотвани Р., Ульман Д.'' Введение в теорию автоматов, языков и вычислений, 2-е изд. / Пер. с англ. — Москва: Издательский дом «Вильямс», 2002. — с. 169-177: ISBN 5-8459-0261-4 (рус.)

[[Категория: Теория формальных языков]]
[[Категория: Автоматы и регулярные языки]]

Сведение задачи RMQ к задаче LCA

2015-06-09T10:14:17Z

Nastyastanchul: /* Описание */

{{Шаблон:Задача
|definition =Дан массив <tex>A[1..N]</tex>. Поступают запросы вида <tex>(i, j)</tex>, на каждый запрос требуется найти минимум в массиве <tex>A</tex>, начиная с позиции <tex>i</tex> и заканчивая позицией <tex>j</tex>.
}}

== Алгоритм ==
===Описание===
[[Файл:Wiki.PNG|thumb|right|400x200px|Пример декартового дерева]]
Будем решать задачу RMQ, уже умея решать задачу LCA. Для хранения решения задачи о LCA будем использовать [[декартово дерево по неявному ключу]]. Тогда минимум на отрезке от <tex> i </tex> до <tex> j </tex> массива <tex> A </tex> будет равен наименьшему общему предку <tex>i</tex>-того и <tex>j</tex>-того элементов из декартова дерева построенного на массиве <tex> A </tex>.

Декартово дерево по неявному ключу на массиве <tex>A[1..N]</tex> {{---}} это бинарное дерево, допускающее следующее рекурсивное построение:
* Корнем дерева является элемент массива, имеющий минимальное значение <tex>A</tex>, скажем <tex>A[i]</tex>. Если минимальных элементов несколько, можно взять любой.
* Левым поддеревом является декартово дерево на массиве <tex>A[1..i-1]</tex>.
* Правым поддеревом является декартово дерево на массиве <tex>A[i+1..N]</tex>.

Здесь и далее <tex>A[i]</tex> будет также использоваться для обозначения соответствующей вершины дерева.

Построим декартово дерево на массиве <tex>A</tex>. Тогда <tex>RMQ(i, j)</tex> = <tex>LCA(A[i], A[j])</tex>.
<br clear="all">

=== Корректность ===
{{Теорема
|statement=
<tex>RMQ(i, j)</tex> = <tex>LCA(A[i], A[j])</tex>.
|proof=
Положим <tex>w = LCA(A[i], A[j])</tex>.

Заметим, что <tex>A[i]</tex> и <tex>A[j]</tex> не принадлежат одновременно либо правому, либо левому поддереву <tex>w</tex>, потому как тогда бы соответствующий сын находился на большей глубине, чем <tex>w</tex>, и также являлся предком как <tex>A[i]</tex> так и <tex>A[j]</tex>, что противоречит определению <tex>LCA</tex>. Из этого замечанию следует, что <tex>w</tex> лежит между <tex>A[i]</tex> и <tex>A[j]</tex> и, следовательно, принадлежит отрезку <tex>A[i..j]</tex>.

По построению мы также знаем, что:
# Любая вершина дерева имеет свое значение меньшим либо равным значению её детей.
# Поддерево с корнем в <tex>w</tex> содержит в себе подмассив <tex>A[i..j]</tex>.

Суммируя, получаем, что <tex>w</tex> имеет минимальное значение на отрезке, покрывающем <tex>A[i..j]</tex>, и принадлежит отрезку <tex>A[i..j]</tex>, отсюда <tex>RMQ(i, j) = w</tex>.
}}

=== Сложность ===
Существует [[Декартово дерево#Построение декартова дерева|алгоритм]], который строит декартово дерево за <tex>O(n)</tex>. Используя [[Сведение задачи LCA к задаче RMQ | алгоритм построения LCA]], получаем:
препроцессинг для <tex>LCA</tex> {{---}} <tex>O(n)</tex> и ответ на запрос {{---}} <tex>O(1)</tex>.

Нам нужно единожды построить декартово дерево за <tex>O(n)</tex>, единожды провести препроцессинг за <tex>O(n)</tex> и отвечать на запросы за <tex>O(1)</tex>.

В итоге получили <tex>RMQ</tex> с построением за <tex>O(n)</tex> и ответом на запрос за <tex>O(1)</tex>.

== См.также ==
*[[Сведение задачи LCA к задаче RMQ]]
*[[Декартово дерево]]
*[[Алгоритм Фарака-Колтона и Бендера]]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Сведение задачи LCA к задаче RMQ

2015-06-09T10:02:25Z

Nastyastanchul: /* Препроцессинг */

{{Шаблон:Задача
|definition =
Пусть дано корневое дерево <tex>T</tex>. На вход подаются запросы вида <tex>(u,\;v)</tex>, для каждого запроса требуется найти их наименьшего общего предка.
}}
{{Определение
|id=lca_suf_tree
|definition = '''Наименьшим общим предком''' (англ. ''least common ancestor'') двух узлов <tex>u</tex> и <tex>v</tex> в корневом дереве <tex>T</tex> называется узел <tex>w</tex>, который среди всех узлов, являющихся предками как узла <tex>u</tex>, так и <tex>v</tex>, имеет наибольшую глубину.
}}

== Алгоритм ==
=== Идея ===
Будем решать задачу <tex>LCA</tex>, уже умея решать задачу <tex>RMQ</tex>. Тогда поиск наименьшего общего предка <tex>i</tex>-того и <tex>j</tex>-того элементов сводится к запросу минимума на отрезке массива, который будет введен позднее.

=== Препроцессинг ===
Для каждой вершины <tex>T</tex> определим глубину с помощью следующей рекурсивной формулы:
:<tex>\mathrm{depth}(u) = \begin{cases}
0 & u = \mathrm{root}(T),\\
\mathrm{depth}(v) + 1 & u = \mathrm{son}(v).
\end{cases}</tex>
Ясно, что глубина вершины элементарным образом поддерживается во время обхода в глубину.

Запустим [[Обход в глубину, цвета вершин|обход в глубину]] из корня, который будет вычислять значения следующих величин:
#Cписок глубин посещенных вершин <tex>d</tex>. Глубина текущей вершины добавляется в конец списка при входе в данную вершину, а также после каждого возвращения из её сына.
#Список посещений узлов <tex>\mathtt{vtx}</tex>, строящийся аналогично предыдущему, только добавляется не глубина а сама вершина.
#Значение функции <tex>\mathtt{I}[u]</tex>, возвращающей индекс в списке глубин <tex>d</tex>, по которому была записана глубина вершины <tex>u</tex> (например на момент входа в вершину).

Вот таким образом будет выглядеть массив <tex>\mathtt{vtx}</tex> после обхода в глубину:

[[Файл:Полная персистентность.png‎ | мини | left | 500x300px| Пример массива <tex>\mathtt{vtx}</tex>]]
<br clear="all">

=== Запрос ===
Будем считать, что <tex>\mathrm{rmq}(d,l,r)</tex> возвращает индекс минимального элемента в <tex>d</tex> на отрезке <tex>[l..r]</tex>. Тогда ответом на запрос <tex>\mathrm{lca}(u, v)</tex>, где <tex>\mathtt{I}[u] \leqslant \mathtt{I}[v]</tex>, будет <tex>\mathtt{vtx}[\mathrm{rmq}(d,\mathtt{I}[u], \mathtt{I}[v])]</tex>.
=== Доказательство корректности алгоритма ===
{{Теорема
|statement=
Наименьшему общему предку вершин <tex>u, v</tex> соответствует минимальная глубина на отрезке <tex>d[\mathtt{I}[u], \mathtt{I}[v]]</tex>.
|proof=
Рассмотрим два узла <tex>u, v</tex> корневого дерева <tex>T</tex>. Рассмотрим отрезок <tex>d[\mathtt{I}[u]..\mathtt{I}[v]]</tex>. Поскольку этот отрезок {{---}} путь из <tex>u</tex> в <tex>v</tex>, он проходит через их наименьшего общего предка <tex>w</tex> (в дереве есть только один простой путь между вершинами), а следовательно минимум на отрезке никак не больше глубины <tex>w</tex>. Заметим, что в момент добавления <tex>\mathtt{I}[u]</tex> обход посещал поддерево с корнем <tex>w</tex>. В момент добавления <tex>\mathtt{I}[v]</tex> мы все еще в поддереве с корнем <tex>w</tex>. Значит, и на отрезке между <tex>\mathtt{I}[u]</tex> и <tex>\mathtt{I}[v]</tex> мы находились внутри поддерева с корнем <tex>w</tex>. Отсюда сделаем заключение, что на рассматриваемом отрезке не посещалась вершина, отличная от <tex>w</tex>, с глубиной меньшей либо равной глубины <tex>w</tex>, т. к. подобной вершины нет в поддереве с корнем <tex>w</tex>.
}}.

== Пример ==
Рассмотрим дерево на рисунке 1. Найдем наименьшего общего предка вершин, помеченных красным цветом.
Список глубин, получающийся в результате обхода в глубину {{---}} <tex>[0, 1, 2, 1, 2, 1, 0, 1, 0].</tex>
Глубина наименьшего общего предка красных вершин равна минимуму на отрезке <tex>[2, 1, 0, 1].</tex>
[[Файл:Lca to rmq.png(2).png|thumb|center|400x200px|Рисунок к примеру]]
<div style='clear:left;'></div>

== Сложность ==

Для нахождения минимального элемента на отрезке можно использовать [[Алгоритм Фарака-Колтона и Бендера|алгоритм Фарака-Колтона и Бендера]] для <tex>\pm 1RMQ</tex>, т. к. соседние элементы в списке глубин отличаются не более чем на единицу. Длина списка глубин составляет <tex>(2n - 1)</tex>, таким образом, препроцессинг работает за <tex>O(n)</tex>. Время выполнения запроса равно времени запроса минимального элемента на отрезке {{---}} <tex>O(1)</tex>.

== См.также ==
*[[Метод двоичного подъема]]
*[[Решение RMQ с помощью разреженной таблицы]]
*[[Алгоритм Фарака-Колтона и Бендера]]
*[[Сведение задачи RMQ к задаче LCA]]
== Источники информации ==
*[http://e-maxx.ru/algo/lca Наименьший общий предок. Нахождение за O (sqrt (N)) и O (log N) с препроцессингом O (N)]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Сведение задачи LCA к задаче RMQ

2015-06-09T10:01:57Z

Nastyastanchul: /* Алгоритм */

{{Шаблон:Задача
|definition =
Пусть дано корневое дерево <tex>T</tex>. На вход подаются запросы вида <tex>(u,\;v)</tex>, для каждого запроса требуется найти их наименьшего общего предка.
}}
{{Определение
|id=lca_suf_tree
|definition = '''Наименьшим общим предком''' (англ. ''least common ancestor'') двух узлов <tex>u</tex> и <tex>v</tex> в корневом дереве <tex>T</tex> называется узел <tex>w</tex>, который среди всех узлов, являющихся предками как узла <tex>u</tex>, так и <tex>v</tex>, имеет наибольшую глубину.
}}

== Алгоритм ==
=== Идея ===
Будем решать задачу <tex>LCA</tex>, уже умея решать задачу <tex>RMQ</tex>. Тогда поиск наименьшего общего предка <tex>i</tex>-того и <tex>j</tex>-того элементов сводится к запросу минимума на отрезке массива, который будет введен позднее.

=== Препроцессинг ===
Для каждой вершины <tex>T</tex> определим глубину с помощью следующей рекурсивной формулы:
:<tex>\mathrm{depth}(u) = \begin{cases}
0 & u = \mathrm{root}(T),\\
\mathrm{depth}(v) + 1 & u = \mathrm{son}(v).
\end{cases}</tex>
Ясно, что глубина вершины элементарным образом поддерживается во время обхода в глубину.

Запустим [[Обход в глубину, цвета вершин|обход в глубину]] из корня, который будет вычислять значения следующих величин:
#Cписок глубин посещенных вершин <tex>d</tex>. Глубина текущей вершины добавляется в конец списка при входе в данную вершину, а также после каждого возвращения из её сына.
#Список посещений узлов <tex>\mathtt{vtx}</tex>, строящийся аналогично предыдущему, только добавляется не глубина а сама вершина.
#Значение функции <tex>\mathtt{I}[u]</tex>, возвращающей индекс в списке глубин <tex>d</tex>, по которому была записана глубина вершины <tex>u</tex> (например на момент входа в вершину).

Вот таким образом будет выглядеть массив <tex>\mathtt{vtx}</tex> после обхода в глубину:

[[Файл:Полная персистентность.png‎ | мини | left | 500x200px| Пример массива <tex>\mathtt{vtx}</tex>]]
<br clear="all">
=== Запрос ===
Будем считать, что <tex>\mathrm{rmq}(d,l,r)</tex> возвращает индекс минимального элемента в <tex>d</tex> на отрезке <tex>[l..r]</tex>. Тогда ответом на запрос <tex>\mathrm{lca}(u, v)</tex>, где <tex>\mathtt{I}[u] \leqslant \mathtt{I}[v]</tex>, будет <tex>\mathtt{vtx}[\mathrm{rmq}(d,\mathtt{I}[u], \mathtt{I}[v])]</tex>.
=== Доказательство корректности алгоритма ===
{{Теорема
|statement=
Наименьшему общему предку вершин <tex>u, v</tex> соответствует минимальная глубина на отрезке <tex>d[\mathtt{I}[u], \mathtt{I}[v]]</tex>.
|proof=
Рассмотрим два узла <tex>u, v</tex> корневого дерева <tex>T</tex>. Рассмотрим отрезок <tex>d[\mathtt{I}[u]..\mathtt{I}[v]]</tex>. Поскольку этот отрезок {{---}} путь из <tex>u</tex> в <tex>v</tex>, он проходит через их наименьшего общего предка <tex>w</tex> (в дереве есть только один простой путь между вершинами), а следовательно минимум на отрезке никак не больше глубины <tex>w</tex>. Заметим, что в момент добавления <tex>\mathtt{I}[u]</tex> обход посещал поддерево с корнем <tex>w</tex>. В момент добавления <tex>\mathtt{I}[v]</tex> мы все еще в поддереве с корнем <tex>w</tex>. Значит, и на отрезке между <tex>\mathtt{I}[u]</tex> и <tex>\mathtt{I}[v]</tex> мы находились внутри поддерева с корнем <tex>w</tex>. Отсюда сделаем заключение, что на рассматриваемом отрезке не посещалась вершина, отличная от <tex>w</tex>, с глубиной меньшей либо равной глубины <tex>w</tex>, т. к. подобной вершины нет в поддереве с корнем <tex>w</tex>.
}}.

== Пример ==
Рассмотрим дерево на рисунке 1. Найдем наименьшего общего предка вершин, помеченных красным цветом.
Список глубин, получающийся в результате обхода в глубину {{---}} <tex>[0, 1, 2, 1, 2, 1, 0, 1, 0].</tex>
Глубина наименьшего общего предка красных вершин равна минимуму на отрезке <tex>[2, 1, 0, 1].</tex>
[[Файл:Lca to rmq.png(2).png|thumb|center|400x200px|Рисунок к примеру]]
<div style='clear:left;'></div>

== Сложность ==

Для нахождения минимального элемента на отрезке можно использовать [[Алгоритм Фарака-Колтона и Бендера|алгоритм Фарака-Колтона и Бендера]] для <tex>\pm 1RMQ</tex>, т. к. соседние элементы в списке глубин отличаются не более чем на единицу. Длина списка глубин составляет <tex>(2n - 1)</tex>, таким образом, препроцессинг работает за <tex>O(n)</tex>. Время выполнения запроса равно времени запроса минимального элемента на отрезке {{---}} <tex>O(1)</tex>.

== См.также ==
*[[Метод двоичного подъема]]
*[[Решение RMQ с помощью разреженной таблицы]]
*[[Алгоритм Фарака-Колтона и Бендера]]
*[[Сведение задачи RMQ к задаче LCA]]
== Источники информации ==
*[http://e-maxx.ru/algo/lca Наименьший общий предок. Нахождение за O (sqrt (N)) и O (log N) с препроцессингом O (N)]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Сведение задачи LCA к задаче RMQ

2015-06-09T10:01:04Z

Nastyastanchul: /* Препроцессинг */

{{Шаблон:Задача
|definition =
Пусть дано корневое дерево <tex>T</tex>. На вход подаются запросы вида <tex>(u,\;v)</tex>, для каждого запроса требуется найти их наименьшего общего предка.
}}
{{Определение
|id=lca_suf_tree
|definition = '''Наименьшим общим предком''' (англ. ''least common ancestor'') двух узлов <tex>u</tex> и <tex>v</tex> в корневом дереве <tex>T</tex> называется узел <tex>w</tex>, который среди всех узлов, являющихся предками как узла <tex>u</tex>, так и <tex>v</tex>, имеет наибольшую глубину.
}}

== Алгоритм ==
=== Идея ===
Будем решать задачу <tex>LCA</tex>, уже умея решать задачу <tex>RMQ</tex>. Тогда поиск наименьшего общего предка <tex>i</tex>-того и <tex>j</tex>-того элементов сводится к запросу минимума на отрезке массива, который будет введен позднее.

=== Препроцессинг ===
Для каждой вершины <tex>T</tex> определим глубину с помощью следующей рекурсивной формулы:
:<tex>\mathrm{depth}(u) = \begin{cases}
0 & u = \mathrm{root}(T),\\
\mathrm{depth}(v) + 1 & u = \mathrm{son}(v).
\end{cases}</tex>
Ясно, что глубина вершины элементарным образом поддерживается во время обхода в глубину.

Запустим [[Обход в глубину, цвета вершин|обход в глубину]] из корня, который будет вычислять значения следующих величин:
#Cписок глубин посещенных вершин <tex>d</tex>. Глубина текущей вершины добавляется в конец списка при входе в данную вершину, а также после каждого возвращения из её сына.
#Список посещений узлов <tex>\mathtt{vtx}</tex>, строящийся аналогично предыдущему, только добавляется не глубина а сама вершина.
#Значение функции <tex>\mathtt{I}[u]</tex>, возвращающей индекс в списке глубин <tex>d</tex>, по которому была записана глубина вершины <tex>u</tex> (например на момент входа в вершину).

Вот таким образом будет выглядеть массив <tex>\mathtt{vtx}</tex> после обхода в глубину:

[[Файл:Полная персистентность.png‎ | мини | left | 500x200px| Пример массива <tex>\mathtt{vtx}</tex>]]

=== Запрос ===
Будем считать, что <tex>\mathrm{rmq}(d,l,r)</tex> возвращает индекс минимального элемента в <tex>d</tex> на отрезке <tex>[l..r]</tex>. Тогда ответом на запрос <tex>\mathrm{lca}(u, v)</tex>, где <tex>\mathtt{I}[u] \leqslant \mathtt{I}[v]</tex>, будет <tex>\mathtt{vtx}[\mathrm{rmq}(d,\mathtt{I}[u], \mathtt{I}[v])]</tex>.

=== Доказательство корректности алгоритма ===
{{Теорема
|statement=
Наименьшему общему предку вершин <tex>u, v</tex> соответствует минимальная глубина на отрезке <tex>d[\mathtt{I}[u], \mathtt{I}[v]]</tex>.
|proof=
Рассмотрим два узла <tex>u, v</tex> корневого дерева <tex>T</tex>. Рассмотрим отрезок <tex>d[\mathtt{I}[u]..\mathtt{I}[v]]</tex>. Поскольку этот отрезок {{---}} путь из <tex>u</tex> в <tex>v</tex>, он проходит через их наименьшего общего предка <tex>w</tex> (в дереве есть только один простой путь между вершинами), а следовательно минимум на отрезке никак не больше глубины <tex>w</tex>. Заметим, что в момент добавления <tex>\mathtt{I}[u]</tex> обход посещал поддерево с корнем <tex>w</tex>. В момент добавления <tex>\mathtt{I}[v]</tex> мы все еще в поддереве с корнем <tex>w</tex>. Значит, и на отрезке между <tex>\mathtt{I}[u]</tex> и <tex>\mathtt{I}[v]</tex> мы находились внутри поддерева с корнем <tex>w</tex>. Отсюда сделаем заключение, что на рассматриваемом отрезке не посещалась вершина, отличная от <tex>w</tex>, с глубиной меньшей либо равной глубины <tex>w</tex>, т. к. подобной вершины нет в поддереве с корнем <tex>w</tex>.
}}.

== Пример ==
Рассмотрим дерево на рисунке 1. Найдем наименьшего общего предка вершин, помеченных красным цветом.
Список глубин, получающийся в результате обхода в глубину {{---}} <tex>[0, 1, 2, 1, 2, 1, 0, 1, 0].</tex>
Глубина наименьшего общего предка красных вершин равна минимуму на отрезке <tex>[2, 1, 0, 1].</tex>
[[Файл:Lca to rmq.png(2).png|thumb|center|400x200px|Рисунок к примеру]]
<div style='clear:left;'></div>

== Сложность ==

Для нахождения минимального элемента на отрезке можно использовать [[Алгоритм Фарака-Колтона и Бендера|алгоритм Фарака-Колтона и Бендера]] для <tex>\pm 1RMQ</tex>, т. к. соседние элементы в списке глубин отличаются не более чем на единицу. Длина списка глубин составляет <tex>(2n - 1)</tex>, таким образом, препроцессинг работает за <tex>O(n)</tex>. Время выполнения запроса равно времени запроса минимального элемента на отрезке {{---}} <tex>O(1)</tex>.

== См.также ==
*[[Метод двоичного подъема]]
*[[Решение RMQ с помощью разреженной таблицы]]
*[[Алгоритм Фарака-Колтона и Бендера]]
*[[Сведение задачи RMQ к задаче LCA]]
== Источники информации ==
*[http://e-maxx.ru/algo/lca Наименьший общий предок. Нахождение за O (sqrt (N)) и O (log N) с препроцессингом O (N)]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Алгоритм Карккайнена-Сандерса

2015-06-09T09:21:58Z

Nastyastanchul: /* База рекурсии */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

Для упрощения алгоритма вначале дополним нашу строку до четной длины (например, добавлением <tex>\$</tex> в конец). На шаге слияния мы сможем избавиться от него.

=====База рекурсии=====
Если длина текущей строки <tex> S </tex> равна двум, надо выполнить обычное сравнение суффиксов.

=====Суффиксный массив для нечетных суффиксов=====

# Отобразим исходную строку <tex> S^* </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S^*[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

=====Суффиксный массив для четных суффиксов=====
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S^*[i..n] \mid i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S^*[i], S^*[i+1..n]) \mid i \bmod 2 = 0 \} </tex>. Однако <tex> S^*[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n / 2 - 1
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
quick_stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

=====Слияние суффиксных массивов=====
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае [[Суффиксный массив|суффиксного массива]] слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

=====Суффиксный массив для нечетных суффиксов=====
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку <tex>S^*[1..n]</tex> = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

=====Суффиксный массив для четных суффиксов=====
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [(<tex>\$</tex>, 9), (<tex>a</tex>, 7), (<tex>b</tex>, 5), (<tex>a</tex>, 1), (<tex>a</tex>, 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [(<tex>\$</tex>, 9), (<tex>a</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 3), (<tex>b</tex>, 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

=====Слияние суффиксных массивов=====
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex> и получим <tex>S^*</tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S^*[i..n-1] \mid i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S^*[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n]S^*[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S^*[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S^* </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S^*[i..n-1] \mid i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S^*[i], S^*[i+1..n-1]) \mid i \bmod 3 = 0 \} </tex>, где <tex> S^*[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S*[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S^*[i], S^*[i+1..n-1]) </tex> и <tex> (S^*[j], S^*[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S^*[i], S^*[i+1], S^*[i+2..n-1]) </tex> и <tex> (S^*[j], S^*[j+1], S^*[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
<font color=green>// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции. </font>
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S*[pos12], rank[pos12 + 1]) < Pair(S*[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S*[pos12], S*[pos12 + 1], rank[pos12 + 2]) < Triple(S*[pos0], S*[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки <tex>(S^*[5], S^*[6], S^*[7..8])</tex> и <tex>(S^*[0], S^*[1], S^*[2..8])</tex>.
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что № 9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Обобщение алгоритма ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (англ. ''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Сведение задачи RMQ к задаче LCA

2015-06-09T07:24:49Z

Nastyastanchul: /* Описание */

{{Шаблон:Задача
|definition =Дан массив <tex>A[1..N]</tex>. Поступают запросы вида <tex>(i, j)</tex>, на каждый запрос требуется найти минимум в массиве <tex>A</tex>, начиная с позиции <tex>i</tex> и заканчивая позицией <tex>j</tex>.
}}

== Алгоритм ==
===Описание===
[[Файл:Wiki.PNG|thumb|right|400x200px|Пример декартового дерева]]
Будем решать задачу RMQ, уже умея решать задачу LCA. Для хранения решения задачи о LCA будем использовать [[декартово дерево по неявному ключу]]. Тогда минимум на отрезке от <tex> i </tex> до <tex> j </tex> будет равен наименьшему общему предку <tex>i</tex>-того и <tex>j</tex>-того элементов из декартова дерева.

Декартово дерево по неявному ключу на массиве <tex>A[1..N]</tex> {{---}} это бинарное дерево, допускающее следующее рекурсивное построение:
* Корнем дерева является элемент массива, имеющий минимальное значение <tex>A</tex>, скажем <tex>A[i]</tex>. Если минимальных элементов несколько, можно взять любой.
* Левым поддеревом является декартово дерево на массиве <tex>A[1..i-1]</tex>.
* Правым поддеревом является декартово дерево на массиве <tex>A[i+1..N]</tex>.

Здесь и далее <tex>A[i]</tex> будет также использоваться для обозначения соответствующей вершины дерева.

Построим декартово дерево на массиве <tex>A</tex>. Тогда <tex>RMQ(i, j)</tex> = <tex>LCA(A[i], A[j])</tex>.
<br clear="all">

=== Корректность ===
{{Теорема
|statement=
<tex>RMQ(i, j)</tex> = <tex>LCA(A[i], A[j])</tex>.
|proof=
Положим <tex>w = LCA(A[i], A[j])</tex>.

Заметим, что <tex>A[i]</tex> и <tex>A[j]</tex> не принадлежат одновременно либо правому, либо левому поддереву <tex>w</tex>, потому как тогда бы соответствующий сын находился на большей глубине, чем <tex>w</tex>, и также являлся предком как <tex>A[i]</tex> так и <tex>A[j]</tex>, что противоречит определению <tex>LCA</tex>. Из этого замечанию следует, что <tex>w</tex> лежит между <tex>A[i]</tex> и <tex>A[j]</tex> и, следовательно, принадлежит отрезку <tex>A[i..j]</tex>.

По построению мы также знаем, что:
# Любая вершина дерева имеет свое значение меньшим либо равным значению её детей.
# Поддерево с корнем в <tex>w</tex> содержит в себе подмассив <tex>A[i..j]</tex>.

Суммируя, получаем, что <tex>w</tex> имеет минимальное значение на отрезке, покрывающем <tex>A[i..j]</tex>, и принадлежит отрезку <tex>A[i..j]</tex>, отсюда <tex>RMQ(i, j) = w</tex>.
}}

=== Сложность ===
Существует [[Декартово дерево#Построение декартова дерева|алгоритм]], который строит декартово дерево за <tex>O(n)</tex>. Используя [[Сведение задачи LCA к задаче RMQ | алгоритм построения LCA]], получаем:
препроцессинг для <tex>LCA</tex> {{---}} <tex>O(n)</tex> и ответ на запрос {{---}} <tex>O(1)</tex>.

Нам нужно единожды построить декартово дерево за <tex>O(n)</tex>, единожды провести препроцессинг за <tex>O(n)</tex> и отвечать на запросы за <tex>O(1)</tex>.

В итоге получили <tex>RMQ</tex> с построением за <tex>O(n)</tex> и ответом на запрос за <tex>O(1)</tex>.

== См.также ==
*[[Сведение задачи LCA к задаче RMQ]]
*[[Декартово дерево]]
*[[Алгоритм Фарака-Колтона и Бендера]]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Сведение задачи LCA к задаче RMQ

2015-06-09T07:24:20Z

Nastyastanchul: /* Пример */

{{Шаблон:Задача
|definition =
Пусть дано корневое дерево <tex>T</tex>. На вход подаются запросы вида <tex>(u,\;v)</tex>, для каждого запроса требуется найти их наименьшего общего предка.
}}
{{Определение
|id=lca_suf_tree
|definition = '''Наименьшим общим предком''' (англ. ''least common ancestor'') двух узлов <tex>u</tex> и <tex>v</tex> в корневом дереве <tex>T</tex> называется узел <tex>w</tex>, который среди всех узлов, являющихся предками как узла <tex>u</tex>, так и <tex>v</tex>, имеет наибольшую глубину.
}}

== Алгоритм ==
=== Идея ===
Будем решать задачу <tex>LCA</tex>, уже умея решать задачу <tex>RMQ</tex>. Тогда поиск наименьшего общего предка <tex>i</tex>-того и <tex>j</tex>-того элементов сводится к запросу минимума на отрезке массива, который будет введен позднее.

=== Препроцессинг ===
Для каждой вершины <tex>T</tex> определим глубину с помощью следующей рекурсивной формулы:
:<tex>\mathrm{depth}(u) = \begin{cases}
0 & u = \mathrm{root}(T),\\
\mathrm{depth}(v) + 1 & u = \mathrm{son}(v).
\end{cases}</tex>
Ясно, что глубина вершины элементарным образом поддерживается во время обхода в глубину.

Запустим [[Обход в глубину, цвета вершин|обход в глубину]] из корня, который будет вычислять значения следующих величин:
#Cписок глубин посещенных вершин <tex>d</tex>. Глубина текущей вершины добавляется в конец списка при входе в данную вершину, а также после каждого возвращения из её сына.
#Список посещений узлов <tex>\mathtt{vtx}</tex>, строящийся аналогично предыдущему, только добавляется не глубина а сама вершина.
#Значение функции <tex>\mathtt{I}[u]</tex>, возвращающей индекс в списке глубин <tex>d</tex>, по которому была записана глубина вершины <tex>u</tex> (например на момент входа в вершину).

=== Запрос ===
Будем считать, что <tex>\mathrm{rmq}(d,l,r)</tex> возвращает индекс минимального элемента в <tex>d</tex> на отрезке <tex>[l..r]</tex>. Тогда ответом на запрос <tex>\mathrm{lca}(u, v)</tex>, где <tex>\mathtt{I}[u] \leqslant \mathtt{I}[v]</tex>, будет <tex>\mathtt{vtx}[\mathrm{rmq}(d,\mathtt{I}[u], \mathtt{I}[v])]</tex>.

=== Доказательство корректности алгоритма ===
{{Теорема
|statement=
Наименьшему общему предку вершин <tex>u, v</tex> соответствует минимальная глубина на отрезке <tex>d[\mathtt{I}[u], \mathtt{I}[v]]</tex>.
|proof=
Рассмотрим два узла <tex>u, v</tex> корневого дерева <tex>T</tex>. Рассмотрим отрезок <tex>d[\mathtt{I}[u]..\mathtt{I}[v]]</tex>. Поскольку этот отрезок {{---}} путь из <tex>u</tex> в <tex>v</tex>, он проходит через их наименьшего общего предка <tex>w</tex> (в дереве есть только один простой путь между вершинами), а следовательно минимум на отрезке никак не больше глубины <tex>w</tex>. Заметим, что в момент добавления <tex>\mathtt{I}[u]</tex> обход посещал поддерево с корнем <tex>w</tex>. В момент добавления <tex>\mathtt{I}[v]</tex> мы все еще в поддереве с корнем <tex>w</tex>. Значит, и на отрезке между <tex>\mathtt{I}[u]</tex> и <tex>\mathtt{I}[v]</tex> мы находились внутри поддерева с корнем <tex>w</tex>. Отсюда сделаем заключение, что на рассматриваемом отрезке не посещалась вершина, отличная от <tex>w</tex>, с глубиной меньшей либо равной глубины <tex>w</tex>, т. к. подобной вершины нет в поддереве с корнем <tex>w</tex>.
}}.

== Пример ==
Рассмотрим дерево на рисунке 1. Найдем наименьшего общего предка вершин, помеченных красным цветом.
Список глубин, получающийся в результате обхода в глубину {{---}} <tex>[0, 1, 2, 1, 2, 1, 0, 1, 0].</tex>
Глубина наименьшего общего предка красных вершин равна минимуму на отрезке <tex>[2, 1, 0, 1].</tex>
[[Файл:Lca to rmq.png(2).png|thumb|center|400x200px|Рисунок к примеру]]
<div style='clear:left;'></div>

== Сложность ==

Для нахождения минимального элемента на отрезке можно использовать [[Алгоритм Фарака-Колтона и Бендера|алгоритм Фарака-Колтона и Бендера]] для <tex>\pm 1RMQ</tex>, т. к. соседние элементы в списке глубин отличаются не более чем на единицу. Длина списка глубин составляет <tex>(2n - 1)</tex>, таким образом, препроцессинг работает за <tex>O(n)</tex>. Время выполнения запроса равно времени запроса минимального элемента на отрезке {{---}} <tex>O(1)</tex>.

== См.также ==
*[[Метод двоичного подъема]]
*[[Решение RMQ с помощью разреженной таблицы]]
*[[Алгоритм Фарака-Колтона и Бендера]]
*[[Сведение задачи RMQ к задаче LCA]]
== Источники информации ==
*[http://e-maxx.ru/algo/lca Наименьший общий предок. Нахождение за O (sqrt (N)) и O (log N) с препроцессингом O (N)]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Файл:Lca to rmq.png(2).png

2015-06-09T07:21:02Z

Nastyastanchul: загружена новая версия «Файл:Lca to rmq.png(2).png»

Сведение задачи LCA к задаче RMQ

2015-06-09T06:51:09Z

Nastyastanchul: /* Препроцессинг */

{{Шаблон:Задача
|definition =
Пусть дано корневое дерево <tex>T</tex>. На вход подаются запросы вида <tex>(u,\;v)</tex>, для каждого запроса требуется найти их наименьшего общего предка.
}}
{{Определение
|id=lca_suf_tree
|definition = '''Наименьшим общим предком''' (англ. ''least common ancestor'') двух узлов <tex>u</tex> и <tex>v</tex> в корневом дереве <tex>T</tex> называется узел <tex>w</tex>, который среди всех узлов, являющихся предками как узла <tex>u</tex>, так и <tex>v</tex>, имеет наибольшую глубину.
}}

== Алгоритм ==
=== Идея ===
Будем решать задачу <tex>LCA</tex>, уже умея решать задачу <tex>RMQ</tex>. Тогда поиск наименьшего общего предка <tex>i</tex>-того и <tex>j</tex>-того элементов сводится к запросу минимума на отрезке массива, который будет введен позднее.

=== Препроцессинг ===
Для каждой вершины <tex>T</tex> определим глубину с помощью следующей рекурсивной формулы:
:<tex>\mathrm{depth}(u) = \begin{cases}
0 & u = \mathrm{root}(T),\\
\mathrm{depth}(v) + 1 & u = \mathrm{son}(v).
\end{cases}</tex>
Ясно, что глубина вершины элементарным образом поддерживается во время обхода в глубину.

Запустим [[Обход в глубину, цвета вершин|обход в глубину]] из корня, который будет вычислять значения следующих величин:
#Cписок глубин посещенных вершин <tex>d</tex>. Глубина текущей вершины добавляется в конец списка при входе в данную вершину, а также после каждого возвращения из её сына.
#Список посещений узлов <tex>\mathtt{vtx}</tex>, строящийся аналогично предыдущему, только добавляется не глубина а сама вершина.
#Значение функции <tex>\mathtt{I}[u]</tex>, возвращающей индекс в списке глубин <tex>d</tex>, по которому была записана глубина вершины <tex>u</tex> (например на момент входа в вершину).

=== Запрос ===
Будем считать, что <tex>\mathrm{rmq}(d,l,r)</tex> возвращает индекс минимального элемента в <tex>d</tex> на отрезке <tex>[l..r]</tex>. Тогда ответом на запрос <tex>\mathrm{lca}(u, v)</tex>, где <tex>\mathtt{I}[u] \leqslant \mathtt{I}[v]</tex>, будет <tex>\mathtt{vtx}[\mathrm{rmq}(d,\mathtt{I}[u], \mathtt{I}[v])]</tex>.

=== Доказательство корректности алгоритма ===
{{Теорема
|statement=
Наименьшему общему предку вершин <tex>u, v</tex> соответствует минимальная глубина на отрезке <tex>d[\mathtt{I}[u], \mathtt{I}[v]]</tex>.
|proof=
Рассмотрим два узла <tex>u, v</tex> корневого дерева <tex>T</tex>. Рассмотрим отрезок <tex>d[\mathtt{I}[u]..\mathtt{I}[v]]</tex>. Поскольку этот отрезок {{---}} путь из <tex>u</tex> в <tex>v</tex>, он проходит через их наименьшего общего предка <tex>w</tex> (в дереве есть только один простой путь между вершинами), а следовательно минимум на отрезке никак не больше глубины <tex>w</tex>. Заметим, что в момент добавления <tex>\mathtt{I}[u]</tex> обход посещал поддерево с корнем <tex>w</tex>. В момент добавления <tex>\mathtt{I}[v]</tex> мы все еще в поддереве с корнем <tex>w</tex>. Значит, и на отрезке между <tex>\mathtt{I}[u]</tex> и <tex>\mathtt{I}[v]</tex> мы находились внутри поддерева с корнем <tex>w</tex>. Отсюда сделаем заключение, что на рассматриваемом отрезке не посещалась вершина, отличная от <tex>w</tex>, с глубиной меньшей либо равной глубины <tex>w</tex>, т. к. подобной вершины нет в поддереве с корнем <tex>w</tex>.
}}.

== Пример ==
Рассмотрим дерево на рисунке 1. Найдем наименьшего общего предка вершин, помеченных красным цветом.
Список глубин, получающийся в результате обхода в глубину {{---}} <tex>[0, 1, 2, 1, 2, 1, 0, 1, 0].</tex>
Глубина наименьшего общего предка красных вершин равна минимуму на отрезке <tex>[2, 1, 0, 1].</tex>
[[Файл:Lca to rmq.png(2).png|thumb|center|300x150px|Рисунок к примеру]]
<div style='clear:left;'></div>

== Сложность ==

Для нахождения минимального элемента на отрезке можно использовать [[Алгоритм Фарака-Колтона и Бендера|алгоритм Фарака-Колтона и Бендера]] для <tex>\pm 1RMQ</tex>, т. к. соседние элементы в списке глубин отличаются не более чем на единицу. Длина списка глубин составляет <tex>(2n - 1)</tex>, таким образом, препроцессинг работает за <tex>O(n)</tex>. Время выполнения запроса равно времени запроса минимального элемента на отрезке {{---}} <tex>O(1)</tex>.

== См.также ==
*[[Метод двоичного подъема]]
*[[Решение RMQ с помощью разреженной таблицы]]
*[[Алгоритм Фарака-Колтона и Бендера]]
*[[Сведение задачи RMQ к задаче LCA]]
== Источники информации ==
*[http://e-maxx.ru/algo/lca Наименьший общий предок. Нахождение за O (sqrt (N)) и O (log N) с препроцессингом O (N)]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Сведение задачи LCA к задаче RMQ

2015-06-09T06:46:50Z

Nastyastanchul: /* Алгоритм */

{{Шаблон:Задача
|definition =
Пусть дано корневое дерево <tex>T</tex>. На вход подаются запросы вида <tex>(u,\;v)</tex>, для каждого запроса требуется найти их наименьшего общего предка.
}}
{{Определение
|id=lca_suf_tree
|definition = '''Наименьшим общим предком''' (англ. ''least common ancestor'') двух узлов <tex>u</tex> и <tex>v</tex> в корневом дереве <tex>T</tex> называется узел <tex>w</tex>, который среди всех узлов, являющихся предками как узла <tex>u</tex>, так и <tex>v</tex>, имеет наибольшую глубину.
}}

== Алгоритм ==
=== Идея ===
Будем решать задачу <tex>LCA</tex>, уже умея решать задачу <tex>RMQ</tex>. Тогда поиск наименьшего общего предка <tex>i</tex>-того и <tex>j</tex>-того элементов сводится к запросу минимума на отрезке массива, который будет введен позднее.

=== Препроцессинг ===
Для каждой вершины <tex>T</tex> определим глубину с помощью следующей рекурсивной формулы:
:<tex>\mathrm{depth}(u) = \begin{cases}
0 & u = \mathrm{root}(T),\\
\mathrm{depth}(v) + 1 & u = \mathrm{son}(v).
\end{cases}</tex>
Ясно, что глубина вершины элементарным образом поддерживается во время обхода в глубину.

Запустим [[Обход в глубину, цвета вершин|обход в глубину]] из корня, который будет вычислять значения следующих величин:
#Cписок глубин посещенных вершин <tex>d</tex>. Глубина текущей вершины добавляется в конец списка при входе в данную вершину, а также после каждого возвращения из её сына.
#Список посещений узлов <tex>\mathtt{vtx}</tex>, строящийся аналогично предыдущему, только добавляется не глубина а сама вершина.
#Значение функции <tex>\mathtt{I}[u]</tex>, возвращающей любой индекс в списке глубин <tex>d</tex>, по которому была записана глубина вершины <tex>u</tex> (например на момент входа в вершину).

=== Запрос ===
Будем считать, что <tex>\mathrm{rmq}(d,l,r)</tex> возвращает индекс минимального элемента в <tex>d</tex> на отрезке <tex>[l..r]</tex>. Тогда ответом на запрос <tex>\mathrm{lca}(u, v)</tex>, где <tex>\mathtt{I}[u] \leqslant \mathtt{I}[v]</tex>, будет <tex>\mathtt{vtx}[\mathrm{rmq}(d,\mathtt{I}[u], \mathtt{I}[v])]</tex>.

=== Доказательство корректности алгоритма ===
{{Теорема
|statement=
Наименьшему общему предку вершин <tex>u, v</tex> соответствует минимальная глубина на отрезке <tex>d[\mathtt{I}[u], \mathtt{I}[v]]</tex>.
|proof=
Рассмотрим два узла <tex>u, v</tex> корневого дерева <tex>T</tex>. Рассмотрим отрезок <tex>d[\mathtt{I}[u]..\mathtt{I}[v]]</tex>. Поскольку этот отрезок {{---}} путь из <tex>u</tex> в <tex>v</tex>, он проходит через их наименьшего общего предка <tex>w</tex> (в дереве есть только один простой путь между вершинами), а следовательно минимум на отрезке никак не больше глубины <tex>w</tex>. Заметим, что в момент добавления <tex>\mathtt{I}[u]</tex> обход посещал поддерево с корнем <tex>w</tex>. В момент добавления <tex>\mathtt{I}[v]</tex> мы все еще в поддереве с корнем <tex>w</tex>. Значит, и на отрезке между <tex>\mathtt{I}[u]</tex> и <tex>\mathtt{I}[v]</tex> мы находились внутри поддерева с корнем <tex>w</tex>. Отсюда сделаем заключение, что на рассматриваемом отрезке не посещалась вершина, отличная от <tex>w</tex>, с глубиной меньшей либо равной глубины <tex>w</tex>, т. к. подобной вершины нет в поддереве с корнем <tex>w</tex>.
}}.

== Пример ==
Рассмотрим дерево на рисунке 1. Найдем наименьшего общего предка вершин, помеченных красным цветом.
Список глубин, получающийся в результате обхода в глубину {{---}} <tex>[0, 1, 2, 1, 2, 1, 0, 1, 0].</tex>
Глубина наименьшего общего предка красных вершин равна минимуму на отрезке <tex>[2, 1, 0, 1].</tex>
[[Файл:Lca to rmq.png(2).png|thumb|center|300x150px|Рисунок к примеру]]
<div style='clear:left;'></div>

== Сложность ==

Для нахождения минимального элемента на отрезке можно использовать [[Алгоритм Фарака-Колтона и Бендера|алгоритм Фарака-Колтона и Бендера]] для <tex>\pm 1RMQ</tex>, т. к. соседние элементы в списке глубин отличаются не более чем на единицу. Длина списка глубин составляет <tex>(2n - 1)</tex>, таким образом, препроцессинг работает за <tex>O(n)</tex>. Время выполнения запроса равно времени запроса минимального элемента на отрезке {{---}} <tex>O(1)</tex>.

== См.также ==
*[[Метод двоичного подъема]]
*[[Решение RMQ с помощью разреженной таблицы]]
*[[Алгоритм Фарака-Колтона и Бендера]]
*[[Сведение задачи RMQ к задаче LCA]]
== Источники информации ==
*[http://e-maxx.ru/algo/lca Наименьший общий предок. Нахождение за O (sqrt (N)) и O (log N) с препроцессингом O (N)]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Сведение задачи LCA к задаче RMQ

2015-06-09T06:45:39Z

Nastyastanchul: /* Пример */

{{Шаблон:Задача
|definition =
Пусть дано корневое дерево <tex>T</tex>. На вход подаются запросы вида <tex>(u,\;v)</tex>, для каждого запроса требуется найти их наименьшего общего предка.
}}
{{Определение
|id=lca_suf_tree
|definition = '''Наименьшим общим предком''' (англ. ''least common ancestor'') двух узлов <tex>u</tex> и <tex>v</tex> в корневом дереве <tex>T</tex> называется узел <tex>w</tex>, который среди всех узлов, являющихся предками как узла <tex>u</tex>, так и <tex>v</tex>, имеет наибольшую глубину.
}}

== Алгоритм ==
=== Идея ===
Будем решать задачу LCA, уже умея решать задачу RMQ. Тогда поиск наименьшего общего предка <tex>i</tex>-того и <tex>j</tex>-того элементов сводится к запросу минимума на отрезке массива, который будет введен позднее.

=== Препроцессинг ===
Для каждой вершины <tex>T</tex> определим глубину с помощью следующей рекурсивной формулы:
:<tex>\mathrm{depth}(u) = \begin{cases}
0 & u = \mathrm{root}(T),\\
\mathrm{depth}(v) + 1 & u = \mathrm{son}(v).
\end{cases}</tex>
Ясно, что глубина вершины элементарным образом поддерживается во время обхода в глубину.

Запустим [[Обход в глубину, цвета вершин|обход в глубину]] из корня, который будет вычислять значения следующих величин:
#Cписок глубин посещенных вершин <tex>d</tex>. Глубина текущей вершины добавляется в конец списка при входе в данную вершину, а также после каждого возвращения из её сына.
#Список посещений узлов <tex>\mathtt{vtx}</tex>, строящийся аналогично предыдущему, только добавляется не глубина а сама вершина.
#Значение функции <tex>\mathtt{I}[u]</tex>, возвращающей любой индекс в списке глубин <tex>d</tex>, по которому была записана глубина вершины <tex>u</tex> (например на момент входа в вершину).

=== Запрос ===
Будем считать, что <tex>\mathrm{rmq}(d,l,r)</tex> возвращает индекс минимального элемента в <tex>d</tex> на отрезке <tex>[l..r]</tex>. Тогда ответом на запрос <tex>\mathrm{lca}(u, v)</tex>, где <tex>\mathtt{I}[u] \leqslant \mathtt{I}[v]</tex>, будет <tex>\mathtt{vtx}[\mathrm{rmq}(d,\mathtt{I}[u], \mathtt{I}[v])]</tex>.

=== Доказательство корректности алгоритма ===
{{Теорема
|statement=
Наименьшему общему предку вершин <tex>u, v</tex> соответствует минимальная глубина на отрезке <tex>d[\mathtt{I}[u], \mathtt{I}[v]]</tex>.
|proof=
Рассмотрим два узла <tex>u, v</tex> корневого дерева <tex>T</tex>. Рассмотрим отрезок <tex>d[\mathtt{I}[u]..\mathtt{I}[v]]</tex>. Поскольку этот отрезок {{---}} путь из <tex>u</tex> в <tex>v</tex>, он проходит через их наименьшего общего предка <tex>w</tex> (в дереве есть только один простой путь между вершинами), а следовательно минимум на отрезке никак не больше глубины <tex>w</tex>. Заметим, что в момент добавления <tex>\mathtt{I}[u]</tex> обход посещал поддерево с корнем <tex>w</tex>. В момент добавления <tex>\mathtt{I}[v]</tex> мы все еще в поддереве с корнем <tex>w</tex>. Значит, и на отрезке между <tex>\mathtt{I}[u]</tex> и <tex>\mathtt{I}[v]</tex> мы находились внутри поддерева с корнем <tex>w</tex>. Отсюда сделаем заключение, что на рассматриваемом отрезке не посещалась вершина, отличная от <tex>w</tex>, с глубиной меньшей либо равной глубины <tex>w</tex>, т. к. подобной вершины нет в поддереве с корнем <tex>w</tex>.
}}.

== Пример ==
Рассмотрим дерево на рисунке 1. Найдем наименьшего общего предка вершин, помеченных красным цветом.
Список глубин, получающийся в результате обхода в глубину {{---}} <tex>[0, 1, 2, 1, 2, 1, 0, 1, 0].</tex>
Глубина наименьшего общего предка красных вершин равна минимуму на отрезке <tex>[2, 1, 0, 1].</tex>
[[Файл:Lca to rmq.png(2).png|thumb|center|300x150px|Рисунок к примеру]]
<div style='clear:left;'></div>

== Сложность ==

Для нахождения минимального элемента на отрезке можно использовать [[Алгоритм Фарака-Колтона и Бендера|алгоритм Фарака-Колтона и Бендера]] для <tex>\pm 1RMQ</tex>, т. к. соседние элементы в списке глубин отличаются не более чем на единицу. Длина списка глубин составляет <tex>(2n - 1)</tex>, таким образом, препроцессинг работает за <tex>O(n)</tex>. Время выполнения запроса равно времени запроса минимального элемента на отрезке {{---}} <tex>O(1)</tex>.

== См.также ==
*[[Метод двоичного подъема]]
*[[Решение RMQ с помощью разреженной таблицы]]
*[[Алгоритм Фарака-Колтона и Бендера]]
*[[Сведение задачи RMQ к задаче LCA]]
== Источники информации ==
*[http://e-maxx.ru/algo/lca Наименьший общий предок. Нахождение за O (sqrt (N)) и O (log N) с препроцессингом O (N)]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Алгоритм Карккайнена-Сандерса

2015-06-09T06:44:06Z

Nastyastanchul: /* Обобщение алгоритма */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

Для упрощения алгоритма вначале дополним нашу строку до четной длины (например, добавлением <tex>\$</tex> в конец). На шаге слияния мы сможем избавиться от него.

=====База рекурсии=====
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

=====Суффиксный массив для нечетных суффиксов=====

# Отобразим исходную строку <tex> S^* </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S^*[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

=====Суффиксный массив для четных суффиксов=====
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S^*[i..n] \mid i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S^*[i], S^*[i+1..n]) \mid i \bmod 2 = 0 \} </tex>. Однако <tex> S^*[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n / 2 - 1
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
quick_stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

=====Слияние суффиксных массивов=====
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае [[Суффиксный массив|суффиксного массива]] слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

=====Суффиксный массив для нечетных суффиксов=====
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку <tex>S^*[1..n]</tex> = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

=====Суффиксный массив для четных суффиксов=====
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [(<tex>\$</tex>, 9), (<tex>a</tex>, 7), (<tex>b</tex>, 5), (<tex>a</tex>, 1), (<tex>a</tex>, 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [(<tex>\$</tex>, 9), (<tex>a</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 3), (<tex>b</tex>, 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

=====Слияние суффиксных массивов=====
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex> и получим <tex>S^*</tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S^*[i..n-1] \mid i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S^*[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n]S^*[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S^*[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S^* </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S^*[i..n-1] \mid i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S^*[i], S^*[i+1..n-1]) \mid i \bmod 3 = 0 \} </tex>, где <tex> S^*[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S*[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S^*[i], S^*[i+1..n-1]) </tex> и <tex> (S^*[j], S^*[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S^*[i], S^*[i+1], S^*[i+2..n-1]) </tex> и <tex> (S^*[j], S^*[j+1], S^*[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
<font color=green>// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции. </font>
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S*[pos12], rank[pos12 + 1]) < Pair(S*[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S*[pos12], S*[pos12 + 1], rank[pos12 + 2]) < Triple(S*[pos0], S*[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки <tex>(S^*[5], S^*[6], S^*[7..8])</tex> и <tex>(S^*[0], S^*[1], S^*[2..8])</tex>.
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что № 9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Обобщение алгоритма ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (англ. ''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-09T06:42:35Z

Nastyastanchul: /* Алгоритм Карккайнена-Сандерса */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

Для упрощения алгоритма вначале дополним нашу строку до четной длины (например, добавлением <tex>\$</tex> в конец). На шаге слияния мы сможем избавиться от него.

=====База рекурсии=====
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

=====Суффиксный массив для нечетных суффиксов=====

# Отобразим исходную строку <tex> S^* </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S^*[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

=====Суффиксный массив для четных суффиксов=====
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S^*[i..n] \mid i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S^*[i], S^*[i+1..n]) \mid i \bmod 2 = 0 \} </tex>. Однако <tex> S^*[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n / 2 - 1
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
quick_stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

=====Слияние суффиксных массивов=====
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае [[Суффиксный массив|суффиксного массива]] слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

=====Суффиксный массив для нечетных суффиксов=====
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку <tex>S^*[1..n]</tex> = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

=====Суффиксный массив для четных суффиксов=====
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [(<tex>\$</tex>, 9), (<tex>a</tex>, 7), (<tex>b</tex>, 5), (<tex>a</tex>, 1), (<tex>a</tex>, 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [(<tex>\$</tex>, 9), (<tex>a</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 3), (<tex>b</tex>, 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

=====Слияние суффиксных массивов=====
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex> и получим <tex>S^*</tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S^*[i..n-1] \mid i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S^*[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n]S^*[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S^*[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S^* </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S^*[i..n-1] \mid i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S^*[i], S^*[i+1..n-1]) \mid i \bmod 3 = 0 \} </tex>, где <tex> S^*[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S*[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S^*[i], S^*[i+1..n-1]) </tex> и <tex> (S^*[j], S^*[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S^*[i], S^*[i+1], S^*[i+2..n-1]) </tex> и <tex> (S^*[j], S^*[j+1], S^*[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
<font color=green>// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции. </font>
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S*[pos12], rank[pos12 + 1]) < Pair(S*[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S*[pos12], S*[pos12 + 1], rank[pos12 + 2]) < Triple(S*[pos0], S*[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки <tex>(S^*[5], S^*[6], S^*[7..8])</tex> и <tex>(S^*[0], S^*[1], S^*[2..8])</tex>.
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что № 9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Обобщение алгоритма ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-09T06:41:01Z

Nastyastanchul:

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

Для упрощения алгоритма вначале дополним нашу строку до четной длины (например, добавлением <tex>\$</tex> в конец). На шаге слияния мы сможем избавиться от него.

=====База рекурсии=====
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

=====Суффиксный массив для нечетных суффиксов=====

# Отобразим исходную строку <tex> S^* </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S^*[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

=====Суффиксный массив для четных суффиксов=====
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S^*[i..n] \mid i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S^*[i], S^*[i+1..n]) \mid i \bmod 2 = 0 \} </tex>. Однако <tex> S^*[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n / 2 - 1
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
quick_stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

=====Слияние суффиксных массивов=====
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае [[Суффиксный массив|суффиксного массива]] слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

=====Суффиксный массив для нечетных суффиксов=====
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку <tex>S^*[1..n]</tex> = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

=====Суффиксный массив для четных суффиксов=====
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [(<tex>\$</tex>, 9), (<tex>a</tex>, 7), (<tex>b</tex>, 5), (<tex>a</tex>, 1), (<tex>a</tex>, 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [(<tex>\$</tex>, 9), (<tex>a</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 3), (<tex>b</tex>, 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

=====Слияние суффиксных массивов=====
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex> и получим <tex>S^*</tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S^*[i..n-1] \mid i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S^*[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n]S^*[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S^*[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S^* </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S^*[i..n-1] \mid i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S^*[i], S^*[i+1..n-1]) \mid i \bmod 3 = 0 \} </tex>, где <tex> S^*[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S*[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S^*[i], S^*[i+1..n-1]) </tex> и <tex> (S^*[j], S^*[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S^*[i], S^*[i+1], S^*[i+2..n-1]) </tex> и <tex> (S^*[j], S^*[j+1], S^*[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S*[pos12], rank[pos12 + 1]) < Pair(S*[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S*[pos12], S*[pos12 + 1], rank[pos12 + 2]) < Triple(S*[pos0], S*[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки <tex>(S^*[5], S^*[6], S^*[7..8])</tex> и <tex>(S^*[0], S^*[1], S^*[2..8])</tex>.
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что № 9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Обобщение алгоритма ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-09T06:35:45Z

Nastyastanchul: /* Суффиксный массив для четных суффиксов */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

Для упрощения алгоритма вначале дополним нашу строку до четной длины (например, добавлением <tex>\$</tex> в конец). На шаге слияния мы сможем избавиться от него.

=====База рекурсии=====
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

=====Суффиксный массив для нечетных суффиксов=====

# Отобразим исходную строку <tex> S^* </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S^*[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

=====Суффиксный массив для четных суффиксов=====
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S^*[i..n] \mid i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S^*[i], S^*[i+1..n]) \mid i \bmod 2 = 0 \} </tex>. Однако <tex> S^*[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n / 2 - 1
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
quick_stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

=====Слияние суффиксных массивов=====
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае [[Суффиксный массив|суффиксного массива]] слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

=====Суффиксный массив для нечетных суффиксов=====
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку <tex>S^*[1..n]</tex> = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

=====Суффиксный массив для четных суффиксов=====
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [(<tex>\$</tex>, 9), (<tex>a</tex>, 7), (<tex>b</tex>, 5), (<tex>a</tex>, 1), (<tex>a</tex>, 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [(<tex>\$</tex>, 9), (<tex>a</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 3), (<tex>b</tex>, 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

=====Слияние суффиксных массивов=====
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex> и получим <tex>S^*</tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S^*[i..n-1] \mid i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S^*[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n]S^*[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S^*[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S^* </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S^*[i..n-1] \mid i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S^*[i], S^*[i+1..n-1]) \mid i \bmod 3 = 0 \} </tex>, где <tex> S^*[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S*[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S^*[i], S^*[i+1..n-1]) </tex> и <tex> (S^*[j], S^*[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S^*[i], S^*[i+1], S^*[i+2..n-1]) </tex> и <tex> (S^*[j], S^*[j+1], S^*[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S*[pos12], rank[pos12 + 1]) < Pair(S*[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S*[pos12], S*[pos12 + 1], rank[pos12 + 2]) < Triple(S*[pos0], S*[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки <tex>(S^*[5], S^*[6], S^*[7..8])</tex> и <tex>(S^*[0], S^*[1], S^*[2..8])</tex>.
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что № 9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-09T06:33:34Z

Nastyastanchul: /* Слияние суффиксных массивов */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

Для упрощения алгоритма вначале дополним нашу строку до четной длины (например, добавлением <tex>\$</tex> в конец). На шаге слияния мы сможем избавиться от него.

=====База рекурсии=====
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

=====Суффиксный массив для нечетных суффиксов=====

# Отобразим исходную строку <tex> S^* </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S^*[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

=====Суффиксный массив для четных суффиксов=====
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S^*[i..n] \mid i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S^*[i], S^*[i+1..n]) \mid i \bmod 2 = 0 \} </tex>. Однако <tex> S^*[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n / 2 - 1
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
quick_stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

=====Слияние суффиксных массивов=====
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае [[Суффиксный массив|суффиксного массива]] слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

=====Суффиксный массив для нечетных суффиксов=====
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку <tex>S^*[1..n]</tex> = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

=====Суффиксный массив для четных суффиксов=====
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

=====Слияние суффиксных массивов=====
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex> и получим <tex>S^*</tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S^*[i..n-1] \mid i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S^*[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n]S^*[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S^*[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S^* </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S^*[i..n-1] \mid i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S^*[i], S^*[i+1..n-1]) \mid i \bmod 3 = 0 \} </tex>, где <tex> S^*[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S*[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S^*[i], S^*[i+1..n-1]) </tex> и <tex> (S^*[j], S^*[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S^*[i], S^*[i+1], S^*[i+2..n-1]) </tex> и <tex> (S^*[j], S^*[j+1], S^*[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S*[pos12], rank[pos12 + 1]) < Pair(S*[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S*[pos12], S*[pos12 + 1], rank[pos12 + 2]) < Triple(S*[pos0], S*[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки <tex>(S^*[5], S^*[6], S^*[7..8])</tex> и <tex>(S^*[0], S^*[1], S^*[2..8])</tex>.
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что № 9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-09T06:29:51Z

Nastyastanchul: /* Суффиксный массив для четных суффиксов */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

Для упрощения алгоритма вначале дополним нашу строку до четной длины (например, добавлением <tex>\$</tex> в конец). На шаге слияния мы сможем избавиться от него.

=====База рекурсии=====
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

=====Суффиксный массив для нечетных суффиксов=====

# Отобразим исходную строку <tex> S^* </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S^*[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

=====Суффиксный массив для четных суффиксов=====
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S^*[i..n] \mid i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S^*[i], S^*[i+1..n]) \mid i \bmod 2 = 0 \} </tex>. Однако <tex> S^*[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n / 2 - 1
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
quick_stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

=====Слияние суффиксных массивов=====
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

=====Суффиксный массив для нечетных суффиксов=====
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку <tex>S^*[1..n]</tex> = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

=====Суффиксный массив для четных суффиксов=====
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

=====Слияние суффиксных массивов=====
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex> и получим <tex>S^*</tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S^*[i..n-1] \mid i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S^*[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n]S^*[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S^*[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S^* </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S^*[i..n-1] \mid i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S^*[i], S^*[i+1..n-1]) \mid i \bmod 3 = 0 \} </tex>, где <tex> S^*[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S*[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S^*[i], S^*[i+1..n-1]) </tex> и <tex> (S^*[j], S^*[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S^*[i], S^*[i+1], S^*[i+2..n-1]) </tex> и <tex> (S^*[j], S^*[j+1], S^*[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S*[pos12], rank[pos12 + 1]) < Pair(S*[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S*[pos12], S*[pos12 + 1], rank[pos12 + 2]) < Triple(S*[pos0], S*[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки <tex>(S^*[5], S^*[6], S^*[7..8])</tex> и <tex>(S^*[0], S^*[1], S^*[2..8])</tex>.
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что № 9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-09T06:28:29Z

Nastyastanchul: /* Суффиксный массив для четных суффиксов */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

Для упрощения алгоритма вначале дополним нашу строку до четной длины (например, добавлением <tex>\$</tex> в конец). На шаге слияния мы сможем избавиться от него.

=====База рекурсии=====
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

=====Суффиксный массив для нечетных суффиксов=====

# Отобразим исходную строку <tex> S^* </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S^*[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

=====Суффиксный массив для четных суффиксов=====
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S^*[i..n] \mid i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S^*[i], S^*[i+1..n]) \mid i \bmod 2 = 0 \} </tex>. Однако <tex> S^*[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
quick_stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

=====Слияние суффиксных массивов=====
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

=====Суффиксный массив для нечетных суффиксов=====
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку <tex>S^*[1..n]</tex> = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

=====Суффиксный массив для четных суффиксов=====
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

=====Слияние суффиксных массивов=====
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex> и получим <tex>S^*</tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S^*[i..n-1] \mid i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S^*[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n]S^*[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S^*[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S^* </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S^*[i..n-1] \mid i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S^*[i], S^*[i+1..n-1]) \mid i \bmod 3 = 0 \} </tex>, где <tex> S^*[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S*[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S^*[i], S^*[i+1..n-1]) </tex> и <tex> (S^*[j], S^*[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S^*[i], S^*[i+1], S^*[i+2..n-1]) </tex> и <tex> (S^*[j], S^*[j+1], S^*[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S*[pos12], rank[pos12 + 1]) < Pair(S*[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S*[pos12], S*[pos12 + 1], rank[pos12 + 2]) < Triple(S*[pos0], S*[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки <tex>(S^*[5], S^*[6], S^*[7..8])</tex> и <tex>(S^*[0], S^*[1], S^*[2..8])</tex>.
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что № 9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-09T06:26:36Z

Nastyastanchul: /* Алгоритм Карккайнена-Сандерса */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

Для упрощения алгоритма вначале дополним нашу строку до четной длины (например, добавлением <tex>\$</tex> в конец). На шаге слияния мы сможем избавиться от него.

=====База рекурсии=====
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

=====Суффиксный массив для нечетных суффиксов=====

# Отобразим исходную строку <tex> S^* </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S^*[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

=====Суффиксный массив для четных суффиксов=====
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S^*[i..n] \mid i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S^*[i], S^*[i+1..n]) \mid i \bmod 2 = 0 \} </tex>. Однако <tex> S^*[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

=====Слияние суффиксных массивов=====
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

=====Суффиксный массив для нечетных суффиксов=====
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку <tex>S^*[1..n]</tex> = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

=====Суффиксный массив для четных суффиксов=====
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

=====Слияние суффиксных массивов=====
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex> и получим <tex>S^*</tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S^*[i..n-1] \mid i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S^*[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n]S^*[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S^*[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S^* </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S^*[i..n-1] \mid i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S^*[i], S^*[i+1..n-1]) \mid i \bmod 3 = 0 \} </tex>, где <tex> S^*[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S*[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S^*[i], S^*[i+1..n-1]) </tex> и <tex> (S^*[j], S^*[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S^*[i], S^*[i+1], S^*[i+2..n-1]) </tex> и <tex> (S^*[j], S^*[j+1], S^*[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S*[pos12], rank[pos12 + 1]) < Pair(S*[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S*[pos12], S*[pos12 + 1], rank[pos12 + 2]) < Triple(S*[pos0], S*[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки <tex>(S^*[5], S^*[6], S^*[7..8])</tex> и <tex>(S^*[0], S^*[1], S^*[2..8])</tex>.
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что № 9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-09T06:16:47Z

Nastyastanchul: /* Суффиксный массив для нечетных суффиксов */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

Для упрощения алгоритма вначале дополним нашу строку до четной длины (например, добавлением <tex>\$</tex> в конец). На шаге слияния мы сможем избавиться от него.

=====База рекурсии=====
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

=====Суффиксный массив для нечетных суффиксов=====

# Отобразим исходную строку <tex> S^* </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S^*[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

=====Суффиксный массив для четных суффиксов=====
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S^*[i..n] \mid i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S^*[i], S^*[i+1..n]) \mid i \bmod 2 = 0 \} </tex>. Однако <tex> S^*[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

=====Слияние суффиксных массивов=====
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

=====Суффиксный массив для нечетных суффиксов=====
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку <tex>S^*[1..n]</tex> = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

=====Суффиксный массив для четных суффиксов=====
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

=====Слияние суффиксных массивов=====
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S[i..n-1] \mid i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n]S[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S[i..n-1] \mid i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S[i], S[i+1..n-1]) \mid i \bmod 3 = 0 \} </tex>, где <tex> S[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S[i], S[i+1..n-1]) </tex> и <tex> (S[j], S[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S[i], S[i+1], S[i+2..n-1]) </tex> и <tex> (S[j], S[j+1], S[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S[pos12], rank[pos12 + 1]) < Pair(S[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S[pos12], S[pos12 + 1], rank[pos12 + 2]) < Triple(S[pos0], S[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки (S[5], S[6], S[7..8]) и (S[0], S[1], S[2..8]).
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что № 9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-09T06:15:22Z

Nastyastanchul: /* Суффиксный массив для четных суффиксов */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

Для упрощения алгоритма вначале дополним нашу строку до четной длины (например, добавлением <tex>\$</tex> в конец). На шаге слияния мы сможем избавиться от него.

=====База рекурсии=====
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

=====Суффиксный массив для нечетных суффиксов=====

# Отобразим исходную строку <tex> S^* </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S^*[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

=====Суффиксный массив для четных суффиксов=====
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S^*[i..n] \mid i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S^*[i], S^*[i+1..n]) \mid i \bmod 2 = 0 \} </tex>. Однако <tex> S^*[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

=====Слияние суффиксных массивов=====
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

=====Суффиксный массив для нечетных суффиксов=====
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку S[1..n] = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

=====Суффиксный массив для четных суффиксов=====
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

=====Слияние суффиксных массивов=====
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S[i..n-1] \mid i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n]S[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S[i..n-1] \mid i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S[i], S[i+1..n-1]) \mid i \bmod 3 = 0 \} </tex>, где <tex> S[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S[i], S[i+1..n-1]) </tex> и <tex> (S[j], S[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S[i], S[i+1], S[i+2..n-1]) </tex> и <tex> (S[j], S[j+1], S[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S[pos12], rank[pos12 + 1]) < Pair(S[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S[pos12], S[pos12 + 1], rank[pos12 + 2]) < Triple(S[pos0], S[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки (S[5], S[6], S[7..8]) и (S[0], S[1], S[2..8]).
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что № 9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-09T06:13:38Z

Nastyastanchul: /* Суффиксный массив для нечетных суффиксов */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

Для упрощения алгоритма вначале дополним нашу строку до четной длины (например, добавлением <tex>\$</tex> в конец). На шаге слияния мы сможем избавиться от него.

=====База рекурсии=====
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

=====Суффиксный массив для нечетных суффиксов=====

# Отобразим исходную строку <tex> S^* </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S^*[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S^*[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

=====Суффиксный массив для четных суффиксов=====
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S[i..n] \mid i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S[i], S[i+1..n]) \mid i \bmod 2 = 0 \} </tex>. Однако <tex> S[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

=====Слияние суффиксных массивов=====
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

=====Суффиксный массив для нечетных суффиксов=====
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку S[1..n] = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

=====Суффиксный массив для четных суффиксов=====
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

=====Слияние суффиксных массивов=====
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S[i..n-1] \mid i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n]S[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S[i..n-1] \mid i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S[i], S[i+1..n-1]) \mid i \bmod 3 = 0 \} </tex>, где <tex> S[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S[i], S[i+1..n-1]) </tex> и <tex> (S[j], S[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S[i], S[i+1], S[i+2..n-1]) </tex> и <tex> (S[j], S[j+1], S[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S[pos12], rank[pos12 + 1]) < Pair(S[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S[pos12], S[pos12 + 1], rank[pos12 + 2]) < Triple(S[pos0], S[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки (S[5], S[6], S[7..8]) и (S[0], S[1], S[2..8]).
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что № 9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-09T05:58:53Z

Nastyastanchul: /* Алгоритм Карккайнена-Сандерса */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

Для упрощения алгоритма вначале дополним нашу строку до четной длины (например, добавлением <tex>\$</tex> в конец). На шаге слияния мы сможем избавиться от него.

=====База рекурсии=====
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

=====Суффиксный массив для нечетных суффиксов=====

# Отобразим исходную строку <tex> S </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

=====Суффиксный массив для четных суффиксов=====
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S[i..n] \mid i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S[i], S[i+1..n]) \mid i \bmod 2 = 0 \} </tex>. Однако <tex> S[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

=====Слияние суффиксных массивов=====
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

=====Суффиксный массив для нечетных суффиксов=====
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку S[1..n] = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

=====Суффиксный массив для четных суффиксов=====
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

=====Слияние суффиксных массивов=====
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S[i..n-1] \mid i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n]S[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S[i..n-1] \mid i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S[i], S[i+1..n-1]) \mid i \bmod 3 = 0 \} </tex>, где <tex> S[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S[i], S[i+1..n-1]) </tex> и <tex> (S[j], S[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S[i], S[i+1], S[i+2..n-1]) </tex> и <tex> (S[j], S[j+1], S[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S[pos12], rank[pos12 + 1]) < Pair(S[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S[pos12], S[pos12 + 1], rank[pos12 + 2]) < Triple(S[pos0], S[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки (S[5], S[6], S[7..8]) и (S[0], S[1], S[2..8]).
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что № 9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-09T05:57:41Z

Nastyastanchul: /* Суффиксный массив для четных суффиксов */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

Для упрощения алгоритма вначале дополним нашу строку до четной длины (например, добавлением <tex>\$</tex> в конец). На шаге слияния мы сможем избавиться от него.

=====База рекурсии=====
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

=====Суффиксный массив для нечетных суффиксов=====

# Отобразим исходную строку <tex> S </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

=====Суффиксный массив для четных суффиксов=====
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S[i..n] \mid i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S[i], S[i+1..n]) \mid i \bmod 2 = 0 \} </tex>. Однако <tex> S[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

=====Слияние суффиксных массивов=====
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

=====Суффиксный массив для нечетных суффиксов=====
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку S[1..n] = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

=====Суффиксный массив для четных суффиксов=====
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

=====Слияние суффиксных массивов=====
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S[i..n-1] | i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n]S[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S[i..n-1] | i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S[i], S[i+1..n-1]) | i \bmod 3 = 0 \} </tex>, где <tex> S[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S[i], S[i+1..n-1]) </tex> и <tex> (S[j], S[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S[i], S[i+1], S[i+2..n-1]) </tex> и <tex> (S[j], S[j+1], S[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S[pos12], rank[pos12 + 1]) < Pair(S[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S[pos12], S[pos12 + 1], rank[pos12 + 2]) < Triple(S[pos0], S[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки (S[5], S[6], S[7..8]) и (S[0], S[1], S[2..8]).
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что №9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-09T05:55:22Z

Nastyastanchul: /* Алгоритм «разделяй и властвуй» */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

Для упрощения алгоритма вначале дополним нашу строку до четной длины (например, добавлением <tex>\$</tex> в конец). На шаге слияния мы сможем избавиться от него.

=====База рекурсии=====
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

=====Суффиксный массив для нечетных суффиксов=====

# Отобразим исходную строку <tex> S </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

=====Суффиксный массив для четных суффиксов=====
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S[i..n] | i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S[i], S[i+1..n]) | i \bmod 2 = 0 \} </tex>. Однако <tex> S[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

=====Слияние суффиксных массивов=====
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

=====Суффиксный массив для нечетных суффиксов=====
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку S[1..n] = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

=====Суффиксный массив для четных суффиксов=====
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

=====Слияние суффиксных массивов=====
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S[i..n-1] | i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n]S[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S[i..n-1] | i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S[i], S[i+1..n-1]) | i \bmod 3 = 0 \} </tex>, где <tex> S[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S[i], S[i+1..n-1]) </tex> и <tex> (S[j], S[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S[i], S[i+1], S[i+2..n-1]) </tex> и <tex> (S[j], S[j+1], S[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S[pos12], rank[pos12 + 1]) < Pair(S[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S[pos12], S[pos12 + 1], rank[pos12 + 2]) < Triple(S[pos0], S[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки (S[5], S[6], S[7..8]) и (S[0], S[1], S[2..8]).
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что №9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-09T05:49:53Z

Nastyastanchul: /* Алгоритм «разделяй и властвуй» */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

Для упрощения алгоритма вначале дополним нашу строку до четной длины (например, добавлением <tex>\$</tex> в конец). На шаге слияния мы сможем избавиться от него.

* '''База рекурсии'''
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

* '''Суффиксный массив для нечетных суффиксов'''

# Отобразим исходную строку <tex> S </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

* '''Суффиксный массив для четных суффиксов'''
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S[i..n] | i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S[i], S[i+1..n]) | i \bmod 2 = 0 \} </tex>. Однако <tex> S[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

* '''Суффиксный массив для нечетных суффиксов'''
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку S[1..n] = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

* '''Суффиксный массив для четных суффиксов'''
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

* '''Слияние суффиксных массивов'''
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S[i..n-1] | i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n]S[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S[i..n-1] | i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S[i], S[i+1..n-1]) | i \bmod 3 = 0 \} </tex>, где <tex> S[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S[i], S[i+1..n-1]) </tex> и <tex> (S[j], S[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S[i], S[i+1], S[i+2..n-1]) </tex> и <tex> (S[j], S[j+1], S[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S[pos12], rank[pos12 + 1]) < Pair(S[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S[pos12], S[pos12 + 1], rank[pos12 + 2]) < Triple(S[pos0], S[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки (S[5], S[6], S[7..8]) и (S[0], S[1], S[2..8]).
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что №9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-09T05:49:38Z

Nastyastanchul: /* Алгоритм «разделяй и властвуй» */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

Для упрощения алгоритма вначале дополним нашу строку до четной длины (например, добавлением <tex>$</tex> в конец). На шаге слияния мы сможем избавиться от него.

* '''База рекурсии'''
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

* '''Суффиксный массив для нечетных суффиксов'''

# Отобразим исходную строку <tex> S </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

* '''Суффиксный массив для четных суффиксов'''
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S[i..n] | i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S[i], S[i+1..n]) | i \bmod 2 = 0 \} </tex>. Однако <tex> S[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

* '''Суффиксный массив для нечетных суффиксов'''
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку S[1..n] = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

* '''Суффиксный массив для четных суффиксов'''
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

* '''Слияние суффиксных массивов'''
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S[i..n-1] | i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n]S[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S[i..n-1] | i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S[i], S[i+1..n-1]) | i \bmod 3 = 0 \} </tex>, где <tex> S[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S[i], S[i+1..n-1]) </tex> и <tex> (S[j], S[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S[i], S[i+1], S[i+2..n-1]) </tex> и <tex> (S[j], S[j+1], S[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S[pos12], rank[pos12 + 1]) < Pair(S[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S[pos12], S[pos12 + 1], rank[pos12 + 2]) < Triple(S[pos0], S[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки (S[5], S[6], S[7..8]) и (S[0], S[1], S[2..8]).
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что №9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-09T05:48:40Z

Nastyastanchul: /* Используемые обозначения */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S^*[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

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

* '''База рекурсии'''
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

* '''Суффиксный массив для нечетных суффиксов'''

# Отобразим исходную строку <tex> S </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

* '''Суффиксный массив для четных суффиксов'''
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S[i..n] | i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S[i], S[i+1..n]) | i \bmod 2 = 0 \} </tex>. Однако <tex> S[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

* '''Суффиксный массив для нечетных суффиксов'''
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку S[1..n] = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

* '''Суффиксный массив для четных суффиксов'''
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

* '''Слияние суффиксных массивов'''
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S[i..n-1] | i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n]S[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S[i..n-1] | i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S[i], S[i+1..n-1]) | i \bmod 3 = 0 \} </tex>, где <tex> S[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S[i], S[i+1..n-1]) </tex> и <tex> (S[j], S[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S[i], S[i+1], S[i+2..n-1]) </tex> и <tex> (S[j], S[j+1], S[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S[pos12], rank[pos12 + 1]) < Pair(S[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S[pos12], S[pos12 + 1], rank[pos12 + 2]) < Triple(S[pos0], S[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки (S[5], S[6], S[7..8]) и (S[0], S[1], S[2..8]).
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что №9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Сведение задачи LCA к задаче RMQ

2015-06-08T16:10:42Z

Nastyastanchul: /* Алгоритм */

{{Шаблон:Задача
|definition =
Пусть дано корневое дерево <tex>T</tex>. На вход подаются запросы вида <tex>(u,\;v)</tex>, для каждого запроса требуется найти их наименьшего общего предка.
}}
{{Определение
|id=lca_suf_tree
|definition = '''Наименьшим общим предком''' (англ. ''least common ancestor'') двух узлов <tex>u</tex> и <tex>v</tex> в корневом дереве <tex>T</tex> называется узел <tex>w</tex>, который среди всех узлов, являющихся предками как узла <tex>u</tex>, так и <tex>v</tex>, имеет наибольшую глубину.
}}

== Алгоритм ==
=== Идея ===
Будем решать задачу LCA, уже умея решать задачу RMQ. Тогда поиск наименьшего общего предка <tex>i</tex>-того и <tex>j</tex>-того элементов сводится к запросу минимума на отрезке массива, который будет введен позднее.

=== Препроцессинг ===
Для каждой вершины <tex>T</tex> определим глубину с помощью следующей рекурсивной формулы:
:<tex>\mathrm{depth}(u) = \begin{cases}
0 & u = \mathrm{root}(T),\\
\mathrm{depth}(v) + 1 & u = \mathrm{son}(v).
\end{cases}</tex>
Ясно, что глубина вершины элементарным образом поддерживается во время обхода в глубину.

Запустим [[Обход в глубину, цвета вершин|обход в глубину]] из корня, который будет вычислять значения следующих величин:
#Cписок глубин посещенных вершин <tex>d</tex>. Глубина текущей вершины добавляется в конец списка при входе в данную вершину, а также после каждого возвращения из её сына.
#Список посещений узлов <tex>\mathtt{vtx}</tex>, строящийся аналогично предыдущему, только добавляется не глубина а сама вершина.
#Значение функции <tex>\mathtt{I}[u]</tex>, возвращающей любой индекс в списке глубин <tex>d</tex>, по которому была записана глубина вершины <tex>u</tex> (например на момент входа в вершину).

=== Запрос ===
Будем считать, что <tex>\mathrm{rmq}(d,l,r)</tex> возвращает индекс минимального элемента в <tex>d</tex> на отрезке <tex>[l..r]</tex>. Тогда ответом на запрос <tex>\mathrm{lca}(u, v)</tex>, где <tex>\mathtt{I}[u] \leqslant \mathtt{I}[v]</tex>, будет <tex>\mathtt{vtx}[\mathrm{rmq}(d,\mathtt{I}[u], \mathtt{I}[v])]</tex>.

=== Доказательство корректности алгоритма ===
{{Теорема
|statement=
Наименьшему общему предку вершин <tex>u, v</tex> соответствует минимальная глубина на отрезке <tex>d[\mathtt{I}[u], \mathtt{I}[v]]</tex>.
|proof=
Рассмотрим два узла <tex>u, v</tex> корневого дерева <tex>T</tex>. Рассмотрим отрезок <tex>d[\mathtt{I}[u]..\mathtt{I}[v]]</tex>. Поскольку этот отрезок {{---}} путь из <tex>u</tex> в <tex>v</tex>, он проходит через их наименьшего общего предка <tex>w</tex> (в дереве есть только один простой путь между вершинами), а следовательно минимум на отрезке никак не больше глубины <tex>w</tex>. Заметим, что в момент добавления <tex>\mathtt{I}[u]</tex> обход посещал поддерево с корнем <tex>w</tex>. В момент добавления <tex>\mathtt{I}[v]</tex> мы все еще в поддереве с корнем <tex>w</tex>. Значит, и на отрезке между <tex>\mathtt{I}[u]</tex> и <tex>\mathtt{I}[v]</tex> мы находились внутри поддерева с корнем <tex>w</tex>. Отсюда сделаем заключение, что на рассматриваемом отрезке не посещалась вершина, отличная от <tex>w</tex>, с глубиной меньшей либо равной глубины <tex>w</tex>, т. к. подобной вершины нет в поддереве с корнем <tex>w</tex>.
}}.

== Пример ==
Рассмотрим дерево на рисунке 1. Найдем наименьшего общего предка вершин, помеченных красным цветом.
Список глубин, получающийся в результате обхода в глубину {{---}} <tex>[0, 1, 2, 1, 2, 1, 0, 1, 0].</tex>
Глубина наименьшего общего предка красных вершин равна минимуму на отрезке <tex>[2, 1, 0, 1].</tex>
[[Файл:Lca to rmq.png(2).png|thumb|left|Рисунок к примеру]]
<div style='clear:left;'></div>

== Сложность ==

Для нахождения минимального элемента на отрезке можно использовать [[Алгоритм Фарака-Колтона и Бендера|алгоритм Фарака-Колтона и Бендера]] для <tex>\pm 1RMQ</tex>, т. к. соседние элементы в списке глубин отличаются не более чем на единицу. Длина списка глубин составляет <tex>(2n - 1)</tex>, таким образом, препроцессинг работает за <tex>O(n)</tex>. Время выполнения запроса равно времени запроса минимального элемента на отрезке {{---}} <tex>O(1)</tex>.

== См.также ==
*[[Метод двоичного подъема]]
*[[Решение RMQ с помощью разреженной таблицы]]
*[[Алгоритм Фарака-Колтона и Бендера]]
*[[Сведение задачи RMQ к задаче LCA]]
== Источники информации ==
*[http://e-maxx.ru/algo/lca Наименьший общий предок. Нахождение за O (sqrt (N)) и O (log N) с препроцессингом O (N)]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Сведение задачи RMQ к задаче LCA

2015-06-08T15:52:41Z

Nastyastanchul: /* Описание */

{{Шаблон:Задача
|definition =Дан массив <tex>A[1..N]</tex>. Поступают запросы вида <tex>(i, j)</tex>, на каждый запрос требуется найти минимум в массиве <tex>A</tex>, начиная с позиции <tex>i</tex> и заканчивая позицией <tex>j</tex>.
}}

== Алгоритм ==
===Описание===
[[Файл:Wiki.PNG|thumb|right|300x150px|Пример декартового дерева]]
Будем решать задачу RMQ, уже умея решать задачу LCA. Для хранения решения задачи о LCA будем использовать [[декартово дерево по неявному ключу]]. Тогда минимум на отрезке от <tex> i </tex> до <tex> j </tex> будет равен наименьшему общему предку <tex>i</tex>-того и <tex>j</tex>-того элементов из декартова дерева.

Декартово дерево по неявному ключу на массиве <tex>A[1..N]</tex> {{---}} это бинарное дерево, допускающее следующее рекурсивное построение:
* Корнем дерева является элемент массива, имеющий минимальное значение <tex>A</tex>, скажем <tex>A[i]</tex>. Если минимальных элементов несколько, можно взять любой.
* Левым поддеревом является декартово дерево на массиве <tex>A[1..i-1]</tex>.
* Правым поддеревом является декартово дерево на массиве <tex>A[i+1..N]</tex>.

Здесь и далее <tex>A[i]</tex> будет также использоваться для обозначения соответствующей вершины дерева.

Построим декартово дерево на массиве <tex>A</tex>. Тогда <tex>RMQ(i, j)</tex> = <tex>LCA(A[i], A[j])</tex>.
<br clear="all">

=== Корректность ===
{{Теорема
|statement=
<tex>RMQ(i, j)</tex> = <tex>LCA(A[i], A[j])</tex>.
|proof=
Положим <tex>w = LCA(A[i], A[j])</tex>.

Заметим, что <tex>A[i]</tex> и <tex>A[j]</tex> не принадлежат одновременно либо правому, либо левому поддереву <tex>w</tex>, потому как тогда бы соответствующий сын находился на большей глубине, чем <tex>w</tex>, и также являлся предком как <tex>A[i]</tex> так и <tex>A[j]</tex>, что противоречит определению <tex>LCA</tex>. Из этого замечанию следует, что <tex>w</tex> лежит между <tex>A[i]</tex> и <tex>A[j]</tex> и, следовательно, принадлежит отрезку <tex>A[i..j]</tex>.

По построению мы также знаем, что:
# Любая вершина дерева имеет свое значение меньшим либо равным значению её детей.
# Поддерево с корнем в <tex>w</tex> содержит в себе подмассив <tex>A[i..j]</tex>.

Суммируя, получаем, что <tex>w</tex> имеет минимальное значение на отрезке, покрывающем <tex>A[i..j]</tex>, и принадлежит отрезку <tex>A[i..j]</tex>, отсюда <tex>RMQ(i, j) = w</tex>.
}}

=== Сложность ===
Существует [[Декартово дерево#Построение декартова дерева|алгоритм]], который строит декартово дерево за <tex>O(n)</tex>. Используя [[Сведение задачи LCA к задаче RMQ | алгоритм построения LCA]], получаем:
препроцессинг для <tex>LCA</tex> {{---}} <tex>O(n)</tex> и ответ на запрос {{---}} <tex>O(1)</tex>.

Нам нужно единожды построить декартово дерево за <tex>O(n)</tex>, единожды провести препроцессинг за <tex>O(n)</tex> и отвечать на запросы за <tex>O(1)</tex>.

В итоге получили <tex>RMQ</tex> с построением за <tex>O(n)</tex> и ответом на запрос за <tex>O(1)</tex>.

== См.также ==
*[[Сведение задачи LCA к задаче RMQ]]
*[[Декартово дерево]]
*[[Алгоритм Фарака-Колтона и Бендера]]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Сведение задачи RMQ к задаче LCA

2015-06-08T15:46:45Z

Nastyastanchul: /* Алгоритм */

{{Шаблон:Задача
|definition =Дан массив <tex>A[1..N]</tex>. Поступают запросы вида <tex>(i, j)</tex>, на каждый запрос требуется найти минимум в массиве <tex>A</tex>, начиная с позиции <tex>i</tex> и заканчивая позицией <tex>j</tex>.
}}

== Алгоритм ==
===Описание===
[[Файл:Wiki.PNG|thumb|right|300x150px|Пример декартового дерева]]
Будем решать задачу RMQ, уже умея решать задачу LCA, для хранения решения задачи о LCA будем использовать [[декартово дерево по неявному ключу]].

Декартово дерево по неявному ключу на массиве <tex>A[1..N]</tex> {{---}} это бинарное дерево, допускающее следующее рекурсивное построение:
* Корнем дерева является элемент массива, имеющий минимальное значение <tex>A</tex>, скажем <tex>A[i]</tex>. Если минимальных элементов несколько, можно взять любой.
* Левым поддеревом является декартово дерево на массиве <tex>A[1..i-1]</tex>.
* Правым поддеревом является декартово дерево на массиве <tex>A[i+1..N]</tex>.

Здесь и далее <tex>A[i]</tex> будет также использоваться для обозначения соответствующей вершины дерева.

Построим декартово дерево на массиве <tex>A</tex>. Тогда <tex>RMQ(i, j)</tex> = <tex>LCA(A[i], A[j])</tex>.
<br clear="all">

=== Корректность ===
{{Теорема
|statement=
<tex>RMQ(i, j)</tex> = <tex>LCA(A[i], A[j])</tex>.
|proof=
Положим <tex>w = LCA(A[i], A[j])</tex>.

Заметим, что <tex>A[i]</tex> и <tex>A[j]</tex> не принадлежат одновременно либо правому, либо левому поддереву <tex>w</tex>, потому как тогда бы соответствующий сын находился на большей глубине, чем <tex>w</tex>, и также являлся предком как <tex>A[i]</tex> так и <tex>A[j]</tex>, что противоречит определению <tex>LCA</tex>. Из этого замечанию следует, что <tex>w</tex> лежит между <tex>A[i]</tex> и <tex>A[j]</tex> и, следовательно, принадлежит отрезку <tex>A[i..j]</tex>.

По построению мы также знаем, что:
# Любая вершина дерева имеет свое значение меньшим либо равным значению её детей.
# Поддерево с корнем в <tex>w</tex> содержит в себе подмассив <tex>A[i..j]</tex>.

Суммируя, получаем, что <tex>w</tex> имеет минимальное значение на отрезке, покрывающем <tex>A[i..j]</tex>, и принадлежит отрезку <tex>A[i..j]</tex>, отсюда <tex>RMQ(i, j) = w</tex>.
}}

=== Сложность ===
Существует [[Декартово дерево#Построение декартова дерева|алгоритм]], который строит декартово дерево за <tex>O(n)</tex>. Используя [[Сведение задачи LCA к задаче RMQ | алгоритм построения LCA]], получаем:
препроцессинг для <tex>LCA</tex> {{---}} <tex>O(n)</tex> и ответ на запрос {{---}} <tex>O(1)</tex>.

Нам нужно единожды построить декартово дерево за <tex>O(n)</tex>, единожды провести препроцессинг за <tex>O(n)</tex> и отвечать на запросы за <tex>O(1)</tex>.

В итоге получили <tex>RMQ</tex> с построением за <tex>O(n)</tex> и ответом на запрос за <tex>O(1)</tex>.

== См.также ==
*[[Сведение задачи LCA к задаче RMQ]]
*[[Декартово дерево]]
*[[Алгоритм Фарака-Колтона и Бендера]]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Сведение задачи LCA к задаче RMQ

2015-06-08T15:22:52Z

Nastyastanchul: /* Запрос */

{{Шаблон:Задача
|definition =
Пусть дано корневое дерево <tex>T</tex>. На вход подаются запросы вида <tex>(u,\;v)</tex>, для каждого запроса требуется найти их наименьшего общего предка.
}}
{{Определение
|id=lca_suf_tree
|definition = '''Наименьшим общим предком''' (англ. ''least common ancestor'') двух узлов <tex>u</tex> и <tex>v</tex> в корневом дереве <tex>T</tex> называется узел <tex>w</tex>, который среди всех узлов, являющихся предками как узла <tex>u</tex>, так и <tex>v</tex>, имеет наибольшую глубину.
}}

== Алгоритм ==
=== Препроцессинг ===
Для каждой вершины <tex>T</tex> определим глубину с помощью следующей рекурсивной формулы:
:<tex>\mathrm{depth}(u) = \begin{cases}
0 & u = \mathrm{root}(T),\\
\mathrm{depth}(v) + 1 & u = \mathrm{son}(v).
\end{cases}</tex>
Ясно, что глубина вершины элементарным образом поддерживается во время обхода в глубину.

Запустим [[Обход в глубину, цвета вершин|обход в глубину]] из корня, который будет вычислять значения следующих величин:
#Cписок глубин посещенных вершин <tex>d</tex>. Глубина текущей вершины добавляется в конец списка при входе в данную вершину, а также после каждого возвращения из её сына.
#Список посещений узлов <tex>\mathtt{vtx}</tex>, строящийся аналогично предыдущему, только добавляется не глубина а сама вершина.
#Значение функции <tex>\mathtt{I}[u]</tex>, возвращающей любой индекс в списке глубин <tex>d</tex>, по которому была записана глубина вершины <tex>u</tex> (например на момент входа в вершину).

=== Запрос ===
Будем считать, что <tex>\mathrm{rmq}(d,l,r)</tex> возвращает индекс минимального элемента в <tex>d</tex> на отрезке <tex>[l..r]</tex>. Тогда ответом на запрос <tex>\mathrm{lca}(u, v)</tex>, где <tex>\mathtt{I}[u] \leqslant \mathtt{I}[v]</tex>, будет <tex>\mathtt{vtx}[\mathrm{rmq}(d,\mathtt{I}[u], \mathtt{I}[v])]</tex>.

=== Доказательство корректности алгоритма ===
{{Теорема
|statement=
Наименьшему общему предку вершин <tex>u, v</tex> соответствует минимальная глубина на отрезке <tex>d[\mathtt{I}[u], \mathtt{I}[v]]</tex>.
|proof=
Рассмотрим два узла <tex>u, v</tex> корневого дерева <tex>T</tex>. Рассмотрим отрезок <tex>d[\mathtt{I}[u]..\mathtt{I}[v]]</tex>. Поскольку этот отрезок {{---}} путь из <tex>u</tex> в <tex>v</tex>, он проходит через их наименьшего общего предка <tex>w</tex> (в дереве есть только один простой путь между вершинами), а следовательно минимум на отрезке никак не больше глубины <tex>w</tex>. Заметим, что в момент добавления <tex>\mathtt{I}[u]</tex> обход посещал поддерево с корнем <tex>w</tex>. В момент добавления <tex>\mathtt{I}[v]</tex> мы все еще в поддереве с корнем <tex>w</tex>. Значит, и на отрезке между <tex>\mathtt{I}[u]</tex> и <tex>\mathtt{I}[v]</tex> мы находились внутри поддерева с корнем <tex>w</tex>. Отсюда сделаем заключение, что на рассматриваемом отрезке не посещалась вершина, отличная от <tex>w</tex>, с глубиной меньшей либо равной глубины <tex>w</tex>, т. к. подобной вершины нет в поддереве с корнем <tex>w</tex>.
}}.

== Пример ==
Рассмотрим дерево на рисунке 1. Найдем наименьшего общего предка вершин, помеченных красным цветом.
Список глубин, получающийся в результате обхода в глубину {{---}} <tex>[0, 1, 2, 1, 2, 1, 0, 1, 0].</tex>
Глубина наименьшего общего предка красных вершин равна минимуму на отрезке <tex>[2, 1, 0, 1].</tex>
[[Файл:Lca to rmq.png(2).png|thumb|left|Рисунок к примеру]]
<div style='clear:left;'></div>

== Сложность ==

Для нахождения минимального элемента на отрезке можно использовать [[Алгоритм Фарака-Колтона и Бендера|алгоритм Фарака-Колтона и Бендера]] для <tex>\pm 1RMQ</tex>, т. к. соседние элементы в списке глубин отличаются не более чем на единицу. Длина списка глубин составляет <tex>(2n - 1)</tex>, таким образом, препроцессинг работает за <tex>O(n)</tex>. Время выполнения запроса равно времени запроса минимального элемента на отрезке {{---}} <tex>O(1)</tex>.

== См.также ==
*[[Метод двоичного подъема]]
*[[Решение RMQ с помощью разреженной таблицы]]
*[[Алгоритм Фарака-Колтона и Бендера]]
*[[Сведение задачи RMQ к задаче LCA]]
== Источники информации ==
*[http://e-maxx.ru/algo/lca Наименьший общий предок. Нахождение за O (sqrt (N)) и O (log N) с препроцессингом O (N)]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Сведение задачи LCA к задаче RMQ

2015-06-07T06:43:28Z

Nastyastanchul: /* Препроцессинг */

{{Шаблон:Задача
|definition =
Пусть дано корневое дерево <tex>T</tex>. На вход подаются запросы вида <tex>(u,\;v)</tex>, для каждого запроса требуется найти их наименьшего общего предка.
}}
{{Определение
|id=lca_suf_tree
|definition = '''Наименьшим общим предком''' (англ. ''least common ancestor'') двух узлов <tex>u</tex> и <tex>v</tex> в корневом дереве <tex>T</tex> называется узел <tex>w</tex>, который среди всех узлов, являющихся предками как узла <tex>u</tex>, так и <tex>v</tex>, имеет наибольшую глубину.
}}

== Алгоритм ==
=== Препроцессинг ===
Для каждой вершины <tex>T</tex> определим глубину с помощью следующей рекурсивной формулы:
:<tex>\mathrm{depth}(u) = \begin{cases}
0 & u = \mathrm{root}(T),\\
\mathrm{depth}(v) + 1 & u = \mathrm{son}(v).
\end{cases}</tex>
Ясно, что глубина вершины элементарным образом поддерживается во время обхода в глубину.

Запустим [[Обход в глубину, цвета вершин|обход в глубину]] из корня, который будет вычислять значения следующих величин:
#Cписок глубин посещенных вершин <tex>d</tex>. Глубина текущей вершины добавляется в конец списка при входе в данную вершину, а также после каждого возвращения из её сына.
#Список посещений узлов <tex>\mathtt{vtx}</tex>, строящийся аналогично предыдущему, только добавляется не глубина а сама вершина.
#Значение функции <tex>\mathtt{I}[u]</tex>, возвращающей любой индекс в списке глубин <tex>d</tex>, по которому была записана глубина вершины <tex>u</tex> (например на момент входа в вершину).

=== Запрос ===
Будем считать, что <tex>\mathrm{rmq}(d,l,r)</tex> возвращает индекс минимального элемента в <tex>d</tex> на отрезке <tex>[l..r]</tex>. Тогда ответом на запрос <tex>\mathrm{lca}(u, v)</tex>, где <tex>I[u] \leqslant \mathtt{I}[v]</tex>, будет <tex>\mathtt{vtx}[\mathrm{rmq}(d,\mathtt{I}[u], \mathtt{I}[v])]</tex>.

=== Доказательство корректности алгоритма ===
{{Теорема
|statement=
Наименьшему общему предку вершин <tex>u, v</tex> соответствует минимальная глубина на отрезке <tex>d[\mathtt{I}[u], \mathtt{I}[v]]</tex>.
|proof=
Рассмотрим два узла <tex>u, v</tex> корневого дерева <tex>T</tex>. Рассмотрим отрезок <tex>d[\mathtt{I}[u]..\mathtt{I}[v]]</tex>. Поскольку этот отрезок {{---}} путь из <tex>u</tex> в <tex>v</tex>, он проходит через их наименьшего общего предка <tex>w</tex> (в дереве есть только один простой путь между вершинами), а следовательно минимум на отрезке никак не больше глубины <tex>w</tex>. Заметим, что в момент добавления <tex>\mathtt{I}[u]</tex> обход посещал поддерево с корнем <tex>w</tex>. В момент добавления <tex>\mathtt{I}[v]</tex> мы все еще в поддереве с корнем <tex>w</tex>. Значит, и на отрезке между <tex>\mathtt{I}[u]</tex> и <tex>\mathtt{I}[v]</tex> мы находились внутри поддерева с корнем <tex>w</tex>. Отсюда сделаем заключение, что на рассматриваемом отрезке не посещалась вершина, отличная от <tex>w</tex>, с глубиной меньшей либо равной глубины <tex>w</tex>, т. к. подобной вершины нет в поддереве с корнем <tex>w</tex>.
}}.

== Пример ==
Рассмотрим дерево на рисунке 1. Найдем наименьшего общего предка вершин, помеченных красным цветом.
Список глубин, получающийся в результате обхода в глубину {{---}} <tex>[0, 1, 2, 1, 2, 1, 0, 1, 0].</tex>
Глубина наименьшего общего предка красных вершин равна минимуму на отрезке <tex>[2, 1, 0, 1].</tex>
[[Файл:Lca to rmq.png(2).png|thumb|left|Рисунок к примеру]]
<div style='clear:left;'></div>

== Сложность ==

Для нахождения минимального элемента на отрезке можно использовать [[Алгоритм Фарака-Колтона и Бендера|алгоритм Фарака-Колтона и Бендера]] для <tex>\pm 1RMQ</tex>, т. к. соседние элементы в списке глубин отличаются не более чем на единицу. Длина списка глубин составляет <tex>(2n - 1)</tex>, таким образом, препроцессинг работает за <tex>O(n)</tex>. Время выполнения запроса равно времени запроса минимального элемента на отрезке {{---}} <tex>O(1)</tex>.

== См.также ==
*[[Метод двоичного подъема]]
*[[Решение RMQ с помощью разреженной таблицы]]
*[[Алгоритм Фарака-Колтона и Бендера]]
*[[Сведение задачи RMQ к задаче LCA]]
== Источники информации ==
*[http://e-maxx.ru/algo/lca Наименьший общий предок. Нахождение за O (sqrt (N)) и O (log N) с препроцессингом O (N)]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Сведение задачи RMQ к задаче LCA

2015-06-07T06:41:44Z

Nastyastanchul:

{{Шаблон:Задача
|definition =Дан массив <tex>A[1..N]</tex>. Поступают запросы вида <tex>(i, j)</tex>, на каждый запрос требуется найти минимум в массиве <tex>A</tex>, начиная с позиции <tex>i</tex> и заканчивая позицией <tex>j</tex>.
}}

== Алгоритм ==
===Описание===
[[Файл:Wiki.PNG|thumb|right|300x150px|Пример декартового дерева]]
Для нахождения минимума на отрезке будем использовать информацию о наименьшем общем предке. Для хранения наименьших общих предков будем использовать [[декартово дерево по неявному ключу]].

Декартово дерево по неявному ключу на массиве <tex>A[1..N]</tex> {{---}} это бинарное дерево, допускающее следующее рекурсивное построение:
* Корнем дерева является элемент массива, имеющий минимальное значение <tex>A</tex>, скажем <tex>A[i]</tex>. Если минимальных элементов несколько, можно взять любой.
* Левым поддеревом является декартово дерево на массиве <tex>A[1..i-1]</tex>.
* Правым поддеревом является декартово дерево на массиве <tex>A[i+1..N]</tex>.

Здесь и далее <tex>A[i]</tex> будет также использоваться для обозначения соответствующей вершины дерева.

Построим декартово дерево на массиве <tex>A</tex>. Тогда <tex>RMQ(i, j)</tex> = <tex>LCA(A[i], A[j])</tex>.
<br clear="all">

=== Корректность ===
{{Теорема
|statement=
<tex>RMQ(i, j)</tex> = <tex>LCA(A[i], A[j])</tex>.
|proof=
Положим <tex>w = LCA(A[i], A[j])</tex>.

Заметим, что <tex>A[i]</tex> и <tex>A[j]</tex> не принадлежат одновременно либо правому, либо левому поддереву <tex>w</tex>, потому как тогда бы соответствующий сын находился на большей глубине, чем <tex>w</tex>, и также являлся предком как <tex>A[i]</tex> так и <tex>A[j]</tex>, что противоречит определению <tex>LCA</tex>. Из этого замечанию следует, что <tex>w</tex> лежит между <tex>A[i]</tex> и <tex>A[j]</tex> и, следовательно, принадлежит отрезку <tex>A[i..j]</tex>.

По построению мы также знаем, что:
# Любая вершина дерева имеет свое значение меньшим либо равным значению её детей.
# Поддерево с корнем в <tex>w</tex> содержит в себе подмассив <tex>A[i..j]</tex>.

Суммируя, получаем, что <tex>w</tex> имеет минимальное значение на отрезке, покрывающем <tex>A[i..j]</tex>, и принадлежит отрезку <tex>A[i..j]</tex>, отсюда <tex>RMQ(i, j) = w</tex>.
}}

=== Сложность ===
Существует [[Декартово дерево#Построение декартова дерева|алгоритм]], который строит декартово дерево за <tex>O(n)</tex>. Используя [[Сведение задачи LCA к задаче RMQ | алгоритм построения LCA]], получаем:
препроцессинг для <tex>LCA</tex> {{---}} <tex>O(n)</tex> и ответ на запрос {{---}} <tex>O(1)</tex>.

Нам нужно единожды построить декартово дерево за <tex>O(n)</tex>, единожды провести препроцессинг за <tex>O(n)</tex> и отвечать на запросы за <tex>O(1)</tex>.

В итоге получили <tex>RMQ</tex> с построением за <tex>O(n)</tex> и ответом на запрос за <tex>O(1)</tex>.

== См.также ==
*[[Сведение задачи LCA к задаче RMQ]]
*[[Декартово дерево]]
*[[Алгоритм Фарака-Колтона и Бендера]]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Алгоритм Карккайнена-Сандерса

2015-06-07T06:39:25Z

Nastyastanchul: /* Пример */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

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

* '''База рекурсии'''
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

* '''Суффиксный массив для нечетных суффиксов'''

# Отобразим исходную строку <tex> S </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

* '''Суффиксный массив для четных суффиксов'''
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S[i..n] | i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S[i], S[i+1..n]) | i \bmod 2 = 0 \} </tex>. Однако <tex> S[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

* '''Суффиксный массив для нечетных суффиксов'''
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку S[1..n] = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

* '''Суффиксный массив для четных суффиксов'''
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

* '''Слияние суффиксных массивов'''
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S[i..n-1] | i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n]S[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S[i..n-1] | i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S[i], S[i+1..n-1]) | i \bmod 3 = 0 \} </tex>, где <tex> S[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S[i], S[i+1..n-1]) </tex> и <tex> (S[j], S[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S[i], S[i+1], S[i+2..n-1]) </tex> и <tex> (S[j], S[j+1], S[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S[pos12], rank[pos12 + 1]) < Pair(S[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S[pos12], S[pos12 + 1], rank[pos12 + 2]) < Triple(S[pos0], S[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''cab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки (S[5], S[6], S[7..8]) и (S[0], S[1], S[2..8]).
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что №9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-07T06:32:35Z

Nastyastanchul: /* Пример */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

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

* '''База рекурсии'''
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

* '''Суффиксный массив для нечетных суффиксов'''

# Отобразим исходную строку <tex> S </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

* '''Суффиксный массив для четных суффиксов'''
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S[i..n] | i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S[i], S[i+1..n]) | i \bmod 2 = 0 \} </tex>. Однако <tex> S[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

* '''Суффиксный массив для нечетных суффиксов'''
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку S[1..n] = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

* '''Суффиксный массив для четных суффиксов'''
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

* '''Слияние суффиксных массивов'''
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S[i..n-1] | i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n]S[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S[i..n-1] | i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S[i], S[i+1..n-1]) | i \bmod 3 = 0 \} </tex>, где <tex> S[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S[i], S[i+1..n-1]) </tex> и <tex> (S[j], S[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S[i], S[i+1], S[i+2..n-1]) </tex> и <tex> (S[j], S[j+1], S[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S[pos12], rank[pos12 + 1]) < Pair(S[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S[pos12], S[pos12 + 1], rank[pos12 + 2]) < Triple(S[pos0], S[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки <tex>abbacab</tex>. После добавления защитного символа и дополнения до кратной трем длины, получим <tex>abbacab$$</tex>.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: <tex>bba</tex>, <tex>cab</tex>, <tex>\$\$\$</tex>, соответствующими равным 2 по модулю 3 — <tex>bac</tex>, <tex>ab\$</tex>, <tex>\$\$\$</tex>. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы <tex>bba</tex>, <tex>cab</tex>, <tex>\$\$\$</tex>, <tex>bac</tex>, <tex>ab\$</tex>, которые после сортировки получат номера 3, 4, 0, 2, 1 соответственно.
# Строкой <tex>bbacab\$\$\$bacab\$\$\$\$</tex> в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = 340210.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [(<tex>b</tex>, 7), (<tex>a</tex>, 1), (<tex>a</tex>, 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [(<tex>a</tex>, 1), (<tex>a</tex>, 4), (<tex>b</tex>, 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки (S[5], S[6], S[7..8]) и (S[0], S[1], S[2..8]).
# После получения относительного порядка суффиксов, получим тройки (<tex>a</tex>, <tex>b</tex>, 1) и (<tex>a</tex>, <tex>b</tex>, 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ <tex>\$</tex> в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что №9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-07T06:21:10Z

Nastyastanchul: /* Пример */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

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

* '''База рекурсии'''
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

* '''Суффиксный массив для нечетных суффиксов'''

# Отобразим исходную строку <tex> S </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

* '''Суффиксный массив для четных суффиксов'''
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S[i..n] | i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S[i], S[i+1..n]) | i \bmod 2 = 0 \} </tex>. Однако <tex> S[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

* '''Суффиксный массив для нечетных суффиксов'''
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку S[1..n] = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

* '''Суффиксный массив для четных суффиксов'''
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

* '''Слияние суффиксных массивов'''
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S[i..n-1] | i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n]S[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S[i..n-1] | i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S[i], S[i+1..n-1]) | i \bmod 3 = 0 \} </tex>, где <tex> S[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S[i], S[i+1..n-1]) </tex> и <tex> (S[j], S[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S[i], S[i+1], S[i+2..n-1]) </tex> и <tex> (S[j], S[j+1], S[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S[pos12], rank[pos12 + 1]) < Pair(S[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S[pos12], S[pos12 + 1], rank[pos12 + 2]) < Triple(S[pos0], S[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''ab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соотвествтенно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = '''340210'''.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [('''b''', 7), ('''a''', 1), ('''a''', 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки (S[5], S[6], S[7..8]) и (S[0], S[1], S[2..8]).
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ '''$''' в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> acab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> b\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbacab\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> cab\$\$ </tex>
|}
Заметим, что №9 будет выброшен, так как в начале алгоритма был добавлен один <tex> \$ </tex> к строке

{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-07T06:12:03Z

Nastyastanchul: /* Пример */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

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

* '''База рекурсии'''
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

* '''Суффиксный массив для нечетных суффиксов'''

# Отобразим исходную строку <tex> S </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

* '''Суффиксный массив для четных суффиксов'''
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S[i..n] | i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S[i], S[i+1..n]) | i \bmod 2 = 0 \} </tex>. Однако <tex> S[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

* '''Суффиксный массив для нечетных суффиксов'''
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку S[1..n] = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

* '''Суффиксный массив для четных суффиксов'''
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

* '''Слияние суффиксных массивов'''
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:

{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| №
!style="background-color:#EEE"| Подстрока
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 9 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 8 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> \$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 7 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> a\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 6 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> aa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 0 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> ababbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 2 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> abbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 5 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> baa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 1 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> babbbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 4 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbaa\$\$ </tex>
|-
|style="background-color:#FFF;padding:2px 30px"| <tex> 3 </tex>
|style="background-color:#FFF;padding:2px 30px"| <tex> bbbaa\$\$ </tex>
|}

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S[i..n-1] | i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n]S[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S[i..n-1] | i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S[i], S[i+1..n-1]) | i \bmod 3 = 0 \} </tex>, где <tex> S[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S[i], S[i+1..n-1]) </tex> и <tex> (S[j], S[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S[i], S[i+1], S[i+2..n-1]) </tex> и <tex> (S[j], S[j+1], S[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S[pos12], rank[pos12 + 1]) < Pair(S[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S[pos12], S[pos12 + 1], rank[pos12 + 2]) < Triple(S[pos0], S[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''ab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соотвествтенно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = '''340210'''.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [('''b''', 7), ('''a''', 1), ('''a''', 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки (S[5], S[6], S[7..8]) и (S[0], S[1], S[2..8]).
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ '''$''' в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].
8 '''$''' (будет выброшен, так как в начале алгоритма добавляли один '''$''' к строке)
7 '''$$'''
5 '''ab$$'''
0 '''abbacab$$'''
3 '''acab$$'''
6 '''b$$'''
2 '''bacab$$'''
1 '''bbacab$$'''
4 '''cab$$'''
{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-06T21:21:10Z

Nastyastanchul: /* Алгоритм Карккайнена-Сандерса */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

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

* '''База рекурсии'''
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

* '''Суффиксный массив для нечетных суффиксов'''

# Отобразим исходную строку <tex> S </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

* '''Суффиксный массив для четных суффиксов'''
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S[i..n] | i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S[i], S[i+1..n]) | i \bmod 2 = 0 \} </tex>. Однако <tex> S[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

* '''Суффиксный массив для нечетных суффиксов'''
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку S[1..n] = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

* '''Суффиксный массив для четных суффиксов'''
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

* '''Слияние суффиксных массивов'''
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:
9 '''$'''
8 '''$$'''
7 '''a$$'''
6 '''aa$$'''
0 '''ababbbaa$$'''
2 '''abbbaa$$'''
5 '''baa$$'''
1 '''babbbaa$$'''
4 '''bbaa$$'''
3 '''bbbaa$$'''

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Суффиксный массив для позиций не кратных 3'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S[i..n-1] | i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n]S[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Суффиксный массив для позиций кратных 3'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S[i..n-1] | i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S[i], S[i+1..n-1]) | i \bmod 3 = 0 \} </tex>, где <tex> S[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S[i], S[i+1..n-1]) </tex> и <tex> (S[j], S[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S[i], S[i+1], S[i+2..n-1]) </tex> и <tex> (S[j], S[j+1], S[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S[pos12], rank[pos12 + 1]) < Pair(S[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S[pos12], S[pos12 + 1], rank[pos12 + 2]) < Triple(S[pos0], S[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Суффиксный массив для позиций не кратных 3'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''ab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соотвествтенно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = '''340210'''.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Суффиксный массив для позиций кратных 3'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [('''b''', 7), ('''a''', 1), ('''a''', 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Слияние суффиксных массивов'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки (S[5], S[6], S[7..8]) и (S[0], S[1], S[2..8]).
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ '''$''' в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].
8 '''$''' (будет выброшен, так как в начале алгоритма добавляли один '''$''' к строке)
7 '''$$'''
5 '''ab$$'''
0 '''abbacab$$'''
3 '''acab$$'''
6 '''b$$'''
2 '''bacab$$'''
1 '''bbacab$$'''
4 '''cab$$'''
{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-06T09:38:01Z

Nastyastanchul: /* Алгоритм «разделяй и властвуй» */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

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

* '''База рекурсии'''
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

* '''Суффиксный массив для нечетных суффиксов'''

# Отобразим исходную строку <tex> S </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

* '''Суффиксный массив для четных суффиксов'''
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S[i..n] | i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S[i], S[i+1..n]) | i \bmod 2 = 0 \} </tex>. Однако <tex> S[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

* '''Слияние суффиксных массивов'''
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

* '''Суффиксный массив для нечетных суффиксов'''
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку S[1..n] = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

* '''Суффиксный массив для четных суффиксов'''
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

* '''Слияние суффиксных массивов'''
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:
9 '''$'''
8 '''$$'''
7 '''a$$'''
6 '''aa$$'''
0 '''ababbbaa$$'''
2 '''abbbaa$$'''
5 '''baa$$'''
1 '''babbbaa$$'''
4 '''bbaa$$'''
3 '''bbbaa$$'''

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Шаг 1'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S[i..n-1] | i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n]S[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Шаг 2'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S[i..n-1] | i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S[i], S[i+1..n-1]) | i \bmod 3 = 0 \} </tex>, где <tex> S[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Шаг 3'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S[i], S[i+1..n-1]) </tex> и <tex> (S[j], S[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S[i], S[i+1], S[i+2..n-1]) </tex> и <tex> (S[j], S[j+1], S[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S[pos12], rank[pos12 + 1]) < Pair(S[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S[pos12], S[pos12 + 1], rank[pos12 + 2]) < Triple(S[pos0], S[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Шаг 1'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''ab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соотвествтенно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = '''340210'''.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Шаг 2'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [('''b''', 7), ('''a''', 1), ('''a''', 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Шаг 3'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки (S[5], S[6], S[7..8]) и (S[0], S[1], S[2..8]).
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ '''$''' в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].
8 '''$''' (будет выброшен, так как в начале алгоритма добавляли один '''$''' к строке)
7 '''$$'''
5 '''ab$$'''
0 '''abbacab$$'''
3 '''acab$$'''
6 '''b$$'''
2 '''bacab$$'''
1 '''bbacab$$'''
4 '''cab$$'''
{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-06T08:51:48Z

Nastyastanchul: /* Алгоритм Карккайнена-Сандерса */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

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

* '''База рекурсии'''
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

* '''Шаг 1'''
На первом шаге мы строим суффиксный массив <tex> A_{S_o} </tex> для нечетных суффиксов строки <tex> S </tex>.

# Отобразим исходную строку <tex> S </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

* '''Шаг 2'''
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S[i..n] | i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S[i], S[i+1..n]) | i \bmod 2 = 0 \} </tex>. Однако <tex> S[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

* '''Шаг 3'''
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

* '''Шаг 1'''
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку S[1..n] = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

* '''Шаг 2'''
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

* '''Шаг 3'''
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:
9 '''$'''
8 '''$$'''
7 '''a$$'''
6 '''aa$$'''
0 '''ababbbaa$$'''
2 '''abbbaa$$'''
5 '''baa$$'''
1 '''babbbaa$$'''
4 '''bbaa$$'''
3 '''bbbaa$$'''

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex>.

* '''База рекурсии'''
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

* '''Шаг 1'''
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S[i..n-1] | i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n]S[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

* '''Шаг 2'''
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S[i..n-1] | i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S[i], S[i+1..n-1]) | i \bmod 3 = 0 \} </tex>, где <tex> S[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

* '''Шаг 3'''
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S[i], S[i+1..n-1]) </tex> и <tex> (S[j], S[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S[i], S[i+1], S[i+2..n-1]) </tex> и <tex> (S[j], S[j+1], S[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S[pos12], rank[pos12 + 1]) < Pair(S[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S[pos12], S[pos12 + 1], rank[pos12 + 2]) < Triple(S[pos0], S[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
* '''Шаг 1'''
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''ab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соотвествтенно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = '''340210'''.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

* '''Шаг 2'''
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [('''b''', 7), ('''a''', 1), ('''a''', 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
* '''Шаг 3'''
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки (S[5], S[6], S[7..8]) и (S[0], S[1], S[2..8]).
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ '''$''' в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].
8 '''$''' (будет выброшен, так как в начале алгоритма добавляли один '''$''' к строке)
7 '''$$'''
5 '''ab$$'''
0 '''abbacab$$'''
3 '''acab$$'''
6 '''b$$'''
2 '''bacab$$'''
1 '''bbacab$$'''
4 '''cab$$'''
{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Алгоритм Карккайнена-Сандерса

2015-06-06T08:49:52Z

Nastyastanchul: /* Алгоритм «разделяй и властвуй» */

'''Алгоритм Карккайнена-Сандерса''' (Kärkkäinen, Sanders) — алгоритм построения [[суффиксный массив | суффиксного массива]] за линейное время.

__TOC__

== Используемые обозначения ==
* В данном конспекте используется 0-индексация.
* <tex>S[i..j] </tex> — подстрока строки <tex> S </tex> с <tex>i</tex>-го по <tex>j</tex>-й символы включительно.
* Пусть длина строки <tex> S </tex> равна <tex> n </tex>. Обозначим <tex> S[i..j] </tex>, где <tex> j \geqslant n </tex> как строку <tex> S[i..n-1] </tex>, дополненную защитными символами <tex> \$ </tex> до длины <tex> n </tex>.

== Алгоритм «разделяй и властвуй» ==

{{Определение
|definition=
'''Четным суффиксом''' назовем суффикс, начинающийся в четной позиции. <br>
'''Нечетным суффиксом''' — суффикс, начинающийся в нечетной позиции.
}}

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

Получили асимптотическое уравнение <tex> T(n) = T\left( \dfrac{n}{2}\right) + O(n) </tex>, решением которого является <tex> T(n) = O(n) </tex>.

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

* '''База рекурсии'''
Если длина текущей строки <tex> S </tex> меньше двух, надо выполнить обычное сравнение суффиксов.

* '''Шаг 1'''
На первом шаге мы строим суффиксный массив <tex> A_{S_o} </tex> для нечетных суффиксов строки <tex> S </tex>.

# Отобразим исходную строку <tex> S </tex> длины <tex> n </tex> в строку <tex> S' </tex> длины <tex> \dfrac{n}{2} </tex> следующим образом:
#* Сделаем список, состоящий из пар символов вида <tex> S[i..i + 1] </tex>, где <tex> i \bmod 2 = 1 </tex>.
#* Отсортируем его цифровой сортировкой за линейное время и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n] </tex> в алфавит <tex> \Sigma' </tex>, получив строку <tex> S' </tex> половинной длины.
# Рекурсивно построим суффиксный массив <tex> A_{S'} </tex>.
# Построим суффиксный массив <tex> A_{S_o} </tex>. Очевидно, <tex> A_{S_o}[i] = 2 A_{S'}[i] + 1 </tex>, так отношение упорядоченности любых двух строк в старом алфавите <tex> \Sigma </tex> эквивалентно отношению упорядоченности в новом алфавите <tex> \Sigma' </tex> по его построению.

* '''Шаг 2'''
На этом шаге мы за линейное время получим суффиксный массив <tex> A_{S_e} </tex> для четных суффиксов, используя уже построенный <tex> A_{S_o} </tex>.

Заметим, что сортировка множества четных суффиксов <tex> \{ S[i..n] | i \bmod 2 = 0 \} </tex> аналогична сортировке множества пар <tex> \{ (S[i], S[i+1..n]) | i \bmod 2 = 0 \} </tex>. Однако <tex> S[i+1..n] </tex> — нечетный суффикс, и его относительную позицию мы уже узнали на шаге 1.

Таким образом, чтобы отсортировать эти пары за линейное время, сначала сразу выпишем их в порядке возрастания второго элемента пары (то есть в порядке вхождения в массив <tex> A_{S_o} </tex>), а потом отсортируем устойчивой сортировкой подсчетом по первым элементам. После этого легко можно восстановить массив <tex> A_{S_e} </tex>:
M = []
'''for''' i = 0 '''to''' n/2 - 1:
M.add(Pair(S[<tex> A_{S_o}</tex>[i] - 1], <tex> A_{S_o}</tex>[i]))
stable_sort(M)
<tex> A_{S_e} </tex> = []
'''for''' i = 0 '''to''' n/2 - 1:
<tex> A_{S_e} </tex>.add(M[i].second - 1)

Заметим, что массив <tex> M </tex> перед сортировкой подсчетом не был явно отсортирован по вторым элементам, и хранил не суффиксы, а их позиции в строке <tex> S </tex>, но важно, что он был отсортирован по возрастанию соответствующих этим позициям нечетных суффиксов.

Получили, что весь второй шаг требует <tex> O(n) </tex> времени.

* '''Шаг 3'''
Для суффиксного дерева третий шаг алгоритма опирается на специфические особенности суффиксных деревьев, которые не присущи суффиксным массивам<ref>M. Farach. Optimal suffix tree construction with large alphabets. http://www.cs.rutgers.edu/~farach/pubs/FarFerrMuthu00.pdf </ref> .
В случае суффиксного массива слияние становится очень сложным, но все же оно было реализовано в алгоритме Ким-Сим-Парк-Парка<ref> D. K. Kim, J. S. Sim, H. Park, and K. Park. Linear-time construction of suffix arrays. http://www.springerlink.com/content/568156021q45r320/</ref>. Однако простой модификацией алгоритма можно значительно упростить его.

=== Пример ===
Покажем первые два шага агоритма для строки '''ababbbaa'''.

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

* '''Шаг 1'''
# В новом алфавите <tex> \Sigma' </tex> будет четыре элемента — '''ba''', '''bb''', '''a$''', '''$$'''. После сортировки они получат номера 2, 3, 1 и 0 соответственно.
# Переводим строку S[1..n] = '''babbbaa$$$''' в новый алфавит. Сжатой строкой <tex> S' </tex> будет '''23210'''.
# После рекурсивного вызова получим, что <tex> A_{S'} </tex> = [4, 3, 2, 0, 1], и <tex> A_{S_o} </tex> = [9, 7, 5, 1, 3].

* '''Шаг 2'''
# Обойдя массив <tex> A_{S_o} </tex>, получим <tex> M </tex> = [('''$''', 9), ('''a''', 7), ('''b''', 5), ('''a''', 1), ('''a''', 3)].
# После сортировки подсчетом по первому элементу, получим <tex> M </tex>= [('''$''', 9), ('''a''', 7), ('''a''', 1), ('''a''', 3), ('''b''', 5)].
# Восстановив массив <tex> A_{S_e} </tex>, получаем [8, 6, 0, 2, 4], что действительно является суффиксным массивом для четных суффиксов.

* '''Шаг 3'''
Если бы мы умели сливать <tex> A_{S_o} </tex> и <tex> A_{S_e} </tex> за линейное время, получили бы:
9 '''$'''
8 '''$$'''
7 '''a$$'''
6 '''aa$$'''
0 '''ababbbaa$$'''
2 '''abbbaa$$'''
5 '''baa$$'''
1 '''babbbaa$$'''
4 '''bbaa$$'''
3 '''bbbaa$$'''

Как и было сказано вначале, избавиться от лишних '''$''' легко, так как суффиксы, им соответствующие, будут первыми в суффиксном массиве (в данном случае достаточно выбросить "9" из суффиксного массива).

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

Получили асимптотическое уравнение <tex> T(n) = T\left(\dfrac23 n\right) + O(n) </tex>, решением которого также является <tex> T(n) = O(n) </tex> (это видно из того, что сумма геометрической прогрессии с основанием <tex> \dfrac23 </tex> равна <tex> 3 </tex>).

Аналогично первой версии алгоритма, дополним строку <tex> S </tex> до длины, кратной трем, защитными символами <tex> \$ </tex>.

=== База рекурсии ===
Для этого алгоритма минимальной базой рекурсии будет строка длиной 4, так как она дополняется до длины 6, после чего вновь следует рекурсивный вызов строки длиной 4, и, если бы база была меньше 4, алгоритм вошел бы в бесконечную рекурсию. На этом этапе также можно применить обычную сортировку суффиксов, так как это потребует <tex> O(1) </tex> действий.

=== Шаг 1 ===
На этом шаге строится суффиксный массив <tex> A_{S_{12}} </tex> для множества суффиксов <tex> \{ S[i..n-1] | i \bmod 3 \ne 0 \} </tex>.
# Получим строку <tex> S' </tex> аналогично предыдущему алгоритму:
#* Сделаем список, состоящий из троек <tex> S[i..i+2]</tex> , где <tex> i \bmod 3 \ne 0 </tex>.
#* Отсортируем его за линейное время цифровой сортировкой и получим новый алфавит <tex> \Sigma' </tex>.
#* Перекодируем строку <tex> S[1..n]S[2..n+1] </tex> в строку <tex> S' </tex> длиной <tex> \dfrac23 n </tex> в алфавите <tex> \Sigma' </tex>. Тогда суффиксу <tex> S[i..n-1] </tex> в старом алфавите, где <tex> i \bmod 3 = 1 </tex>, в новом алфавите будет соответствовать строка <tex> S'\left[\dfrac{i-1}{3}..\dfrac{n}{3} - 1\right] </tex>, а если <tex> i\bmod 3 = 2 </tex>, то строка <tex> S'\left[\dfrac{n}{3} + \dfrac{i-2}{3}..\dfrac{2n}{3} - 1\right] </tex>.
# Вызовем алгоритм рекурсивно для строки <tex> S' </tex>, получив суффиксный массив <tex> A_{S'} </tex>.
# Пройдем по массиву <tex> A_{S'} </tex>. Если <tex> A_{S'}[i] < \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3A_{S'}[i] + 1 </tex> в строке <tex> S </tex>, если же <tex> A_{S'}[i] \geqslant \dfrac{n}{3} </tex>, то этот суффикс соответствует позиции <tex> j = 3\left(A_{S'}[i] - \dfrac{n}{3}\right) + 2 </tex> в строке <tex> S </tex>. Псевдокод получения <tex> A_{S_{12}} </tex>:
<tex> A_{S_{12}} </tex> = []
'''for''' i = 0 '''to''' <tex>A_{S'}</tex>.length - 1:
'''if''' <tex>A_{S'}</tex>[i] < n/3:
<tex>A_{S_{12}}</tex>.add(3 * <tex>A_{S'}</tex>[i] + 1)
'''else''':
<tex>A_{S_{12}}</tex>.add(3 * (<tex>A_{S'}</tex>[i] - n/3) + 2)

=== Шаг 2 ===
Этот шаг также аналогичен первой версии алгоритма. Сортировка множества <tex> \{ S[i..n-1] | i \bmod 3 = 0 \} </tex> аналогична сортировке пар <tex> \{ (S[i], S[i+1..n-1]) | i \bmod 3 = 0 \} </tex>, где <tex> S[i+1..n-1] </tex> — суффиксы в позициях, равных 1 по модулю 3, относительный порядок которых уже известен. Выпишем эти пары в порядке вхождения их в <tex> A_{S_{12}} </tex> и отсортируем по первому элементу устойчивой сортировкой подсчетом, получив суффиксный массив <tex> A_{S_0} </tex>. Псевдокод этого шага:

<tex>A_{S_0}</tex> = []
M = []
'''for''' i = 0 '''to''' 2n/3 - 1:
'''if''' <tex> A_{S_{12}}</tex>[i] % 3 == 1:
M.add(Pair(S[<tex>A_{S_{12}}</tex>[i] - 1], <tex>A_{S_{12}}</tex>[i]))
stable_sort(M)
'''for''' i = 0 '''to''' n/3 - 1:
<tex>A_{S_0}</tex>.add(M[i].second - 1)
Аналогично, второй шаг требует <tex> O(n) </tex> времени.

=== Шаг 3 ===
На этом шаге мы должны слить суффиксные массивы <tex> A_{S_0} </tex> и <tex> A_{S_{12}} </tex>, чтобы получить суффиксный массив <tex> A_{S} </tex> для всей строки <tex> S </tex>.

Применим стандартный алгоритм слияния двух отсортированных массивов. Заметим, что явно массивы не отсортированы, но соответствующие элементам массива суффиксы — отсортированы.

Пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 1 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Это аналогично сравнению пар <tex> (S[i], S[i+1..n-1]) </tex> и <tex> (S[j], S[j+1..n-1]) </tex>. Сравнить первые элементы пар мы можем за <tex> O(1) </tex>, а относительный порядок вторых элементов пар нам уже известен, так как они соответствуют позициям, равным 2 и 1 по модулю 3 соответственно.

Аналогично, пусть на какой-то итерации слияния мы сравниваем суффиксы, соответствующие позициям <tex> i </tex>, равной 2 по модулю 3, и <tex> j </tex> (она всегда будет равна 0 по модулю 3). Тогда это аналогично сравнению троек <tex> (S[i], S[i+1], S[i+2..n-1]) </tex> и <tex> (S[j], S[j+1], S[j+2..n-1]) </tex>, что также можно делать за <tex> O(1) </tex>.

Псевдокод этой фазы:

<tex>A_{S}</tex> = []
// Вначале предподсчитаем за O(n) обратную перестановку для суффиксного массива <tex> A_{S_{12}}</tex>, то есть массив rank такой, что <tex> A_{S_{12}}</tex>[rank[i]] = i.
// Тогда мы сможем за O(1) сравнивать суффиксы по их позиции.
rank = inverse(<tex>A_{S_{12}}</tex>)
'''while''' i < 2 * n/3 '''and''' j < n/3:
pos12 = <tex> A_{S_{12}} </tex>[i]
pos0 = <tex> A_{0} </tex>[j]
'''if''' pos12 % 3 == 1:
''' if''' Pair(S[pos12], rank[pos12 + 1]) < Pair(S[pos0], rank[pos0 + 1]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''else''':
'''if''' Triple(S[pos12], S[pos12 + 1], rank[pos12 + 2]) < Triple(S[pos0], S[pos0 + 1], rank[pos0 + 2]):
<tex>A_{S}</tex>.add(pos12)
i++
'''else''':
<tex>A_{S}</tex>.add(pos0)
j++
'''while''' i < 2 * n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{12}} </tex>[i])
i++
'''while''' j < n/3:
<tex>A_{S}</tex>.add(<tex> A_{S_{0}} </tex>[j])
j++

Таким образом, получили простой метод слияния за <tex> O(n) </tex>.

=== Пример ===
Построим суффиксный массив для строки '''abbacab'''. После добавления защитного символа и дополнения до кратной трем длины, получим '''abbacab$$'''.
==== Шаг 1 ====
# Тройками, соответствующими равными 1 по модулю 3 позициям, будут: '''bba''', '''cab''', '''$$$''', соответствующими равным 2 по модулю 3 — '''bac''', '''ab$''', '''$$$'''. Новый алфавит <tex> \Sigma' </tex> будет содержать элементы '''bba''', '''cab''', '''$$$''', '''bac''', '''ab$''', которые после сортировки получат номера 3, 4, 0, 2, 1 соотвествтенно.
# Строкой '''bbacab$$$bacab$$$$''' в новом алфавите <tex> \Sigma' </tex> будет <tex> S' </tex> = '''340210'''.
# После рекурсивного вызова получим <tex> A_{S'} </tex> = [5, 2, 4, 3, 0, 1]. Пересчитав <tex> A_{S_{12}} </tex>, получим [(5 - 3)*3 + 2, 2 * 3 + 1, (4 - 3) * 3 + 2, (3 - 3) * 3 + 2, 0 * 3 + 1, 1 * 3 + 1] = [8, 7, 5, 2, 1, 4].

==== Шаг 2 ====
# Обойдя массив <tex> A_{S_{12}} </tex> и выбрав в нем элементы, равные 1 по модулю 3, получим массив пар <tex>M</tex> = [('''b''', 7), ('''a''', 1), ('''a''', 4)]
# После устойчивой сортировки подсчетом по первому элементу, получим <tex> M </tex> = [('''a''', 1), ('''a''', 4), ('''b''', 7)]
# Восстановив <tex> A_{S_0} </tex>, получаем [0, 3, 6].
==== Шаг 3 ====
Рассмотрим, к примеру, третью итерацию слияния, к этой итерации массив <tex> A_{S} </tex> = [8, 7], <tex> i </tex> = 2, <tex> j </tex> = 0, на ней мы сливаем суффиксы, соответствующие позициям 5 и 0.
# Образуем тройки (S[5], S[6], S[7..8]) и (S[0], S[1], S[2..8]).
# После получения относительного порядка суффиксов, получим тройки ('''a''', '''b''', 1) и ('''a''', '''b''', 3). Первая тройка меньше второй, поэтому добавляем суффикс, соответствующий позиции 5 в массив <tex> A_{S} </tex>.
# В конце итерации получаем <tex> A_{S} </tex> = [8, 7, 5], <tex> i </tex> = 3, <tex> j </tex> = 0.
К концу слияния получим <tex> A_{S} </tex> = [8, 7, 5, 0, 3, 6, 2, 1, 4]. Так как мы добавляли один символ '''$''' в начале алгоритма для дополнения строки до длины, кратной трем, выбросим последний суффикс из <tex> A_{S} </tex>, получим в итоге, что <tex> A_{S} </tex> = [7, 5, 0, 3, 6, 2, 1, 4].
8 '''$''' (будет выброшен, так как в начале алгоритма добавляли один '''$''' к строке)
7 '''$$'''
5 '''ab$$'''
0 '''abbacab$$'''
3 '''acab$$'''
6 '''b$$'''
2 '''bacab$$'''
1 '''bbacab$$'''
4 '''cab$$'''
{|
| [[Файл:Kark_sanders_stage1.png|325px|thumb| Фаза 1]]
| [[Файл:Kark_sanders_stage2.png|325px|thumb| Фаза 2]]
| [[Файл:Kark_sanders_stage3.png|325px|thumb| Фаза 3]]
|}

== Получение массива LCP ==
Массив LCP можно получить за линейное время [[Алгоритм_Касаи_и_др. | алгоритмом Касаи]].

== Обобщение алгоритма ==
На самом деле, алгоритм можно обобщить<ref name="generalisation"> Juha Kärkkäinen, Peter Sanders and Stefan Burkhardt. Linear work suffix array construction. http://www.cs.helsinki.fi/juha.karkkainen/publications/jacm05-revised.pdf </ref>, взяв на первом шаге, к примеру, суффиксы, позиции которых по модулю 7 дают 3, 5 и 6. Для этого потребуются некоторое усложнение алгоритма, например, сортировка оставшихся суффиксов в нескольких группах на шаге 2 и слияние нескольких групп на шаге 3, но основная идея алгоритма остается той же. Множества, которые можно выбрать, на первом шаге определяются '''разностным покрытием''' (''difference cover'').
{{Определение
|definition=
'''Разностное покрытие''' (''difference cover'') <tex> D </tex> по модулю <tex>m </tex> — множество чисел от <tex>0</tex> до <tex>m - 1 </tex> таких, что <tex> \forall i \in [0, m-1]: \exists j, k \in D: i \equiv k - j \pmod m </tex>.
}}
Например, <tex> \{1, 2\} </tex> является разностным покрытием по модулю <tex> 3 </tex>, <tex> \{3, 5, 6\} </tex> является разностным покрытием по модулю <tex> 7 </tex>, а <tex> \{1\} </tex> — не является разностным покрытием по модулю <tex> 2 </tex>, поэтому этот алгоритм не применим к нему. Подробнее узнать, как вычислять разностное покрытие для заданного модуля можно также здесь<ref name="generalisation"/>.

== См. также ==
* [[Суффиксный массив]]

== Примечания ==
<references/>

== Источники информации==
* [[Суффиксный массив]]
* [http://www.cs.helsinki.fi/juha.karkkainen/publications/icalp03.pdf Juha Kärkkäinen and Peter Sanders. Simple linear work suffix array construction]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Суффиксный массив]]

Сведение задачи RMQ к задаче LCA

2015-06-04T11:03:14Z

Nastyastanchul: /* Сложность */

{{Шаблон:Задача
|definition =Дан массив <tex>A[1..N]</tex>. Поступают запросы вида <tex>(i, j)</tex>, на каждый запрос требуется найти минимум в массиве <tex>A</tex>, начиная с позиции <tex>i</tex> и заканчивая позицией <tex>j</tex>.
}}

== Алгоритм ==
[[Файл:Wiki.PNG|thumb|right|300x150px|Пример декартового дерева]]
Для нахождения минимума на отрезке будем использовать информацию о наименьшем общем предке. Для хранения наименьших общих предков будем использовать [[декартово дерево по неявному ключу]].

Декартово дерево по неявному ключу на массиве <tex>A[1..N]</tex> {{---}} это бинарное дерево, допускающее следующее рекурсивное построение:
* Корнем дерева является элемент массива, имеющий минимальное значение <tex>A</tex>, скажем <tex>A[i]</tex>. Если минимальных элементов несколько, можно взять любой.
* Левым поддеревом является декартово дерево на массиве <tex>A[1..i-1]</tex>.
* Правым поддеревом является декартово дерево на массиве <tex>A[i+1..N]</tex>.

Здесь и далее <tex>A[i]</tex> будет также использоваться для обозначения соответствующей вершины дерева.

Построим декартово дерево на массиве <tex>A</tex>. Тогда <tex>RMQ(i, j)</tex> = <tex>LCA(A[i], A[j])</tex>.
<br clear="all">

== Доказательство ==
{{Теорема
|statement=
<tex>RMQ(i, j)</tex> = <tex>LCA(A[i], A[j])</tex>.
|proof=
Положим <tex>w = LCA(A[i], A[j])</tex>.

Заметим, что <tex>A[i]</tex> и <tex>A[j]</tex> не принадлежат одновременно либо правому, либо левому поддереву <tex>w</tex>, потому как тогда бы соответствующий сын находился на большей глубине, чем <tex>w</tex>, и также являлся предком как <tex>A[i]</tex> так и <tex>A[j]</tex>, что противоречит определению <tex>LCA</tex>. Из этого замечанию следует, что <tex>w</tex> лежит между <tex>A[i]</tex> и <tex>A[j]</tex> и, следовательно, принадлежит отрезку <tex>A[i..j]</tex>.

По построению мы также знаем, что:
# Любая вершина дерева имеет свое значение меньшим либо равным значению её детей.
# Поддерево с корнем в <tex>w</tex> содержит в себе подмассив <tex>A[i..j]</tex>.

Суммируя, получаем, что <tex>w</tex> имеет минимальное значение на отрезке, покрывающем <tex>A[i..j]</tex>, и принадлежит отрезку <tex>A[i..j]</tex>, отсюда <tex>RMQ(i, j) = w</tex>.
}}

== Сложность ==
Существует [[Декартово дерево#Построение декартова дерева|алгоритм]], который строит декартово дерево за <tex>O(n)</tex>. Используя [[Сведение задачи LCA к задаче RMQ | алгоритм построения LCA]], получаем:
препроцессинг для <tex>LCA</tex> {{---}} <tex>O(n)</tex> и ответ на запрос {{---}} <tex>O(1)</tex>.

Нам нужно единожды построить декартово дерево за <tex>O(n)</tex>, единожды провести препроцессинг за <tex>O(n)</tex> и отвечать на запросы за <tex>O(1)</tex>.

В итоге получили <tex>RMQ</tex> с построением за <tex>O(n)</tex> и ответом на запрос за <tex>O(1)</tex>.

== См.также ==
*[[Сведение задачи LCA к задаче RMQ]]
*[[Декартово дерево]]
*[[Алгоритм Фарака-Колтона и Бендера]]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Сведение задачи LCA к задаче RMQ

2015-06-04T10:49:43Z

Nastyastanchul: /* Препроцессинг */

{{Шаблон:Задача
|definition =
Пусть дано корневое дерево <tex>T</tex>. На вход подаются запросы вида <tex>(u,\;v)</tex>, для каждого запроса требуется найти их наименьшего общего предка.
}}
{{Определение
|id=lca_suf_tree
|definition = '''Наименьшим общим предком''' (англ. ''least common ancestor'') двух узлов <tex>u</tex> и <tex>v</tex> в корневом дереве <tex>T</tex> называется узел <tex>w</tex>, который среди всех узлов, являющихся предками как узла <tex>u</tex>, так и <tex>v</tex>, имеет наибольшую глубину.
}}

== Алгоритм ==
=== Препроцессинг ===
Для каждой вершины <tex>T</tex> определим глубину с помощью следующей рекурсивной формулы:
:<tex>\mathrm{depth}(u) = \begin{cases}
0 & u = \mathrm{root}(T),\\
\mathrm{depth}(v) + 1 & u = \mathrm{son}(v)
\end{cases}.</tex>
Ясно, что глубина вершины элементарным образом поддерживается во время обхода в глубину.

Запустим [[Обход в глубину, цвета вершин|обход в глубину]] из корня, который будет вычислять значения следующих величин:
#Cписок глубин посещенных вершин <tex>d</tex>. Глубина текущей вершины добавляется в конец списка при входе в данную вершину, а также после каждого возвращения из её сына.
#Список посещений узлов <tex>\mathtt{vtx}</tex>, строящийся аналогично предыдущему, только добавляется не глубина а сама вершина.
#Значение функции <tex>\mathtt{I}[u]</tex>, возвращающей любой индекс в списке глубин <tex>d</tex>, по которому была записана глубина вершины <tex>u</tex> (например на момент входа в вершину).

=== Запрос ===
Будем считать, что <tex>\mathrm{rmq}(d,l,r)</tex> возвращает индекс минимального элемента в <tex>d</tex> на отрезке <tex>[l..r]</tex>. Тогда ответом на запрос <tex>\mathrm{lca}(u, v)</tex>, где <tex>I[u] \leqslant \mathtt{I}[v]</tex>, будет <tex>\mathtt{vtx}[\mathrm{rmq}(d,\mathtt{I}[u], \mathtt{I}[v])]</tex>.

=== Доказательство корректности алгоритма ===
{{Теорема
|statement=
Наименьшему общему предку вершин <tex>u, v</tex> соответствует минимальная глубина на отрезке <tex>d[\mathtt{I}[u], \mathtt{I}[v]]</tex>.
|proof=
Рассмотрим два узла <tex>u, v</tex> корневого дерева <tex>T</tex>. Рассмотрим отрезок <tex>d[\mathtt{I}[u]..\mathtt{I}[v]]</tex>. Поскольку этот отрезок {{---}} путь из <tex>u</tex> в <tex>v</tex>, он проходит через их наименьшего общего предка <tex>w</tex> (в дереве есть только один простой путь между вершинами), а следовательно минимум на отрезке никак не больше глубины <tex>w</tex>. Заметим, что в момент добавления <tex>\mathtt{I}[u]</tex> обход посещал поддерево с корнем <tex>w</tex>. В момент добавления <tex>\mathtt{I}[v]</tex> мы все еще в поддереве с корнем <tex>w</tex>. Значит, и на отрезке между <tex>\mathtt{I}[u]</tex> и <tex>\mathtt{I}[v]</tex> мы находились внутри поддерева с корнем <tex>w</tex>. Отсюда сделаем заключение, что на рассматриваемом отрезке не посещалась вершина, отличная от <tex>w</tex>, с глубиной меньшей либо равной глубины <tex>w</tex>, т. к. подобной вершины нет в поддереве с корнем <tex>w</tex>.
}}.

== Пример ==
Рассмотрим дерево на рисунке 1. Найдем наименьшего общего предка вершин, помеченных красным цветом.
Список глубин, получающийся в результате обхода в глубину {{---}} <tex>[0, 1, 2, 1, 2, 1, 0, 1, 0].</tex>
Глубина наименьшего общего предка красных вершин равна минимуму на отрезке <tex>[2, 1, 0, 1].</tex>
[[Файл:Lca to rmq.png(2).png|thumb|left|Рисунок к примеру]]
<div style='clear:left;'></div>

== Сложность ==

Для нахождения минимального элемента на отрезке можно использовать [[Алгоритм Фарака-Колтона и Бендера|алгоритм Фарака-Колтона и Бендера]] для <tex>\pm 1RMQ</tex>, т. к. соседние элементы в списке глубин отличаются не более чем на единицу. Длина списка глубин составляет <tex>(2n - 1)</tex>, таким образом, препроцессинг работает за <tex>O(n)</tex>. Время выполнения запроса равно времени запроса минимального элемента на отрезке {{---}} <tex>O(1)</tex>.

== См.также ==
*[[Метод двоичного подъема]]
*[[Решение RMQ с помощью разреженной таблицы]]
*[[Алгоритм Фарака-Колтона и Бендера]]
*[[Сведение задачи RMQ к задаче LCA]]
== Источники информации ==
*[http://e-maxx.ru/algo/lca Наименьший общий предок. Нахождение за O (sqrt (N)) и O (log N) с препроцессингом O (N)]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]

Сведение задачи RMQ к задаче LCA

2015-06-04T10:44:38Z

Nastyastanchul: /* Алгоритм */

{{Шаблон:Задача
|definition =Дан массив <tex>A[1..N]</tex>. Поступают запросы вида <tex>(i, j)</tex>, на каждый запрос требуется найти минимум в массиве <tex>A</tex>, начиная с позиции <tex>i</tex> и заканчивая позицией <tex>j</tex>.
}}

== Алгоритм ==
[[Файл:Wiki.PNG|thumb|right|300x150px|Пример декартового дерева]]
Для нахождения минимума на отрезке будем использовать информацию о наименьшем общем предке. Для хранения наименьших общих предков будем использовать [[декартово дерево по неявному ключу]].

Декартово дерево по неявному ключу на массиве <tex>A[1..N]</tex> {{---}} это бинарное дерево, допускающее следующее рекурсивное построение:
* Корнем дерева является элемент массива, имеющий минимальное значение <tex>A</tex>, скажем <tex>A[i]</tex>. Если минимальных элементов несколько, можно взять любой.
* Левым поддеревом является декартово дерево на массиве <tex>A[1..i-1]</tex>.
* Правым поддеревом является декартово дерево на массиве <tex>A[i+1..N]</tex>.

Здесь и далее <tex>A[i]</tex> будет также использоваться для обозначения соответствующей вершины дерева.

Построим декартово дерево на массиве <tex>A</tex>. Тогда <tex>RMQ(i, j)</tex> = <tex>LCA(A[i], A[j])</tex>.
<br clear="all">

== Доказательство ==
{{Теорема
|statement=
<tex>RMQ(i, j)</tex> = <tex>LCA(A[i], A[j])</tex>.
|proof=
Положим <tex>w = LCA(A[i], A[j])</tex>.

Заметим, что <tex>A[i]</tex> и <tex>A[j]</tex> не принадлежат одновременно либо правому, либо левому поддереву <tex>w</tex>, потому как тогда бы соответствующий сын находился на большей глубине, чем <tex>w</tex>, и также являлся предком как <tex>A[i]</tex> так и <tex>A[j]</tex>, что противоречит определению <tex>LCA</tex>. Из этого замечанию следует, что <tex>w</tex> лежит между <tex>A[i]</tex> и <tex>A[j]</tex> и, следовательно, принадлежит отрезку <tex>A[i..j]</tex>.

По построению мы также знаем, что:
# Любая вершина дерева имеет свое значение меньшим либо равным значению её детей.
# Поддерево с корнем в <tex>w</tex> содержит в себе подмассив <tex>A[i..j]</tex>.

Суммируя, получаем, что <tex>w</tex> имеет минимальное значение на отрезке, покрывающем <tex>A[i..j]</tex>, и принадлежит отрезку <tex>A[i..j]</tex>, отсюда <tex>RMQ(i, j) = w</tex>.
}}

== Сложность ==
Следующий [[Декартово дерево#Построение декартова дерева|алгоритм]] строит декартово дерево за <tex>O(n)</tex>. Используя [[Сведение задачи LCA к задаче RMQ]], получаем:
препроцессинг для <tex>LCA</tex> {{---}} <tex>O(n)</tex> и ответ на запрос {{---}} <tex>O(1)</tex>.
В итоге получили <tex>RMQ</tex> с построением за <tex>O(n)</tex> и ответом на запрос за <tex>O(1)</tex>.

== См.также ==
*[[Сведение задачи LCA к задаче RMQ]]
*[[Декартово дерево]]
*[[Алгоритм Фарака-Колтона и Бендера]]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о наименьшем общем предке]]