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

Количество подпалиндромов в строке

2016-04-18T20:00:37Z

217.66.158.37: Перенаправление на Алгоритм Манакера

#перенаправление [[Алгоритм Манакера]]

Алгоритм Манакера

2016-04-18T19:58:07Z

217.66.158.37: /* Источники информации */

{{Шаблон:Задача
|definition =
Пусть дана строка <tex>s</tex>. Требуется найти количество подстрок <tex>s</tex>, являющиеся палиндромами. Более формально, все такие пары <tex>(i, j)</tex>, что <tex>s[i..j]</tex> — [[Основные_определения,_связанные_со_строками#palindrome | палиндром]].
}}

==Уточнение постановки==
Легко увидеть, что таких подстрок в худшем случае будет <tex>n^2</tex>. Значит, нужно найти компактный способ хранения информации о них. Пусть <tex>d1[i]</tex> — количество палиндромов нечетной длины с центром в позиции <tex>i</tex>, а <tex>d2[i]</tex> — аналогичная величина для палиндромов четной длины. Далее научимся вычислять значения этих массивов.

== Наивный алгоритм ==
=== Идея ===
Рассмотрим сначала задачу поиска палиндромов нечетной длины. Центром строки нечетной длины назовем символ под индексом <tex>\left\lfloor \dfrac{|t|}{2}\right\rfloor</tex>. Для каждой позиции в строке <tex>s</tex> найдем длину наибольшего палиндрома с центром в этой позиции. Очевидно, что если строка <tex>t</tex> является палиндромом, то строка полученная вычеркиванием первого и последнего символа из <tex>t</tex> также является палиндромом, поэтому длину палиндрома можно искать [[Целочисленный_двоичный_поиск | бинарным поиском]]. Проверить совпадение левой и правой половины можно выполнить за <tex>O(1)</tex>, используя метод хеширования.

Для палиндромов четной длины алгоритм такой же. Центр строки четной длины {{---}} некий мнимый элемент между <tex>\dfrac{|t|}{2} - 1</tex> и <tex>\dfrac{|t|}{2}</tex>. Только требуется проверять вторую строку со сдвигом на единицу. Следует заметить, что мы не посчитаем никакой палиндром дважды из-за четности-нечетности длин палиндромов.

=== Псевдокод ===
'''int''' binarySearch(s : '''string''', center, shift : '''int'''):
''//shift = 0 при поиске палиндрома нечетной длины, иначе shift = 1''
'''int''' l = -1, r = min(center, s.length - center + shift), m = 0
'''while''' r - l != 1
m = l + (r - l) / 2
''//reversed_hash возвращает хэш развернутой строки s''
'''if''' hash(s[center - m..center]) == reversed_hash(s[center + shift..center + shift + m])
l = m
'''else'''
r = m
'''return''' r

'''int''' palindromesCount(s : '''string'''):
'''int''' ans = 0
'''for''' i = 0 '''to''' s.length
ans += binarySearch(s, i, 0) + binarySearch(s, i, 1)
'''return''' ans

=== Время работы ===
Изначальный подсчет хешей производится за <tex>O(|s|)</tex>. Каждая итерация будет выполняться за <tex>O(\log(|s|))</tex>, всего итераций {{---}} <tex>|s|</tex>. Итоговое время работы алгоритма <tex>O(|s|+|s|\cdot \log(|s|)) = O(|s|\cdot \log(|s|))</tex>.

=== Избавление от коллизий ===
У хешей есть один недостаток {{---}} коллизии: можно подобрать входные данные так, что хеши разных строк будут совпадать. Абсолютно точно проверить две подстроки на совпадение можно с помощью [[Суффиксный массив | суффиксного массива]], но с дополнительной памятью <tex>O(|s|\cdot \log(|s|))</tex>. Для этого построим суффиксный массив для строки <tex>s + \# + reverse(s)</tex>, при этом сохраним промежуточные результаты классов эквивалентности <tex>c</tex>. Пусть нам требуется проверить на совпадение подстроки <tex>s[i..i + l]</tex> и <tex>s[j..j + l]</tex>. Разобьем каждую нашу строку на две пересекающиеся подстроки длиной <tex>2^k</tex>, где <tex>k = \lfloor \log{l} \rfloor</tex>. Тогда наши строки совпадают, если <tex>c[k][i] = c[k][j]</tex> и <tex>c[k][i + l - 2^k] = c[k][j + l - 2^k]</tex>.

Итоговая асимптотика алгоритма: предподсчет за построение суффиксного массива и <tex>O(\log(|s|))</tex> на запрос, если предподсчитать все <tex>k</tex>, то <tex>O(1)</tex>.

==Алгоритм Манакера==
===Идея===
Алгоритм, который будет описан далее, отличается от наивного тем, что использует значения, посчитанные ранее.
Будем поддерживать границы самого правого из найденных палиндромов — <tex>[l; r]</tex>. Итак, пусть мы хотим вычислить <tex>d1[i]</tex> — т.е. длину наибольшего палиндрома с центром в позиции <tex>i</tex>. При этом все предыдущие значения в массиве <tex>d</tex> уже посчитаны. Возможны два случая:

# <tex>i > r</tex>, т.е. текущая позиция не попадает в границы самого правого из найденных палиндромов. Тогда просто запустим наивный алгоритм для позиции <tex>i</tex>.
# <tex>i \leqslant r</tex>. Тогда попробуем воспользоваться значениями, посчитанным ранее. Отразим нашу текущую позицию внутри палиндрома <tex>[l;r] : j = (r - i) + l</tex>. Поскольку <tex>i</tex> и <tex>j</tex> — симметричные позиции, то если <tex>d1[j] = k</tex>, мы можем утверждать, что и <tex>d1[i] = k</tex>. Это объясняется тем, что палиндром симметричен относительно своей центральной позиции. Т.е. если имеем некоторый палиндром длины <tex>k</tex> с центром в позиции <tex>l \leqslant i \leqslant r</tex>, то в позиции <tex>j</tex>, симметричной <tex>i</tex> относительно отрезка <tex>[l; r]</tex> тоже может находиться палиндром длины <tex>k</tex>. Это можно лучше понять, посмотрев на рисунок. Снизу фигурными скобками обозначены равные подстроки. Однако стоит не забыть про один граничный случай: что если <tex>i + d1[j] - 1</tex> выходит за границы самого правого палиндрома? Так как информации о том, что происходит за границами это палинлрома у нас нет (а значит мы не можем утверждать, что симметрия сохраняется), то необходимо ограничить значение <tex>d1[i]</tex> следующим образом: <tex>d1[i] = \min(r - i, d1[j])</tex>. После этого запустим наивный алгоритм, который будет увеличивать значение <tex>d1[i]</tex>, пока это возможно.

После каждого шага важно не забывать обновлять значения <tex>[l;r]</tex>.

Заметим, что массив <tex>d2</tex> считается аналогичным образом, нужно лишь немного изменить индексы.

[[Файл:Манакер.png]]

===Псевдокод===
Приведем код, который вычисляет значения массива <tex>d1</tex>:

// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate1('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i, d[r - i + l])
'''while''' i + k + 1 <= n '''and''' i - k - 1 > 0 '''and''' s[i + k + 1] == s[i - k - 1]
k++
d1[i] = k
'''if''' i + k > r
l = i - k
r = i + k
'''return''' d1

Вычисление значений массива <tex>d2</tex>:
// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate2('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i + 1, d[r - i + l + 1])
'''while''' i + k <= n '''and''' i - k - 1 > 0 '''and''' s[i + k] == s[i - k - 1]
k++
d2[i] = k
'''if''' i + k - 1 > r
l = i - k
r = i + k - 1
'''return''' d2

===Оценка сложности===
Внешний цикл в приведенном алгоритме выполняется ровно <tex>n</tex> раз, где <tex>n</tex> — длина строки. Попытаемся понять, сколько раз будет выполнен внутренний цикл, ответственный за наивный подсчет значений. Заметим, что каждая итерация вложенного цикла приводит к увеличению <tex>r</tex> на <tex>1</tex>. Действительно, возможны следующие случаи:

# <tex>i > r</tex>, т.е. сразу будет запущен наивный алгоритм и каждая его итерация будет увеличивать значение <tex>r</tex> хотя бы на <tex>1</tex>.
# <tex>i \leqslant r</tex>. Здесь опять два случая:
## <tex>i + d[j] - 1 \leqslant r</tex>, но тогда, очевидно, ни одной итерации вложенного цикла выполнено не будет.
## <tex>i + d[j] - 1 > r</tex>, тогда каждая итерация вложенного цикла приведет к увеличению <tex>r</tex> хотя бы на <tex>1</tex>.

Т.к. значение <tex>r</tex> не может увеличиваться более <tex>n</tex> раз, то описанный выше алгоритм работает за время <tex>O(n)</tex>.

== См. также ==
* [[Префикс-функция]]
* [[Z-функция]]
* [[Суффиксный массив]]
* [[Поиск наибольшей общей подстроки двух строк с использованием хеширования]]

== Источники информации ==
* [http://e-maxx.ru/algo/palindromes_count MAXimal :: algo :: Нахождение всех подпалиндромов]
* [[wikipedia:ru:Поиск_длиннейшей_подстроки-палиндрома| Википедия — Поиск длиннейшей подстроки-палиндрома]]
* [https://habrahabr.ru/post/276195/ Алгоритмы для поиска палиндромов — Хабр]
* [http://e-maxx.ru/algo/suffix_array#5 MAXimal :: algo :: Суффиксный массив]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Основные определения. Простые комбинаторные свойства слов]]

Алгоритм Манакера

2016-04-18T19:57:35Z

217.66.158.37: /* См. также */

{{Шаблон:Задача
|definition =
Пусть дана строка <tex>s</tex>. Требуется найти количество подстрок <tex>s</tex>, являющиеся палиндромами. Более формально, все такие пары <tex>(i, j)</tex>, что <tex>s[i..j]</tex> — [[Основные_определения,_связанные_со_строками#palindrome | палиндром]].
}}

==Уточнение постановки==
Легко увидеть, что таких подстрок в худшем случае будет <tex>n^2</tex>. Значит, нужно найти компактный способ хранения информации о них. Пусть <tex>d1[i]</tex> — количество палиндромов нечетной длины с центром в позиции <tex>i</tex>, а <tex>d2[i]</tex> — аналогичная величина для палиндромов четной длины. Далее научимся вычислять значения этих массивов.

== Наивный алгоритм ==
=== Идея ===
Рассмотрим сначала задачу поиска палиндромов нечетной длины. Центром строки нечетной длины назовем символ под индексом <tex>\left\lfloor \dfrac{|t|}{2}\right\rfloor</tex>. Для каждой позиции в строке <tex>s</tex> найдем длину наибольшего палиндрома с центром в этой позиции. Очевидно, что если строка <tex>t</tex> является палиндромом, то строка полученная вычеркиванием первого и последнего символа из <tex>t</tex> также является палиндромом, поэтому длину палиндрома можно искать [[Целочисленный_двоичный_поиск | бинарным поиском]]. Проверить совпадение левой и правой половины можно выполнить за <tex>O(1)</tex>, используя метод хеширования.

Для палиндромов четной длины алгоритм такой же. Центр строки четной длины {{---}} некий мнимый элемент между <tex>\dfrac{|t|}{2} - 1</tex> и <tex>\dfrac{|t|}{2}</tex>. Только требуется проверять вторую строку со сдвигом на единицу. Следует заметить, что мы не посчитаем никакой палиндром дважды из-за четности-нечетности длин палиндромов.

=== Псевдокод ===
'''int''' binarySearch(s : '''string''', center, shift : '''int'''):
''//shift = 0 при поиске палиндрома нечетной длины, иначе shift = 1''
'''int''' l = -1, r = min(center, s.length - center + shift), m = 0
'''while''' r - l != 1
m = l + (r - l) / 2
''//reversed_hash возвращает хэш развернутой строки s''
'''if''' hash(s[center - m..center]) == reversed_hash(s[center + shift..center + shift + m])
l = m
'''else'''
r = m
'''return''' r

'''int''' palindromesCount(s : '''string'''):
'''int''' ans = 0
'''for''' i = 0 '''to''' s.length
ans += binarySearch(s, i, 0) + binarySearch(s, i, 1)
'''return''' ans

=== Время работы ===
Изначальный подсчет хешей производится за <tex>O(|s|)</tex>. Каждая итерация будет выполняться за <tex>O(\log(|s|))</tex>, всего итераций {{---}} <tex>|s|</tex>. Итоговое время работы алгоритма <tex>O(|s|+|s|\cdot \log(|s|)) = O(|s|\cdot \log(|s|))</tex>.

=== Избавление от коллизий ===
У хешей есть один недостаток {{---}} коллизии: можно подобрать входные данные так, что хеши разных строк будут совпадать. Абсолютно точно проверить две подстроки на совпадение можно с помощью [[Суффиксный массив | суффиксного массива]], но с дополнительной памятью <tex>O(|s|\cdot \log(|s|))</tex>. Для этого построим суффиксный массив для строки <tex>s + \# + reverse(s)</tex>, при этом сохраним промежуточные результаты классов эквивалентности <tex>c</tex>. Пусть нам требуется проверить на совпадение подстроки <tex>s[i..i + l]</tex> и <tex>s[j..j + l]</tex>. Разобьем каждую нашу строку на две пересекающиеся подстроки длиной <tex>2^k</tex>, где <tex>k = \lfloor \log{l} \rfloor</tex>. Тогда наши строки совпадают, если <tex>c[k][i] = c[k][j]</tex> и <tex>c[k][i + l - 2^k] = c[k][j + l - 2^k]</tex>.

Итоговая асимптотика алгоритма: предподсчет за построение суффиксного массива и <tex>O(\log(|s|))</tex> на запрос, если предподсчитать все <tex>k</tex>, то <tex>O(1)</tex>.

==Алгоритм Манакера==
===Идея===
Алгоритм, который будет описан далее, отличается от наивного тем, что использует значения, посчитанные ранее.
Будем поддерживать границы самого правого из найденных палиндромов — <tex>[l; r]</tex>. Итак, пусть мы хотим вычислить <tex>d1[i]</tex> — т.е. длину наибольшего палиндрома с центром в позиции <tex>i</tex>. При этом все предыдущие значения в массиве <tex>d</tex> уже посчитаны. Возможны два случая:

# <tex>i > r</tex>, т.е. текущая позиция не попадает в границы самого правого из найденных палиндромов. Тогда просто запустим наивный алгоритм для позиции <tex>i</tex>.
# <tex>i \leqslant r</tex>. Тогда попробуем воспользоваться значениями, посчитанным ранее. Отразим нашу текущую позицию внутри палиндрома <tex>[l;r] : j = (r - i) + l</tex>. Поскольку <tex>i</tex> и <tex>j</tex> — симметричные позиции, то если <tex>d1[j] = k</tex>, мы можем утверждать, что и <tex>d1[i] = k</tex>. Это объясняется тем, что палиндром симметричен относительно своей центральной позиции. Т.е. если имеем некоторый палиндром длины <tex>k</tex> с центром в позиции <tex>l \leqslant i \leqslant r</tex>, то в позиции <tex>j</tex>, симметричной <tex>i</tex> относительно отрезка <tex>[l; r]</tex> тоже может находиться палиндром длины <tex>k</tex>. Это можно лучше понять, посмотрев на рисунок. Снизу фигурными скобками обозначены равные подстроки. Однако стоит не забыть про один граничный случай: что если <tex>i + d1[j] - 1</tex> выходит за границы самого правого палиндрома? Так как информации о том, что происходит за границами это палинлрома у нас нет (а значит мы не можем утверждать, что симметрия сохраняется), то необходимо ограничить значение <tex>d1[i]</tex> следующим образом: <tex>d1[i] = \min(r - i, d1[j])</tex>. После этого запустим наивный алгоритм, который будет увеличивать значение <tex>d1[i]</tex>, пока это возможно.

После каждого шага важно не забывать обновлять значения <tex>[l;r]</tex>.

Заметим, что массив <tex>d2</tex> считается аналогичным образом, нужно лишь немного изменить индексы.

[[Файл:Манакер.png]]

===Псевдокод===
Приведем код, который вычисляет значения массива <tex>d1</tex>:

// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate1('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i, d[r - i + l])
'''while''' i + k + 1 <= n '''and''' i - k - 1 > 0 '''and''' s[i + k + 1] == s[i - k - 1]
k++
d1[i] = k
'''if''' i + k > r
l = i - k
r = i + k
'''return''' d1

Вычисление значений массива <tex>d2</tex>:
// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate2('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i + 1, d[r - i + l + 1])
'''while''' i + k <= n '''and''' i - k - 1 > 0 '''and''' s[i + k] == s[i - k - 1]
k++
d2[i] = k
'''if''' i + k - 1 > r
l = i - k
r = i + k - 1
'''return''' d2

===Оценка сложности===
Внешний цикл в приведенном алгоритме выполняется ровно <tex>n</tex> раз, где <tex>n</tex> — длина строки. Попытаемся понять, сколько раз будет выполнен внутренний цикл, ответственный за наивный подсчет значений. Заметим, что каждая итерация вложенного цикла приводит к увеличению <tex>r</tex> на <tex>1</tex>. Действительно, возможны следующие случаи:

# <tex>i > r</tex>, т.е. сразу будет запущен наивный алгоритм и каждая его итерация будет увеличивать значение <tex>r</tex> хотя бы на <tex>1</tex>.
# <tex>i \leqslant r</tex>. Здесь опять два случая:
## <tex>i + d[j] - 1 \leqslant r</tex>, но тогда, очевидно, ни одной итерации вложенного цикла выполнено не будет.
## <tex>i + d[j] - 1 > r</tex>, тогда каждая итерация вложенного цикла приведет к увеличению <tex>r</tex> хотя бы на <tex>1</tex>.

Т.к. значение <tex>r</tex> не может увеличиваться более <tex>n</tex> раз, то описанный выше алгоритм работает за время <tex>O(n)</tex>.

== См. также ==
* [[Префикс-функция]]
* [[Z-функция]]
* [[Суффиксный массив]]
* [[Поиск наибольшей общей подстроки двух строк с использованием хеширования]]

== Источники информации ==
*[http://e-maxx.ru/algo/palindromes_count MAXimal :: algo :: Нахождение всех подпалиндромов]
* [[wikipedia:ru:Поиск_длиннейшей_подстроки-палиндрома| Википедия — Поиск длиннейшей подстроки-палиндрома]]
*[https://habrahabr.ru/post/276195/ Алгоритмы для поиска палиндромов — Хабр]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Основные определения. Простые комбинаторные свойства слов]]

Алгоритм Манакера

2016-04-18T19:56:24Z

217.66.158.37:

{{Шаблон:Задача
|definition =
Пусть дана строка <tex>s</tex>. Требуется найти количество подстрок <tex>s</tex>, являющиеся палиндромами. Более формально, все такие пары <tex>(i, j)</tex>, что <tex>s[i..j]</tex> — [[Основные_определения,_связанные_со_строками#palindrome | палиндром]].
}}

==Уточнение постановки==
Легко увидеть, что таких подстрок в худшем случае будет <tex>n^2</tex>. Значит, нужно найти компактный способ хранения информации о них. Пусть <tex>d1[i]</tex> — количество палиндромов нечетной длины с центром в позиции <tex>i</tex>, а <tex>d2[i]</tex> — аналогичная величина для палиндромов четной длины. Далее научимся вычислять значения этих массивов.

== Наивный алгоритм ==
=== Идея ===
Рассмотрим сначала задачу поиска палиндромов нечетной длины. Центром строки нечетной длины назовем символ под индексом <tex>\left\lfloor \dfrac{|t|}{2}\right\rfloor</tex>. Для каждой позиции в строке <tex>s</tex> найдем длину наибольшего палиндрома с центром в этой позиции. Очевидно, что если строка <tex>t</tex> является палиндромом, то строка полученная вычеркиванием первого и последнего символа из <tex>t</tex> также является палиндромом, поэтому длину палиндрома можно искать [[Целочисленный_двоичный_поиск | бинарным поиском]]. Проверить совпадение левой и правой половины можно выполнить за <tex>O(1)</tex>, используя метод хеширования.

Для палиндромов четной длины алгоритм такой же. Центр строки четной длины {{---}} некий мнимый элемент между <tex>\dfrac{|t|}{2} - 1</tex> и <tex>\dfrac{|t|}{2}</tex>. Только требуется проверять вторую строку со сдвигом на единицу. Следует заметить, что мы не посчитаем никакой палиндром дважды из-за четности-нечетности длин палиндромов.

=== Псевдокод ===
'''int''' binarySearch(s : '''string''', center, shift : '''int'''):
''//shift = 0 при поиске палиндрома нечетной длины, иначе shift = 1''
'''int''' l = -1, r = min(center, s.length - center + shift), m = 0
'''while''' r - l != 1
m = l + (r - l) / 2
''//reversed_hash возвращает хэш развернутой строки s''
'''if''' hash(s[center - m..center]) == reversed_hash(s[center + shift..center + shift + m])
l = m
'''else'''
r = m
'''return''' r

'''int''' palindromesCount(s : '''string'''):
'''int''' ans = 0
'''for''' i = 0 '''to''' s.length
ans += binarySearch(s, i, 0) + binarySearch(s, i, 1)
'''return''' ans

=== Время работы ===
Изначальный подсчет хешей производится за <tex>O(|s|)</tex>. Каждая итерация будет выполняться за <tex>O(\log(|s|))</tex>, всего итераций {{---}} <tex>|s|</tex>. Итоговое время работы алгоритма <tex>O(|s|+|s|\cdot \log(|s|)) = O(|s|\cdot \log(|s|))</tex>.

=== Избавление от коллизий ===
У хешей есть один недостаток {{---}} коллизии: можно подобрать входные данные так, что хеши разных строк будут совпадать. Абсолютно точно проверить две подстроки на совпадение можно с помощью [[Суффиксный массив | суффиксного массива]], но с дополнительной памятью <tex>O(|s|\cdot \log(|s|))</tex>. Для этого построим суффиксный массив для строки <tex>s + \# + reverse(s)</tex>, при этом сохраним промежуточные результаты классов эквивалентности <tex>c</tex>. Пусть нам требуется проверить на совпадение подстроки <tex>s[i..i + l]</tex> и <tex>s[j..j + l]</tex>. Разобьем каждую нашу строку на две пересекающиеся подстроки длиной <tex>2^k</tex>, где <tex>k = \lfloor \log{l} \rfloor</tex>. Тогда наши строки совпадают, если <tex>c[k][i] = c[k][j]</tex> и <tex>c[k][i + l - 2^k] = c[k][j + l - 2^k]</tex>.

Итоговая асимптотика алгоритма: предподсчет за построение суффиксного массива и <tex>O(\log(|s|))</tex> на запрос, если предподсчитать все <tex>k</tex>, то <tex>O(1)</tex>.

==Алгоритм Манакера==
===Идея===
Алгоритм, который будет описан далее, отличается от наивного тем, что использует значения, посчитанные ранее.
Будем поддерживать границы самого правого из найденных палиндромов — <tex>[l; r]</tex>. Итак, пусть мы хотим вычислить <tex>d1[i]</tex> — т.е. длину наибольшего палиндрома с центром в позиции <tex>i</tex>. При этом все предыдущие значения в массиве <tex>d</tex> уже посчитаны. Возможны два случая:

# <tex>i > r</tex>, т.е. текущая позиция не попадает в границы самого правого из найденных палиндромов. Тогда просто запустим наивный алгоритм для позиции <tex>i</tex>.
# <tex>i \leqslant r</tex>. Тогда попробуем воспользоваться значениями, посчитанным ранее. Отразим нашу текущую позицию внутри палиндрома <tex>[l;r] : j = (r - i) + l</tex>. Поскольку <tex>i</tex> и <tex>j</tex> — симметричные позиции, то если <tex>d1[j] = k</tex>, мы можем утверждать, что и <tex>d1[i] = k</tex>. Это объясняется тем, что палиндром симметричен относительно своей центральной позиции. Т.е. если имеем некоторый палиндром длины <tex>k</tex> с центром в позиции <tex>l \leqslant i \leqslant r</tex>, то в позиции <tex>j</tex>, симметричной <tex>i</tex> относительно отрезка <tex>[l; r]</tex> тоже может находиться палиндром длины <tex>k</tex>. Это можно лучше понять, посмотрев на рисунок. Снизу фигурными скобками обозначены равные подстроки. Однако стоит не забыть про один граничный случай: что если <tex>i + d1[j] - 1</tex> выходит за границы самого правого палиндрома? Так как информации о том, что происходит за границами это палинлрома у нас нет (а значит мы не можем утверждать, что симметрия сохраняется), то необходимо ограничить значение <tex>d1[i]</tex> следующим образом: <tex>d1[i] = \min(r - i, d1[j])</tex>. После этого запустим наивный алгоритм, который будет увеличивать значение <tex>d1[i]</tex>, пока это возможно.

После каждого шага важно не забывать обновлять значения <tex>[l;r]</tex>.

Заметим, что массив <tex>d2</tex> считается аналогичным образом, нужно лишь немного изменить индексы.

[[Файл:Манакер.png]]

===Псевдокод===
Приведем код, который вычисляет значения массива <tex>d1</tex>:

// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate1('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i, d[r - i + l])
'''while''' i + k + 1 <= n '''and''' i - k - 1 > 0 '''and''' s[i + k + 1] == s[i - k - 1]
k++
d1[i] = k
'''if''' i + k > r
l = i - k
r = i + k
'''return''' d1

Вычисление значений массива <tex>d2</tex>:
// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate2('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i + 1, d[r - i + l + 1])
'''while''' i + k <= n '''and''' i - k - 1 > 0 '''and''' s[i + k] == s[i - k - 1]
k++
d2[i] = k
'''if''' i + k - 1 > r
l = i - k
r = i + k - 1
'''return''' d2

===Оценка сложности===
Внешний цикл в приведенном алгоритме выполняется ровно <tex>n</tex> раз, где <tex>n</tex> — длина строки. Попытаемся понять, сколько раз будет выполнен внутренний цикл, ответственный за наивный подсчет значений. Заметим, что каждая итерация вложенного цикла приводит к увеличению <tex>r</tex> на <tex>1</tex>. Действительно, возможны следующие случаи:

# <tex>i > r</tex>, т.е. сразу будет запущен наивный алгоритм и каждая его итерация будет увеличивать значение <tex>r</tex> хотя бы на <tex>1</tex>.
# <tex>i \leqslant r</tex>. Здесь опять два случая:
## <tex>i + d[j] - 1 \leqslant r</tex>, но тогда, очевидно, ни одной итерации вложенного цикла выполнено не будет.
## <tex>i + d[j] - 1 > r</tex>, тогда каждая итерация вложенного цикла приведет к увеличению <tex>r</tex> хотя бы на <tex>1</tex>.

Т.к. значение <tex>r</tex> не может увеличиваться более <tex>n</tex> раз, то описанный выше алгоритм работает за время <tex>O(n)</tex>.

== См. также ==
* [[Префикс-функция]]
* [[Z-функция]]

== Источники информации ==
*[http://e-maxx.ru/algo/palindromes_count MAXimal :: algo :: Нахождение всех подпалиндромов]
* [[wikipedia:ru:Поиск_длиннейшей_подстроки-палиндрома| Википедия — Поиск длиннейшей подстроки-палиндрома]]
*[https://habrahabr.ru/post/276195/ Алгоритмы для поиска палиндромов — Хабр]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Основные определения. Простые комбинаторные свойства слов]]

Алгоритм Манакера

2016-04-16T18:56:00Z

217.66.158.37: /* Источники информации */

{{Шаблон:Задача
|definition =
Пусть дана строка <tex>s</tex>. Требуется найти количество подстрок <tex>s</tex>, являющиеся палиндромами. Более формально, все такие пары <tex>(i, j)</tex>, что <tex>s[i..j]</tex> — [[Основные_определения,_связанные_со_строками#palindrome | палиндром]].
}}

==Уточнение постановки==
Легко увидеть, что таких подстрок в худшем случае будет <tex>n^2</tex>. Значит, нужно найти компактный способ хранения информации о них. Пусть <tex>d1[i]</tex> — количество палиндромов нечетной длины с центром в позиции <tex>i</tex>, а <tex>d2[i]</tex> — аналогичная величина для палиндромов четной длины. Далее научимся вычислять значения этих массивов.

== Наивный алгоритм ==
===Идея===
Опишем сначала наивный алгоритм решения задачи. Чтобы посчитать ответ для позиции <tex>i</tex>, будем на каждом шаге увеличивать длину палиндрома с центром в <tex>i</tex> и убеждаться, что рассматриваемая строка не перестала быть палиндромом, либо не произошел выход за границы массива. Очевидно, что такой алгоритм будет работать за <tex>O(n^2)</tex>.

===Псевдокод===
// <tex>s</tex> {{---}} исходная строка
// <tex>d1, d2</tex> {{---}} массивы для записи ответа
'''(int[], int[])''' calculate('''string''' s):
'''for''' i = 1 '''to''' n
d1[i] = 1
'''while''' i - d1[i] > 0 '''and''' i + d1[i] <= n '''and''' s[i - d1[i]] == s[i + d1[i]]
d1[i]++
d2[i] = 0
'''while''' i - d2[i] - 1 > 0 '''and''' i + d2[i] <= n '''and''' s[i - d2[i] - 1] == s[i + d2[i]]
d2[i]++
'''return''' (d1, d2)

==Алгоритм Манакера==
===Идея===
Алгоритм, который будет описан далее, отличается от наивного тем, что использует значения, посчитанные ранее.
Будем поддерживать границы самого правого из найденных палиндромов — <tex>[l; r]</tex>. Итак, пусть мы хотим вычислить <tex>d1[i]</tex> — т.е. длину наибольшего палиндрома с центром в позиции <tex>i</tex>. При этом все предыдущие значения в массиве <tex>d</tex> уже посчитаны. Возможны два случая:

# <tex>i > r</tex>, т.е. текущая позиция не попадает в границы самого правого из найденных палиндромов. Тогда просто запустим наивный алгоритм для позиции <tex>i</tex>.
# <tex>i \leqslant r</tex>. Тогда попробуем воспользоваться значениями, посчитанным ранее. Отразим нашу текущую позицию внутри палиндрома <tex>[l;r] : j = (r - i) + l</tex>. Поскольку <tex>i</tex> и <tex>j</tex> — симметричные позиции, то если <tex>d1[j] = k</tex>, мы можем утверждать, что и <tex>d1[i] = k</tex>. Это объясняется тем, что палиндром симметричен относительно своей центральной позиции. Т.е. если имеем некоторый палиндром длины <tex>k</tex> с центром в позиции <tex>l \leqslant i \leqslant r</tex>, то в позиции <tex>j</tex>, симметричной <tex>i</tex> относительно отрезка <tex>[l; r]</tex> тоже может находиться палиндром длины <tex>k</tex>. Это можно лучше понять, посмотрев на рисунок. Снизу фигурными скобками обозначены равные подстроки. Однако стоит не забыть про один граничный случай: что если <tex>i + d1[j] - 1</tex> выходит за границы самого правого палиндрома? Так как информации о том, что происходит за границами это палинлрома у нас нет (а значит мы не можем утверждать, что симметрия сохраняется), то необходимо ограничить значение <tex>d1[i]</tex> следующим образом: <tex>d1[i] = \min(r - i, d1[j])</tex>. После этого запустим наивный алгоритм, который будет увеличивать значение <tex>d1[i]</tex>, пока это возможно.

После каждого шага важно не забывать обновлять значения <tex>[l;r]</tex>.

Заметим, что массив <tex>d2</tex> считается аналогичным образом, нужно лишь немного изменить индексы.

[[Файл:Манакер.png]]

===Псевдокод===
Приведем код, который вычисляет значения массива <tex>d1</tex>:

// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate1('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i, d[r - i + l])
'''while''' i + k + 1 <= n '''and''' i - k - 1 > 0 '''and''' s[i + k + 1] == s[i - k - 1]
k++
d1[i] = k
'''if''' i + k > r
l = i - k
r = i + k
'''return''' d1

Вычисление значений массива <tex>d2</tex>:
// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate2('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i + 1, d[r - i + l + 1])
'''while''' i + k <= n '''and''' i - k - 1 > 0 '''and''' s[i + k] == s[i - k - 1]
k++
d2[i] = k
'''if''' i + k - 1 > r
l = i - k
r = i + k - 1
'''return''' d2

===Оценка сложности===
Внешний цикл в приведенном алгоритме выполняется ровно <tex>n</tex> раз, где <tex>n</tex> — длина строки. Попытаемся понять, сколько раз будет выполнен внутренний цикл, ответственный за наивный подсчет значений. Заметим, что каждая итерация вложенного цикла приводит к увеличению <tex>r</tex> на <tex>1</tex>. Действительно, возможны следующие случаи:

# <tex>i > r</tex>, т.е. сразу будет запущен наивный алгоритм и каждая его итерация будет увеличивать значение <tex>r</tex> хотя бы на <tex>1</tex>.
# <tex>i \leqslant r</tex>. Здесь опять два случая:
## <tex>i + d[j] - 1 \leqslant r</tex>, но тогда, очевидно, ни одной итерации вложенного цикла выполнено не будет.
## <tex>i + d[j] - 1 > r</tex>, тогда каждая итерация вложенного цикла приведет к увеличению <tex>r</tex> хотя бы на <tex>1</tex>.

Т.к. значение <tex>r</tex> не может увеличиваться более <tex>n</tex> раз, то описанный выше алгоритм работает за время <tex>O(n)</tex>.

== См. также ==
* [[Префикс-функция]]
* [[Z-функция]]

== Источники информации ==
*[http://e-maxx.ru/algo/palindromes_count MAXimal :: algo :: Нахождение всех подпалиндромов]
* [[wikipedia:ru:Поиск_длиннейшей_подстроки-палиндрома| Википедия — Поиск длиннейшей подстроки-палиндрома]]
*[https://habrahabr.ru/post/276195/ Алгоритмы для поиска палиндромов — Хабр]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Основные определения. Простые комбинаторные свойства слов]]

Алгоритм Манакера

2016-04-16T18:53:44Z

217.66.158.37:

{{Шаблон:Задача
|definition =
Пусть дана строка <tex>s</tex>. Требуется найти количество подстрок <tex>s</tex>, являющиеся палиндромами. Более формально, все такие пары <tex>(i, j)</tex>, что <tex>s[i..j]</tex> — [[Основные_определения,_связанные_со_строками#palindrome | палиндром]].
}}

==Уточнение постановки==
Легко увидеть, что таких подстрок в худшем случае будет <tex>n^2</tex>. Значит, нужно найти компактный способ хранения информации о них. Пусть <tex>d1[i]</tex> — количество палиндромов нечетной длины с центром в позиции <tex>i</tex>, а <tex>d2[i]</tex> — аналогичная величина для палиндромов четной длины. Далее научимся вычислять значения этих массивов.

== Наивный алгоритм ==
===Идея===
Опишем сначала наивный алгоритм решения задачи. Чтобы посчитать ответ для позиции <tex>i</tex>, будем на каждом шаге увеличивать длину палиндрома с центром в <tex>i</tex> и убеждаться, что рассматриваемая строка не перестала быть палиндромом, либо не произошел выход за границы массива. Очевидно, что такой алгоритм будет работать за <tex>O(n^2)</tex>.

===Псевдокод===
// <tex>s</tex> {{---}} исходная строка
// <tex>d1, d2</tex> {{---}} массивы для записи ответа
'''(int[], int[])''' calculate('''string''' s):
'''for''' i = 1 '''to''' n
d1[i] = 1
'''while''' i - d1[i] > 0 '''and''' i + d1[i] <= n '''and''' s[i - d1[i]] == s[i + d1[i]]
d1[i]++
d2[i] = 0
'''while''' i - d2[i] - 1 > 0 '''and''' i + d2[i] <= n '''and''' s[i - d2[i] - 1] == s[i + d2[i]]
d2[i]++
'''return''' (d1, d2)

==Алгоритм Манакера==
===Идея===
Алгоритм, который будет описан далее, отличается от наивного тем, что использует значения, посчитанные ранее.
Будем поддерживать границы самого правого из найденных палиндромов — <tex>[l; r]</tex>. Итак, пусть мы хотим вычислить <tex>d1[i]</tex> — т.е. длину наибольшего палиндрома с центром в позиции <tex>i</tex>. При этом все предыдущие значения в массиве <tex>d</tex> уже посчитаны. Возможны два случая:

# <tex>i > r</tex>, т.е. текущая позиция не попадает в границы самого правого из найденных палиндромов. Тогда просто запустим наивный алгоритм для позиции <tex>i</tex>.
# <tex>i \leqslant r</tex>. Тогда попробуем воспользоваться значениями, посчитанным ранее. Отразим нашу текущую позицию внутри палиндрома <tex>[l;r] : j = (r - i) + l</tex>. Поскольку <tex>i</tex> и <tex>j</tex> — симметричные позиции, то если <tex>d1[j] = k</tex>, мы можем утверждать, что и <tex>d1[i] = k</tex>. Это объясняется тем, что палиндром симметричен относительно своей центральной позиции. Т.е. если имеем некоторый палиндром длины <tex>k</tex> с центром в позиции <tex>l \leqslant i \leqslant r</tex>, то в позиции <tex>j</tex>, симметричной <tex>i</tex> относительно отрезка <tex>[l; r]</tex> тоже может находиться палиндром длины <tex>k</tex>. Это можно лучше понять, посмотрев на рисунок. Снизу фигурными скобками обозначены равные подстроки. Однако стоит не забыть про один граничный случай: что если <tex>i + d1[j] - 1</tex> выходит за границы самого правого палиндрома? Так как информации о том, что происходит за границами это палинлрома у нас нет (а значит мы не можем утверждать, что симметрия сохраняется), то необходимо ограничить значение <tex>d1[i]</tex> следующим образом: <tex>d1[i] = \min(r - i, d1[j])</tex>. После этого запустим наивный алгоритм, который будет увеличивать значение <tex>d1[i]</tex>, пока это возможно.

После каждого шага важно не забывать обновлять значения <tex>[l;r]</tex>.

Заметим, что массив <tex>d2</tex> считается аналогичным образом, нужно лишь немного изменить индексы.

[[Файл:Манакер.png]]

===Псевдокод===
Приведем код, который вычисляет значения массива <tex>d1</tex>:

// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate1('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i, d[r - i + l])
'''while''' i + k + 1 <= n '''and''' i - k - 1 > 0 '''and''' s[i + k + 1] == s[i - k - 1]
k++
d1[i] = k
'''if''' i + k > r
l = i - k
r = i + k
'''return''' d1

Вычисление значений массива <tex>d2</tex>:
// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate2('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i + 1, d[r - i + l + 1])
'''while''' i + k <= n '''and''' i - k - 1 > 0 '''and''' s[i + k] == s[i - k - 1]
k++
d2[i] = k
'''if''' i + k - 1 > r
l = i - k
r = i + k - 1
'''return''' d2

===Оценка сложности===
Внешний цикл в приведенном алгоритме выполняется ровно <tex>n</tex> раз, где <tex>n</tex> — длина строки. Попытаемся понять, сколько раз будет выполнен внутренний цикл, ответственный за наивный подсчет значений. Заметим, что каждая итерация вложенного цикла приводит к увеличению <tex>r</tex> на <tex>1</tex>. Действительно, возможны следующие случаи:

# <tex>i > r</tex>, т.е. сразу будет запущен наивный алгоритм и каждая его итерация будет увеличивать значение <tex>r</tex> хотя бы на <tex>1</tex>.
# <tex>i \leqslant r</tex>. Здесь опять два случая:
## <tex>i + d[j] - 1 \leqslant r</tex>, но тогда, очевидно, ни одной итерации вложенного цикла выполнено не будет.
## <tex>i + d[j] - 1 > r</tex>, тогда каждая итерация вложенного цикла приведет к увеличению <tex>r</tex> хотя бы на <tex>1</tex>.

Т.к. значение <tex>r</tex> не может увеличиваться более <tex>n</tex> раз, то описанный выше алгоритм работает за время <tex>O(n)</tex>.

== См. также ==
* [[Префикс-функция]]
* [[Z-функция]]

== Источники информации ==
*[http://e-maxx.ru/algo/palindromes_count MAXimal :: algo :: Нахождение всех подпалиндромов]
* [[wikipedia:ru:Поиск_длиннейшей_подстроки-палиндрома| Википедия — Поиск длиннейшей подстроки-палиндрома]]
*[https://habrahabr.ru/post/276195/ Алгоритмы для поиска палиндромов — Хабр]

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

Алгоритм Манакера

2016-04-16T18:44:36Z

217.66.158.37: /* Идея */

{{Шаблон:Задача
|definition =
Пусть дана строка <tex>s</tex>. Требуется найти количество подстрок <tex>s</tex>, являющиеся палиндромами. Более формально, все такие пары <tex>(i, j)</tex>, что <tex>s[i..j]</tex> — [[Основные_определения,_связанные_со_строками#Отношения_между_строками | палиндром]].
}}

==Уточнение постановки==
Легко увидеть, что таких подстрок в худшем случае будет <tex>n^2</tex>. Значит, нужно найти компактный способ хранения информации о них. Пусть <tex>d1[i]</tex> — количество палиндромов нечетной длины с центром в позиции <tex>i</tex>, а <tex>d2[i]</tex> — аналогичная величина для палиндромов четной длины. Далее научимся вычислять значения этих массивов.

== Наивный алгоритм ==
===Идея===
Опишем сначала наивный алгоритм решения задачи. Чтобы посчитать ответ для позиции <tex>i</tex>, будем на каждом шаге увеличивать длину палиндрома с центром в <tex>i</tex> и убеждаться, что рассматриваемая строка не перестала быть палиндромом, либо не произошел выход за границы массива. Очевидно, что такой алгоритм будет работать за <tex>O(n^2)</tex>.

===Псевдокод===
// <tex>s</tex> {{---}} исходная строка
// <tex>d1, d2</tex> {{---}} массивы для записи ответа
'''(int[], int[])''' calculate('''string''' s):
'''for''' i = 1 '''to''' n
d1[i] = 1
'''while''' i - d1[i] > 0 '''and''' i + d1[i] <= n '''and''' s[i - d1[i]] == s[i + d1[i]]
d1[i]++
d2[i] = 0
'''while''' i - d2[i] - 1 > 0 '''and''' i + d2[i] <= n '''and''' s[i - d2[i] - 1] == s[i + d2[i]]
d2[i]++
'''return''' (d1, d2)

==Алгоритм Манакера==
===Идея===
Алгоритм, который будет описан далее, отличается от наивного тем, что использует значения, посчитанные ранее.
Будем поддерживать границы самого правого из найденных палиндромов — <tex>[l; r]</tex>. Итак, пусть мы хотим вычислить <tex>d1[i]</tex> — т.е. длину наибольшего палиндрома с центром в позиции <tex>i</tex>. При этом все предыдущие значения в массиве <tex>d</tex> уже посчитаны. Возможны два случая:

# <tex>i > r</tex>, т.е. текущая позиция не попадает в границы самого правого из найденных палиндромов. Тогда просто запустим наивный алгоритм для позиции <tex>i</tex>.
# <tex>i \leqslant r</tex>. Тогда попробуем воспользоваться значениями, посчитанным ранее. Отразим нашу текущую позицию внутри палиндрома <tex>[l;r] : j = (r - i) + l</tex>. Поскольку <tex>i</tex> и <tex>j</tex> — симметричные позиции, то если <tex>d1[j] = k</tex>, мы можем утверждать, что и <tex>d1[i] = k</tex>. Это объясняется тем, что палиндром симметричен относительно своей центральной позиции. Т.е. если имеем некоторый палиндром длины <tex>k</tex> с центром в позиции <tex>l \leqslant i \leqslant r</tex>, то в позиции <tex>j</tex>, симметричной <tex>i</tex> относительно отрезка <tex>[l; r]</tex> тоже может находиться палиндром длины <tex>k</tex>. Это можно лучше понять, посмотрев на рисунок. Снизу фигурными скобками обозначены равные подстроки. Однако стоит не забыть про один граничный случай: что если <tex>i + d1[j] - 1</tex> выходит за границы самого правого палиндрома? Так как информации о том, что происходит за границами это палинлрома у нас нет (а значит мы не можем утверждать, что симметрия сохраняется), то необходимо ограничить значение <tex>d1[i]</tex> следующим образом: <tex>d1[i] = \min(r - i, d1[j])</tex>. После этого запустим наивный алгоритм, который будет увеличивать значение <tex>d1[i]</tex>, пока это возможно.

После каждого шага важно не забывать обновлять значения <tex>[l;r]</tex>.

Заметим, что массив <tex>d2</tex> считается аналогичным образом, нужно лишь немного изменить индексы.

[[Файл:Манакер.png]]

===Псевдокод===
Приведем код, который вычисляет значения массива <tex>d1</tex>:

// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate1('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i, d[r - i + l])
'''while''' i + k + 1 <= n '''and''' i - k - 1 > 0 '''and''' s[i + k + 1] == s[i - k - 1]
k++
d1[i] = k
'''if''' i + k > r
l = i - k
r = i + k
'''return''' d1

Вычисление значений массива <tex>d2</tex>:
// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate2('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i + 1, d[r - i + l + 1])
'''while''' i + k <= n '''and''' i - k - 1 > 0 '''and''' s[i + k] == s[i - k - 1]
k++
d2[i] = k
'''if''' i + k - 1 > r
l = i - k
r = i + k - 1
'''return''' d2

===Оценка сложности===
Внешний цикл в приведенном алгоритме выполняется ровно <tex>n</tex> раз, где <tex>n</tex> — длина строки. Попытаемся понять, сколько раз будет выполнен внутренний цикл, ответственный за наивный подсчет значений. Заметим, что каждая итерация вложенного цикла приводит к увеличению <tex>r</tex> на <tex>1</tex>. Действительно, возможны следующие случаи:

# <tex>i > r</tex>, т.е. сразу будет запущен наивный алгоритм и каждая его итерация будет увеличивать значение <tex>r</tex> хотя бы на <tex>1</tex>.
# <tex>i \leqslant r</tex>. Здесь опять два случая:
## <tex>i + d[j] - 1 \leqslant r</tex>, но тогда, очевидно, ни одной итерации вложенного цикла выполнено не будет.
## <tex>i + d[j] - 1 > r</tex>, тогда каждая итерация вложенного цикла приведет к увеличению <tex>r</tex> хотя бы на <tex>1</tex>.

Т.к. значение <tex>r</tex> не может увеличиваться более <tex>n</tex> раз, то описанный выше алгоритм работает за время <tex>O(n)</tex>.

== См. также ==
* [[Префикс-функция]]
* [[Z-функция]]

== Источники информации ==
*[http://e-maxx.ru/algo/palindromes_count MAXimal :: algo :: Нахождение всех подпалиндромов]
* [[wikipedia:ru:Поиск_длиннейшей_подстроки-палиндрома| Википедия — Поиск длиннейшей подстроки-палиндрома]]
*[https://habrahabr.ru/post/276195/ Алгоритмы для поиска палиндромов — Хабр]

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

Алгоритм Манакера

2016-04-16T18:44:03Z

217.66.158.37: /* См. также */

{{Шаблон:Задача
|definition =
Пусть дана строка <tex>s</tex>. Требуется найти количество подстрок <tex>s</tex>, являющиеся палиндромами. Более формально, все такие пары <tex>(i, j)</tex>, что <tex>s[i..j]</tex> — [[Основные_определения,_связанные_со_строками#Отношения_между_строками | палиндром]].
}}

==Уточнение постановки==
Легко увидеть, что таких подстрок в худшем случае будет <tex>n^2</tex>. Значит, нужно найти компактный способ хранения информации о них. Пусть <tex>d1[i]</tex> — количество палиндромов нечетной длины с центром в позиции <tex>i</tex>, а <tex>d2[i]</tex> — аналогичная величина для палиндромов четной длины. Далее научимся вычислять значения этих массивов.

== Наивный алгоритм ==
===Идея===
Опишем сначала наивный алгоритм решения задачи. Чтобы посчитать ответ для позиции <tex>i</tex>, будем на каждом шаге увеличивать длину палиндрома с центром в <tex>i</tex> и убеждаться, что рассматриваемая строка не перестала быть палиндромом, либо не произошел выход за границы массива. Очевидно, что такой алгоритм будет работать за <tex>O(n^2)</tex>.

===Псевдокод===
// <tex>s</tex> {{---}} исходная строка
// <tex>d1, d2</tex> {{---}} массивы для записи ответа
'''(int[], int[])''' calculate('''string''' s):
'''for''' i = 1 '''to''' n
d1[i] = 1
'''while''' i - d1[i] > 0 '''and''' i + d1[i] <= n '''and''' s[i - d1[i]] == s[i + d1[i]]
d1[i]++
d2[i] = 0
'''while''' i - d2[i] - 1 > 0 '''and''' i + d2[i] <= n '''and''' s[i - d2[i] - 1] == s[i + d2[i]]
d2[i]++
'''return''' (d1, d2)

==Алгоритм Манакера==
===Идея===
Алгоритм, который будет описан далее, отличается от наивного тем, что использует значения, посчитанные ранее.
Будем поддерживать границы самого правого из найденных палиндромов — <tex>[l; r]</tex>. Итак, пусть мы хотим вычислить <tex>d1[i]</tex> — т.е. длину наибольшего палиндрома с центром в позиции <tex>i</tex>. При этом все предыдущие значения в массиве <tex>d</tex> уже посчитаны. Возможны два случая:

# <tex>i > r</tex>, т.е. текущая позиция не попадает в границы самого правого из найденных палиндромов. Тогда просто запустим наивный алгоритм для позиции <tex>i</tex>.
# <tex>i \leqslant r</tex>. Тогда попробуем воспользоваться значениями, посчитанным ранее. Отразим нашу текущую позицию внутри палиндрома <tex>[l;r] : j = (r - i) + l</tex>. Поскольку <tex>i</tex> и <tex>j</tex> — симметричные позиции, то если <tex>d1[j] = k</tex>, мы можем утверждать, что и <tex>d1[i] = k</tex>. Это объясняется тем, что палиндром симметричен относительно своей центральной позиции. Т.е. если имеем некоторый палиндром длины <tex>k</tex> с центром в позиции <tex>l \leqslant i \leqslant r</tex>, то в позиции <tex>j</tex>, симметричной <tex>i</tex> относительно отрезка <tex>[l; r]</tex> тоже может находиться палиндром длины <tex>k</tex>. Это можно лучше понять, посмотрев на рисунок. Снизу фигурными скобками обозначены равные подстроки. Однако стоит не забыть про один граничный случай: что если <tex>i + d1[j] - 1</tex> выходит за границы самого правого палиндрома? Так как информации о том, что происходит за границами это палинлрома у нас нет (а значит мы не можем утверждать, что симметрия сохраняется), то необходимо ограничить значение <tex>d1[i]</tex> следующим образом: <tex>d1[i] = min(r - i, d1[j])</tex>. После этого запустим наивный алгоритм, который будет увеличивать значение <tex>d1[i]</tex>, пока это возможно.

После каждого шага важно не забывать обновлять значения <tex>[l;r]</tex>.

Заметим, что массив <tex>d2</tex> считается аналогичным образом, нужно лишь немного изменить индексы.

[[Файл:Манакер.png]]

===Псевдокод===
Приведем код, который вычисляет значения массива <tex>d1</tex>:

// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate1('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i, d[r - i + l])
'''while''' i + k + 1 <= n '''and''' i - k - 1 > 0 '''and''' s[i + k + 1] == s[i - k - 1]
k++
d1[i] = k
'''if''' i + k > r
l = i - k
r = i + k
'''return''' d1

Вычисление значений массива <tex>d2</tex>:
// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate2('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i + 1, d[r - i + l + 1])
'''while''' i + k <= n '''and''' i - k - 1 > 0 '''and''' s[i + k] == s[i - k - 1]
k++
d2[i] = k
'''if''' i + k - 1 > r
l = i - k
r = i + k - 1
'''return''' d2

===Оценка сложности===
Внешний цикл в приведенном алгоритме выполняется ровно <tex>n</tex> раз, где <tex>n</tex> — длина строки. Попытаемся понять, сколько раз будет выполнен внутренний цикл, ответственный за наивный подсчет значений. Заметим, что каждая итерация вложенного цикла приводит к увеличению <tex>r</tex> на <tex>1</tex>. Действительно, возможны следующие случаи:

# <tex>i > r</tex>, т.е. сразу будет запущен наивный алгоритм и каждая его итерация будет увеличивать значение <tex>r</tex> хотя бы на <tex>1</tex>.
# <tex>i \leqslant r</tex>. Здесь опять два случая:
## <tex>i + d[j] - 1 \leqslant r</tex>, но тогда, очевидно, ни одной итерации вложенного цикла выполнено не будет.
## <tex>i + d[j] - 1 > r</tex>, тогда каждая итерация вложенного цикла приведет к увеличению <tex>r</tex> хотя бы на <tex>1</tex>.

Т.к. значение <tex>r</tex> не может увеличиваться более <tex>n</tex> раз, то описанный выше алгоритм работает за время <tex>O(n)</tex>.

== См. также ==
* [[Префикс-функция]]
* [[Z-функция]]

== Источники информации ==
*[http://e-maxx.ru/algo/palindromes_count MAXimal :: algo :: Нахождение всех подпалиндромов]
* [[wikipedia:ru:Поиск_длиннейшей_подстроки-палиндрома| Википедия — Поиск длиннейшей подстроки-палиндрома]]
*[https://habrahabr.ru/post/276195/ Алгоритмы для поиска палиндромов — Хабр]

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

Алгоритм Манакера

2016-04-16T18:42:40Z

217.66.158.37: /* Уточнение постановки */

{{Шаблон:Задача
|definition =
Пусть дана строка <tex>s</tex>. Требуется найти количество подстрок <tex>s</tex>, являющиеся палиндромами. Более формально, все такие пары <tex>(i, j)</tex>, что <tex>s[i..j]</tex> — [[Основные_определения,_связанные_со_строками#Отношения_между_строками | палиндром]].
}}

==Уточнение постановки==
Легко увидеть, что таких подстрок в худшем случае будет <tex>n^2</tex>. Значит, нужно найти компактный способ хранения информации о них. Пусть <tex>d1[i]</tex> — количество палиндромов нечетной длины с центром в позиции <tex>i</tex>, а <tex>d2[i]</tex> — аналогичная величина для палиндромов четной длины. Далее научимся вычислять значения этих массивов.

== Наивный алгоритм ==
===Идея===
Опишем сначала наивный алгоритм решения задачи. Чтобы посчитать ответ для позиции <tex>i</tex>, будем на каждом шаге увеличивать длину палиндрома с центром в <tex>i</tex> и убеждаться, что рассматриваемая строка не перестала быть палиндромом, либо не произошел выход за границы массива. Очевидно, что такой алгоритм будет работать за <tex>O(n^2)</tex>.

===Псевдокод===
// <tex>s</tex> {{---}} исходная строка
// <tex>d1, d2</tex> {{---}} массивы для записи ответа
'''(int[], int[])''' calculate('''string''' s):
'''for''' i = 1 '''to''' n
d1[i] = 1
'''while''' i - d1[i] > 0 '''and''' i + d1[i] <= n '''and''' s[i - d1[i]] == s[i + d1[i]]
d1[i]++
d2[i] = 0
'''while''' i - d2[i] - 1 > 0 '''and''' i + d2[i] <= n '''and''' s[i - d2[i] - 1] == s[i + d2[i]]
d2[i]++
'''return''' (d1, d2)

==Алгоритм Манакера==
===Идея===
Алгоритм, который будет описан далее, отличается от наивного тем, что использует значения, посчитанные ранее.
Будем поддерживать границы самого правого из найденных палиндромов — <tex>[l; r]</tex>. Итак, пусть мы хотим вычислить <tex>d1[i]</tex> — т.е. длину наибольшего палиндрома с центром в позиции <tex>i</tex>. При этом все предыдущие значения в массиве <tex>d</tex> уже посчитаны. Возможны два случая:

# <tex>i > r</tex>, т.е. текущая позиция не попадает в границы самого правого из найденных палиндромов. Тогда просто запустим наивный алгоритм для позиции <tex>i</tex>.
# <tex>i \leqslant r</tex>. Тогда попробуем воспользоваться значениями, посчитанным ранее. Отразим нашу текущую позицию внутри палиндрома <tex>[l;r] : j = (r - i) + l</tex>. Поскольку <tex>i</tex> и <tex>j</tex> — симметричные позиции, то если <tex>d1[j] = k</tex>, мы можем утверждать, что и <tex>d1[i] = k</tex>. Это объясняется тем, что палиндром симметричен относительно своей центральной позиции. Т.е. если имеем некоторый палиндром длины <tex>k</tex> с центром в позиции <tex>l \leqslant i \leqslant r</tex>, то в позиции <tex>j</tex>, симметричной <tex>i</tex> относительно отрезка <tex>[l; r]</tex> тоже может находиться палиндром длины <tex>k</tex>. Это можно лучше понять, посмотрев на рисунок. Снизу фигурными скобками обозначены равные подстроки. Однако стоит не забыть про один граничный случай: что если <tex>i + d1[j] - 1</tex> выходит за границы самого правого палиндрома? Так как информации о том, что происходит за границами это палинлрома у нас нет (а значит мы не можем утверждать, что симметрия сохраняется), то необходимо ограничить значение <tex>d1[i]</tex> следующим образом: <tex>d1[i] = min(r - i, d1[j])</tex>. После этого запустим наивный алгоритм, который будет увеличивать значение <tex>d1[i]</tex>, пока это возможно.

После каждого шага важно не забывать обновлять значения <tex>[l;r]</tex>.

Заметим, что массив <tex>d2</tex> считается аналогичным образом, нужно лишь немного изменить индексы.

[[Файл:Манакер.png]]

===Псевдокод===
Приведем код, который вычисляет значения массива <tex>d1</tex>:

// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate1('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i, d[r - i + l])
'''while''' i + k + 1 <= n '''and''' i - k - 1 > 0 '''and''' s[i + k + 1] == s[i - k - 1]
k++
d1[i] = k
'''if''' i + k > r
l = i - k
r = i + k
'''return''' d1

Вычисление значений массива <tex>d2</tex>:
// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate2('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i + 1, d[r - i + l + 1])
'''while''' i + k <= n '''and''' i - k - 1 > 0 '''and''' s[i + k] == s[i - k - 1]
k++
d2[i] = k
'''if''' i + k - 1 > r
l = i - k
r = i + k - 1
'''return''' d2

===Оценка сложности===
Внешний цикл в приведенном алгоритме выполняется ровно <tex>n</tex> раз, где <tex>n</tex> — длина строки. Попытаемся понять, сколько раз будет выполнен внутренний цикл, ответственный за наивный подсчет значений. Заметим, что каждая итерация вложенного цикла приводит к увеличению <tex>r</tex> на <tex>1</tex>. Действительно, возможны следующие случаи:

# <tex>i > r</tex>, т.е. сразу будет запущен наивный алгоритм и каждая его итерация будет увеличивать значение <tex>r</tex> хотя бы на <tex>1</tex>.
# <tex>i \leqslant r</tex>. Здесь опять два случая:
## <tex>i + d[j] - 1 \leqslant r</tex>, но тогда, очевидно, ни одной итерации вложенного цикла выполнено не будет.
## <tex>i + d[j] - 1 > r</tex>, тогда каждая итерация вложенного цикла приведет к увеличению <tex>r</tex> хотя бы на <tex>1</tex>.

Т.к. значение <tex>r</tex> не может увеличиваться более <tex>n</tex> раз, то описанный выше алгоритм работает за время <tex>O(n)</tex>.

== См. также ==
* [[Префикс-функция]]
* [[Z — функция]]

== Источники информации ==
*[http://e-maxx.ru/algo/palindromes_count MAXimal :: algo :: Нахождение всех подпалиндромов]
* [[wikipedia:ru:Поиск_длиннейшей_подстроки-палиндрома| Википедия — Поиск длиннейшей подстроки-палиндрома]]
*[https://habrahabr.ru/post/276195/ Алгоритмы для поиска палиндромов — Хабр]

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

Алгоритм Манакера

2016-04-16T18:41:26Z

217.66.158.37: /* Идея */

{{Шаблон:Задача
|definition =
Пусть дана строка <tex>s</tex>. Требуется найти количество подстрок <tex>s</tex>, являющиеся палиндромами. Более формально, все такие пары <tex>(i, j)</tex>, что <tex>s[i..j]</tex> — [[Основные_определения,_связанные_со_строками#Отношения_между_строками | палиндром]].
}}

==Уточнение постановки==
Легко увидеть, что таких подстрок в худшем случае будет <tex>n^2</tex>. Значит, нужно найти компактный способ хранения информации о них. Пусть <tex>d1[i]</tex> - количеств палиндромов нечетной длины с центром в позиции <tex>i</tex>, а <tex>d2[i]</tex> - аналогичная величина для палиндромов четной длины. Далее научимся вычислять значения этих массивов.

== Наивный алгоритм ==
===Идея===
Опишем сначала наивный алгоритм решения задачи. Чтобы посчитать ответ для позиции <tex>i</tex>, будем на каждом шаге увеличивать длину палиндрома с центром в <tex>i</tex> и убеждаться, что рассматриваемая строка не перестала быть палиндромом, либо не произошел выход за границы массива. Очевидно, что такой алгоритм будет работать за <tex>O(n^2)</tex>.

===Псевдокод===
// <tex>s</tex> {{---}} исходная строка
// <tex>d1, d2</tex> {{---}} массивы для записи ответа
'''(int[], int[])''' calculate('''string''' s):
'''for''' i = 1 '''to''' n
d1[i] = 1
'''while''' i - d1[i] > 0 '''and''' i + d1[i] <= n '''and''' s[i - d1[i]] == s[i + d1[i]]
d1[i]++
d2[i] = 0
'''while''' i - d2[i] - 1 > 0 '''and''' i + d2[i] <= n '''and''' s[i - d2[i] - 1] == s[i + d2[i]]
d2[i]++
'''return''' (d1, d2)

==Алгоритм Манакера==
===Идея===
Алгоритм, который будет описан далее, отличается от наивного тем, что использует значения, посчитанные ранее.
Будем поддерживать границы самого правого из найденных палиндромов — <tex>[l; r]</tex>. Итак, пусть мы хотим вычислить <tex>d1[i]</tex> — т.е. длину наибольшего палиндрома с центром в позиции <tex>i</tex>. При этом все предыдущие значения в массиве <tex>d</tex> уже посчитаны. Возможны два случая:

# <tex>i > r</tex>, т.е. текущая позиция не попадает в границы самого правого из найденных палиндромов. Тогда просто запустим наивный алгоритм для позиции <tex>i</tex>.
# <tex>i \leqslant r</tex>. Тогда попробуем воспользоваться значениями, посчитанным ранее. Отразим нашу текущую позицию внутри палиндрома <tex>[l;r] : j = (r - i) + l</tex>. Поскольку <tex>i</tex> и <tex>j</tex> — симметричные позиции, то если <tex>d1[j] = k</tex>, мы можем утверждать, что и <tex>d1[i] = k</tex>. Это объясняется тем, что палиндром симметричен относительно своей центральной позиции. Т.е. если имеем некоторый палиндром длины <tex>k</tex> с центром в позиции <tex>l \leqslant i \leqslant r</tex>, то в позиции <tex>j</tex>, симметричной <tex>i</tex> относительно отрезка <tex>[l; r]</tex> тоже может находиться палиндром длины <tex>k</tex>. Это можно лучше понять, посмотрев на рисунок. Снизу фигурными скобками обозначены равные подстроки. Однако стоит не забыть про один граничный случай: что если <tex>i + d1[j] - 1</tex> выходит за границы самого правого палиндрома? Так как информации о том, что происходит за границами это палинлрома у нас нет (а значит мы не можем утверждать, что симметрия сохраняется), то необходимо ограничить значение <tex>d1[i]</tex> следующим образом: <tex>d1[i] = min(r - i, d1[j])</tex>. После этого запустим наивный алгоритм, который будет увеличивать значение <tex>d1[i]</tex>, пока это возможно.

После каждого шага важно не забывать обновлять значения <tex>[l;r]</tex>.

Заметим, что массив <tex>d2</tex> считается аналогичным образом, нужно лишь немного изменить индексы.

[[Файл:Манакер.png]]

===Псевдокод===
Приведем код, который вычисляет значения массива <tex>d1</tex>:

// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate1('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i, d[r - i + l])
'''while''' i + k + 1 <= n '''and''' i - k - 1 > 0 '''and''' s[i + k + 1] == s[i - k - 1]
k++
d1[i] = k
'''if''' i + k > r
l = i - k
r = i + k
'''return''' d1

Вычисление значений массива <tex>d2</tex>:
// <tex>s</tex> {{---}} исходная строка
'''int[]''' calculate2('''string''' s):
'''int''' l = 0
'''int''' r = -1
'''for''' i = 1 '''to''' n
'''int''' k = 0
'''if''' i <= r
k = min(r - i + 1, d[r - i + l + 1])
'''while''' i + k <= n '''and''' i - k - 1 > 0 '''and''' s[i + k] == s[i - k - 1]
k++
d2[i] = k
'''if''' i + k - 1 > r
l = i - k
r = i + k - 1
'''return''' d2

===Оценка сложности===
Внешний цикл в приведенном алгоритме выполняется ровно <tex>n</tex> раз, где <tex>n</tex> — длина строки. Попытаемся понять, сколько раз будет выполнен внутренний цикл, ответственный за наивный подсчет значений. Заметим, что каждая итерация вложенного цикла приводит к увеличению <tex>r</tex> на <tex>1</tex>. Действительно, возможны следующие случаи:

# <tex>i > r</tex>, т.е. сразу будет запущен наивный алгоритм и каждая его итерация будет увеличивать значение <tex>r</tex> хотя бы на <tex>1</tex>.
# <tex>i \leqslant r</tex>. Здесь опять два случая:
## <tex>i + d[j] - 1 \leqslant r</tex>, но тогда, очевидно, ни одной итерации вложенного цикла выполнено не будет.
## <tex>i + d[j] - 1 > r</tex>, тогда каждая итерация вложенного цикла приведет к увеличению <tex>r</tex> хотя бы на <tex>1</tex>.

Т.к. значение <tex>r</tex> не может увеличиваться более <tex>n</tex> раз, то описанный выше алгоритм работает за время <tex>O(n)</tex>.

== См. также ==
* [[Префикс-функция]]
* [[Z — функция]]

== Источники информации ==
*[http://e-maxx.ru/algo/palindromes_count MAXimal :: algo :: Нахождение всех подпалиндромов]
* [[wikipedia:ru:Поиск_длиннейшей_подстроки-палиндрома| Википедия — Поиск длиннейшей подстроки-палиндрома]]
*[https://habrahabr.ru/post/276195/ Алгоритмы для поиска палиндромов — Хабр]

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

Алгоритм Манакера

2016-04-16T18:38:45Z

217.66.158.37: /* Идея */

Алгоритм Манакера

2016-04-16T18:29:38Z

217.66.158.37: /* Идея */