http://neerc.ifmo.ru/wiki/api.php?action=feedcontributions&feedformat=atom&user=EvarandВикиконспекты - Вклад участника [ru]2026-08-03T23:04:12ZВклад участникаMediaWiki 1.30.0http://neerc.ifmo.ru/wiki/index.php?title=%D0%A0%D0%B0%D0%B7%D1%80%D0%B5%D0%B7_%D0%B2_%D0%BF%D0%BB%D0%B0%D0%BD%D0%B0%D1%80%D0%BD%D1%8B%D1%85_%D0%B3%D1%80%D0%B0%D1%84%D0%B0%D1%85&diff=58932Разрез в планарных графах2017-01-06T15:27:08Z<p>Evarand: </p>
<hr />
<div>Особенности [[укладка графа на плоскости | планарных графов]] позволяют реализовать поиск [[разрез, лемма о потоке через разрез | минимального разреза]] в планарном графе с лучшей асимптотикой, чем в произвольном графе, где поиск минимального разреза требует поиска максимального потока, то есть работает за <math>O(V^2E)</math>. Лучший известный алгоритм для планарных графов работает с асимптотикой <math>O(V\log V)</math>.<br />
<br />
==Алгоритм за O(n^2 log n)==<br />
<br />
===Идея алгоритма===<br />
Рассмотрим граф <math>G^d</math>, [[двойственный граф планарного графа | двойственный]] данному графу <math>G</math>. Рассмотрим кратчайший путь <math>\Pi</math> между вершинами <math>\xi^s</math> и <math>\xi^t</math>, принадлежащими граням <math>\varphi_s</math> и <math>\varphi_t</math>, соответствующим вершинам <math>s</math> и <math>t</math> в исходном графе. Определим <math>\Pi</math>-левые и <math>\Pi</math>-правые ребра, <math>\Pi</math>-левые будут лежать "слева" по пути из <math>\xi^s</math> в <math>\xi^t</math>, а <math>\Pi</math>-правые "справа". Формальное определение будет дано в следующем разделе. Тогда минимальный цикл в <math>G^d</math>, ограничивающий <math>\varphi_t</math>, будет <math>\xi_i</math>-циклом {{---}} циклом, содержащим ровно одно <math>\Pi</math>-левое и одно <math>\Pi</math>-правое ребро, причем <math>\Pi</math>-левое ребро входит в вершину <math>\xi_i</math>. <br />
<br />
[[Файл:Xi_cycles.png|600px|thumb|center|Кси-циклы]]<br />
<br />
Каждый такой цикл соответствует разрезу в <math>G</math>. Тогда алгоритм можно записать так:<br />
# Построим граф <math>G^d</math>, двойственный исходному графу <math>G</math><br />
# Найдем кратчайший путь <math>\Pi</math> между вершинами <math>\xi^s</math> и <math>\xi^t</math><br />
# Для каждой вершины <math>\xi_i\in\Pi</math> найдем кратчайший <math>\xi_i</math>-цикл<br />
# Найдем среди этих циклов цикл минимальной длины и построим соответствующий ему разрез в <math>G</math><br />
<br />
===Корректность и асимптотика===<br />
Рассмотрим неориентированный граф <math>G=(V, E)</math>. Будем считать его трёхсвязным, если это не так, [[триангуляция полигонов (ушная + монотонная) | триангулируем]] его, используя ребра нулевой пропускной способности, это не изменит значение минимального <math>(s-t)-</math> разреза. Минимальный разрез исходного графа будет состоять из ребер минимального разреза нового графа, которые есть и в исходном графе.<br />
<br />
<math>G</math> трёхсвязен, поэтому существует единственный [[двойственный граф планарного графа | двойственный]] ему граф <math>G^d=(X, A)</math>, при этом <math>G^d</math> также трёхсвязен. Будем обозначать множество граней <math>G</math> как <math>F</math>, множество граней <math>G^d</math> как <math>\Phi</math>. Между элементами каждой из пар множеств <math>V-\Phi</math>, <math>E-A</math> и <math>F-X</math> существует взаимно однозначное соответствие. Будем обозначать как <math>\alpha^d\in E</math> элемент, соответствующий <math>\alpha\in A</math>. Тогда длину ребра <math>\alpha</math> определим как <math>l(\alpha)=c(\alpha^d)</math>.<br />
<br />
Будем обозначать грани <math>G^d</math>, соответствующие вершинам <math>s</math> и <math>t</math>, как <math>\varphi_s</math> и <math>\varphi_t</math> соответственно. Далее будем считать, что <math>\varphi_s</math> {{---}} внешняя грань <math>G^d</math>.<br />
<br />
{{Лемма<br />
|statement=<br />
<math>C</math> {{---}} минимальный <math>(s-t)-</math> разрез, тогда <math>C^d=\{\alpha \mid \alpha^d\in C\}</math> {{---}} цикл минимальной длины, ограничивающий <math>\varphi_t</math>.<br />
|proof=<br />
Формальное доказательство леммы громоздкое и здесь приведено не будет, однако сама лемма достаточно интуитивно понятна.<ref>"The following lemma is intuitive; however its formal proof is tedious, and therefore, omitted.", Maximum flow in planar networks, Itai & Shiloach, 1979, p. 147</ref> <br />
}}<br />
<br />
Пусть <math>\xi^s\in\varphi_s</math>, <math>\xi^t\in\varphi_t</math>, <math>\Pi=(\xi^s=\xi_1, \ldots, \xi_k=\xi^t)</math> {{---}} кратчайший путь между <math>\xi^s</math> и <math>\xi^t</math> в <math>G^d</math>, <math>\alpha_i</math> {{---}} ребро между <math>\xi_{i-1}</math> и <math>\xi_i</math> для <math>i=2,\ldots,k</math>. Будем называть ребро <math>\xi-\xi_i\in A</math> <math>\Pi</math>-левым, если оно находится между <math>\alpha_i</math> и <math>\alpha_{i+1}</math> при обходе ребер, входящих в <math>\xi_i</math>, по часовой стрелке от <math>\alpha_i</math>, и <math>\Pi</math>-правым, если оно находится между <math>\alpha_{i+1}</math> и <math>\alpha_i</math>.<br />
Для того, чтобы это определение имело смысл для первой и последней вершин пути, можно добавить две вершины <math>\xi_0</math> и <math>\xi_{k+1}</math> и два ребра <math>\alpha_1=\xi_0-\xi_1</math> и <math>\alpha_{k+1}=\xi_k-\xi_{k+1}</math>. Важно, что никакое ребро не является одновременно <math>\Pi</math>-левым и <math>\Pi</math>-правым.<br />
<br />
[[Файл:Виды_ребер.png|600px|thumb|center|П-левые и П-правые ребра]]<br />
<br />
Будем называть <math>\xi_i</math>-циклом простой цикл, который содержит ровно одно <math>\Pi</math>-левое и одно <math>\Pi</math>-правое ребро, при этом <math>\Pi</math>-левое ребро входит в вершину <math>\xi_i</math>. Любой <math>\xi_i</math>-цикл ограничивает <math>\varphi_t</math>.<br />
<br />
{{Лемма<br />
|statement=<br />
Пусть <math>C</math> {{---}} кратчайший ограничивающий <math>\varphi_t</math> цикл. Тогда существует <math>\xi_i</math>-цикл такой же длины.<br />
|proof=<br />
<math>\Pi</math> {{---}} кратчайший путь между <math>\xi^s</math> и <math>\xi^t</math>, поэтому любой содержащийся в <math>\Pi</math> путь между <math>\xi_i</math> и <math>\xi_j</math> также кратчайший. При этом любой ограничиващий <math>\varphi_t</math> цикл обязан пересекать <math>\Pi</math>. Цикл, не являющийся <math>\xi_i</math>-циклом, не будет кратчайшим, так как его можно будет сократить вдоль пути <math>\Pi</math>.<br />
}}<br />
<br />
Для поиска минимального <math>\xi_i</math>-цикла построим из неориентированного графа <math>G</math> ориентированный граф <math>\vec{G}^d</math> следующим образом: все <math>\Pi</math>-левые ребра ориентируем из вершин <math>\xi\in\Pi</math>, все <math>\Pi</math>-правые ребра ориентируем в вершины <math>\xi\in\Pi</math>, а остальные ребра <math>u\leftrightarrow v</math> заменим на два ребра <math>u\rightarrow v</math> и <math>v\rightarrow u</math>. <br />
<br />
{{Лемма<br />
|statement=<br />
Пусть <math>\xi_i\in\Pi</math>, <math>P_i</math> {{---}} кратчайший нетривиальный путь из <math>\xi_i</math> в <math>\xi_i</math> в <math>\vec{G}^d</math>. Тогда соответствующий путь в <math>G^d</math> является кратчайшим <math>\xi_i</math>-циклом.<br />
|proof=<br />
Из определения <math>\vec{G}^d</math> следует, что если нетривиальный путь из <math>\xi_i</math> в <math>\xi_i</math> содержит больше одного <math>\Pi</math>-правого или <math>\Pi</math>-левого ребра, то в нем есть самопересечение, то есть он не является простым, следовательно, не является кратчайшим <math>\xi_i</math>-циклом.<br />
}}<br />
<br />
Таким образом, нахождение минимального <math>\xi_i</math>-цикла эквивалентно нахождению кратчайшего нетривиального пути из <math>\xi_i</math> в <math>\xi_i</math> в <math>\vec{G}^d</math>. Это можно сделать за <math>O(m\log n)</math>, например, с помощью [[алгоритм Дейкстры | алгоритма Дейкстры]]. Так как в планарных графах <math>m=O(n)</math>, это равно <math>O(n\log n)</math>. Максимум <math>n</math> таких поисков дадут итоговую асимптотику <math>O(n^2\log n)</math>.<br />
<br />
==См. также==<br />
* [[Двойственный граф планарного графа]]<br />
* [[Разрез, лемма о потоке через разрез]]<br />
* [[Укладка графа на плоскости]]<br />
<br />
==Примечания==<br />
<references/><br />
<br />
==Источники информации==<br />
* [http://verona.dei.unipd.it/~prin08/primo_meeting/italiano.pdf Improved Algorithms for Min Cuts and Max Flows in Undirected Planar Graphs]<br />
* [https://pdfs.semanticscholar.org/b838/35db99723f922b7b286d10952b08c68970a7.pdf Maximum flow in planar networks, Itai & Shiloach, 1979]<br />
<br />
[[Категория: Алгоритмы и структуры данных]]<br />
[[Категория: Укладки графов]]</div>Evarandhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:Xi_cycles.png&diff=58931Файл:Xi cycles.png2017-01-06T15:21:37Z<p>Evarand: загружена новая версия «Файл:Xi cycles.png»</p>
<hr />
<div>Кси-циклы, алгоритм поиска разреза в планарном графе</div>Evarandhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:%D0%92%D0%B8%D0%B4%D1%8B_%D1%80%D0%B5%D0%B1%D0%B5%D1%80.png&diff=58930Файл:Виды ребер.png2017-01-06T15:19:45Z<p>Evarand: загружена новая версия «Файл:Виды ребер.png»</p>
<hr />
<div>П-левые и П-правые ребра, алгоритм поиска разреза в планарном графе</div>Evarandhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A0%D0%B0%D0%B7%D1%80%D0%B5%D0%B7_%D0%B2_%D0%BF%D0%BB%D0%B0%D0%BD%D0%B0%D1%80%D0%BD%D1%8B%D1%85_%D0%B3%D1%80%D0%B0%D1%84%D0%B0%D1%85&diff=58883Разрез в планарных графах2017-01-05T21:30:55Z<p>Evarand: /* Корректность и асимптотика */ minor</p>
<hr />
<div>Особенности [[укладка графа на плоскости | планарных графов]] позволяют реализовать поиск [[разрез, лемма о потоке через разрез | минимального разреза]] в планарном графе с лучшей асимптотикой, чем в произвольном графе, где поиск минимального разреза требует поиска максимального потока, то есть работает за <math>O(V^2E)</math>. Лучший известный алгоритм для планарных графов работает с асимптотикой <math>O(V\log V)</math>.<br />
<br />
==Алгоритм за <math>O(n^2 \log n)</math>==<br />
<br />
===Идея алгоритма===<br />
Рассмотрим граф <math>G^d</math>, [[двойственный граф планарного графа | двойственный]] данному графу <math>G</math>. Рассмотрим кратчайший путь <math>\Pi</math> между вершинами <math>\xi^s</math> и <math>\xi^t</math>, принадлежащими граням <math>\varphi_s</math> и <math>\varphi_t</math>, соответствующим вершинам <math>s</math> и <math>t</math> в исходном графе. Определим <math>\Pi</math>-левые и <math>\Pi</math>-правые ребра, <math>\Pi</math>-левые будут лежать "слева" по пути из <math>\xi^s</math> в <math>\xi^t</math>, а <math>\Pi</math>-правые "справа". Формальное определение будет дано в следующем разделе. Тогда минимальный цикл в <math>G^d</math>, ограничивающий <math>\varphi_t</math>, будет <math>\xi_i</math>-циклом {{---}} циклом, содержащим ровно одно <math>\Pi</math>-левое и одно <math>\Pi</math>-правое ребро, причем <math>\Pi</math>-левое ребро входит в вершину <math>\xi_i</math>. <br />
<br />
[[Файл:Xi_cycles.png|600px|thumb|center|Кси-циклы]]<br />
<br />
Каждый такой цикл соответствует разрезу в <math>G</math>. Тогда алгоритм можно записать так:<br />
# Построим граф <math>G^d</math>, двойственный исходному графу <math>G</math><br />
# Найдем кратчайший путь <math>\Pi</math> между вершинами <math>\xi^s</math> и <math>\xi^t</math><br />
# Для каждой вершины <math>\xi_i\in\Pi</math> найдем кратчайший <math>\xi_i</math>-цикл<br />
# Найдем среди этих циклов цикл минимальной длины и построим соответствующий ему разрез в <math>G</math><br />
<br />
===Корректность и асимптотика===<br />
Рассмотрим неориентированный граф <math>G=(V, E)</math>. Будем считать его трёхсвязным, если это не так, [[триангуляция полигонов (ушная + монотонная) | триангулируем]] его, используя ребра нулевой пропускной способности, это не изменит значение минимального <math>(s-t)-</math> разреза. Минимальный разрез исходного графа будет состоять из ребер минимального разреза нового графа, которые есть и в исходном графе.<br />
<br />
<math>G</math> трёхсвязен, поэтому существует единственный [[двойственный граф планарного графа | двойственный]] ему граф <math>G^d=(X, A)</math>, при этом <math>G^d</math> также трёхсвязен. Будем обозначать множество граней <math>G</math> как <math>F</math>, множество граней <math>G^d</math> как <math>\Phi</math>. Между элементами каждой из пар множеств <math>V-\Phi</math>, <math>E-A</math> и <math>F-X</math> существует взаимно однозначное соответствие. Будем обозначать как <math>\alpha^d\in E</math> элемент, соответствующий <math>\alpha\in A</math>. Тогда длину ребра <math>\alpha</math> определим как <math>l(\alpha)=c(\alpha^d)</math>.<br />
<br />
Будем обозначать грани <math>G^d</math>, соответствующие вершинам <math>s</math> и <math>t</math>, как <math>\varphi_s</math> и <math>\varphi_t</math> соответственно. Далее будем считать, что <math>\varphi_s</math> {{---}} внешняя грань <math>G^d</math>.<br />
<br />
{{Лемма<br />
|statement=<br />
<math>C</math> {{---}} минимальный <math>(s-t)-</math> разрез, тогда <math>C^d=\{\alpha \mid \alpha^d\in C\}</math> {{---}} цикл минимальной длины, ограничивающий <math>\varphi_t</math>. <br />
Формальное доказательство леммы громоздкое и здесь приведено не будет, однако сама лемма достаточно интуитивно понятна.<ref>"The following lemma is intuitive; however its formal proof is tedious, and therefore, omitted.", Maximum flow in planar networks, Itai & Shiloach, 1979, p. 147</ref><br />
}}<br />
<br />
Пусть <math>\xi^s\in\varphi_s</math>, <math>\xi^t\in\varphi_t</math>, <math>\Pi=(\xi^s=\xi_1, \ldots, \xi_k=\xi^t)</math> {{---}} кратчайший путь между <math>\xi^s</math> и <math>\xi^t</math> в <math>G^d</math>, <math>\alpha_i</math> {{---}} ребро между <math>\xi_{i-1}</math> и <math>\xi_i</math> для <math>i=2,\ldots,k</math>. Будем называть ребро <math>\xi-\xi_i\in A</math> <math>\Pi</math>-левым, если оно находится между <math>\alpha_i</math> и <math>\alpha_{i+1}</math> при обходе ребер, входящих в <math>\xi_i</math>, по часовой стрелке от <math>\alpha_i</math>, и <math>\Pi</math>-правым, если оно находится между <math>\alpha_{i+1}</math> и <math>\alpha_i</math>.<br />
Для того, чтобы это определение имело смысл для первой и последней вершин пути, можно добавить две вершины <math>\xi_0</math> и <math>\xi_{k+1}</math> и два ребра <math>\alpha_1=\xi_0-\xi_1</math> и <math>\alpha_{k+1}=\xi_k-\xi_{k+1}</math>. Важно, что никакое ребро не является одновременно <math>\Pi</math>-левым и <math>\Pi</math>-правым.<br />
<br />
[[Файл:Виды_ребер.png|600px|thumb|center|П-левые и П-правые ребра]]<br />
<br />
Будем называть <math>\xi_i</math>-циклом простой цикл, который содержит ровно одно <math>\Pi</math>-левое и одно <math>\Pi</math>-правое ребро, при этом <math>\Pi</math>-левое ребро входит в вершину <math>\xi_i</math>. Любой <math>\xi_i</math>-цикл ограничивает <math>\varphi_t</math>.<br />
<br />
{{Лемма<br />
|statement=<br />
Пусть <math>C</math> {{---}} кратчайший ограничивающий <math>\varphi_t</math> цикл. Тогда существует <math>\xi_i</math>-цикл такой же длины.<br />
|proof=<br />
<math>\Pi</math> {{---}} кратчайший путь между <math>\xi^s</math> и <math>\xi^t</math>, поэтому любой содержащийся в <math>\Pi</math> путь между <math>\xi_i</math> и <math>\xi_j</math> также кратчайший. При этом любой ограничиващий <math>\varphi_t</math> цикл обязан пересекать <math>\Pi</math>. Цикл, не являющийся <math>\xi_i</math>-циклом, не будет кратчайшим, так как его можно будет сократить вдоль пути <math>\Pi</math>.<br />
}}<br />
<br />
Для поиска минимального <math>\xi_i</math>-цикла построим из неориентированного графа <math>G</math> ориентированный граф <math>\vec{G}^d</math> следующим образом: все <math>\Pi</math>-левые ребра ориентируем из вершин <math>\xi\in\Pi</math>, все <math>\Pi</math>-правые ребра ориентируем в вершины <math>\xi\in\Pi</math>, а остальные ребра <math>u\leftrightarrow v</math> заменим на два ребра <math>u\rightarrow v</math> и <math>v\rightarrow u</math>. <br />
<br />
{{Лемма<br />
|statement=<br />
Пусть <math>\xi_i\in\Pi</math>, <math>P_i</math> {{---}} кратчайший нетривиальный путь из <math>\xi_i</math> в <math>\xi_i</math> в <math>\vec{G}^d</math>. Тогда соответствующий путь в <math>G^d</math> является кратчайшим <math>\xi_i</math>-циклом.<br />
|proof=<br />
Из определения <math>\vec{G}^d</math> следует, что если нетривиальный путь из <math>\xi_i</math> в <math>\xi_i</math> содержит больше одного <math>\Pi</math>-правого или <math>\Pi</math>-левого ребра, то в нем есть самопересечение, то есть он не является простым, следовательно, не является кратчайшим <math>\xi_i</math>-циклом.<br />
}}<br />
<br />
Таким образом, нахождение минимального <math>\xi_i</math>-цикла эквивалентно нахождению кратчайшего нетривиального пути из <math>\xi_i</math> в <math>\xi_i</math> в <math>\vec{G}^d</math>. Это можно сделать за <math>O(m\log n)</math>, например, с помощью [[алгоритм Дейкстры | алгоритма Дейкстры]]. Так как в планарных графах <math>m=O(n)</math>, это равно <math>O(n\log n)</math>. Максимум <math>n</math> таких поисков дадут итоговую асимптотику <math>O(n^2\log n)</math>.<br />
<br />
==См. также==<br />
* [[Двойственный граф планарного графа]]<br />
* [[Разрез, лемма о потоке через разрез]]<br />
* [[Укладка графа на плоскости]]<br />
<br />
==Примечания==<br />
<references/><br />
<br />
==Источники информации==<br />
* [http://verona.dei.unipd.it/~prin08/primo_meeting/italiano.pdf Improved Algorithms for Min Cuts and Max Flows in Undirected Planar Graphs]<br />
* [https://pdfs.semanticscholar.org/b838/35db99723f922b7b286d10952b08c68970a7.pdf Maximum flow in planar networks, Itai & Shiloach, 1979]<br />
<br />
[[Категория: Алгоритмы и структуры данных]]<br />
[[Категория: Укладки графов]]</div>Evarandhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A0%D0%B0%D0%B7%D1%80%D0%B5%D0%B7_%D0%B2_%D0%BF%D0%BB%D0%B0%D0%BD%D0%B0%D1%80%D0%BD%D1%8B%D1%85_%D0%B3%D1%80%D0%B0%D1%84%D0%B0%D1%85&diff=58882Разрез в планарных графах2017-01-05T21:28:46Z<p>Evarand: /* Идея алгоритма */ minor</p>
<hr />
<div>Особенности [[укладка графа на плоскости | планарных графов]] позволяют реализовать поиск [[разрез, лемма о потоке через разрез | минимального разреза]] в планарном графе с лучшей асимптотикой, чем в произвольном графе, где поиск минимального разреза требует поиска максимального потока, то есть работает за <math>O(V^2E)</math>. Лучший известный алгоритм для планарных графов работает с асимптотикой <math>O(V\log V)</math>.<br />
<br />
==Алгоритм за <math>O(n^2 \log n)</math>==<br />
<br />
===Идея алгоритма===<br />
Рассмотрим граф <math>G^d</math>, [[двойственный граф планарного графа | двойственный]] данному графу <math>G</math>. Рассмотрим кратчайший путь <math>\Pi</math> между вершинами <math>\xi^s</math> и <math>\xi^t</math>, принадлежащими граням <math>\varphi_s</math> и <math>\varphi_t</math>, соответствующим вершинам <math>s</math> и <math>t</math> в исходном графе. Определим <math>\Pi</math>-левые и <math>\Pi</math>-правые ребра, <math>\Pi</math>-левые будут лежать "слева" по пути из <math>\xi^s</math> в <math>\xi^t</math>, а <math>\Pi</math>-правые "справа". Формальное определение будет дано в следующем разделе. Тогда минимальный цикл в <math>G^d</math>, ограничивающий <math>\varphi_t</math>, будет <math>\xi_i</math>-циклом {{---}} циклом, содержащим ровно одно <math>\Pi</math>-левое и одно <math>\Pi</math>-правое ребро, причем <math>\Pi</math>-левое ребро входит в вершину <math>\xi_i</math>. <br />
<br />
[[Файл:Xi_cycles.png|600px|thumb|center|Кси-циклы]]<br />
<br />
Каждый такой цикл соответствует разрезу в <math>G</math>. Тогда алгоритм можно записать так:<br />
# Построим граф <math>G^d</math>, двойственный исходному графу <math>G</math><br />
# Найдем кратчайший путь <math>\Pi</math> между вершинами <math>\xi^s</math> и <math>\xi^t</math><br />
# Для каждой вершины <math>\xi_i\in\Pi</math> найдем кратчайший <math>\xi_i</math>-цикл<br />
# Найдем среди этих циклов цикл минимальной длины и построим соответствующий ему разрез в <math>G</math><br />
<br />
===Корректность и асимптотика===<br />
Рассмотрим неориентированный граф <math>G=(V, E)</math>. Будем считать его трёхсвязным, если это не так, [[триангуляция полигонов (ушная + монотонная) | триангулируем]] его, используя ребра нулевой пропускной способности, это не изменит значение минимального <math>(s-t)-</math> разреза. Минимальный разрез исходного графа будет состоять из ребер минимального разреза нового графа, которые есть и в исходном графе.<br />
<br />
<math>G</math> трёхсвязен, поэтому существует единственный [[двойственный граф планарного графа | двойственный]] ему граф <math>G^d=(X, A)</math>, при этом <math>G^d</math> также трёхсвязен. Будем обозначать множество граней <math>G</math> как <math>F</math>, множество граней <math>G^d</math> как <math>\Phi</math>. Между элементами каждой из пар множеств <math>V-\Phi</math>, <math>E-A</math> и <math>F-X</math> существует взаимно однозначное соответствие. Будем обозначать как <math>\alpha^d\in E</math> элемент, соответствующий <math>\alpha\in A</math>. Тогда длину ребра <math>\alpha</math> определим как <math>l(\alpha)=c(\alpha^d)</math>.<br />
<br />
Будем обозначать грани <math>G^d</math>, соответствующие вершинам <math>s</math> и <math>t</math>, как <math>\varphi_s</math> и <math>\varphi_t</math> соответственно. Далее будем считать, что <math>\varphi_s</math> {{---}} внешняя грань <math>G^d</math>.<br />
<br />
{{Лемма<br />
|statement=<br />
<math>C</math> {{---}} минимальный <math>(s-t)-</math> разрез, тогда <math>C^d=\{\alpha \mid \alpha^d\in C\}</math> {{---}} цикл минимальной длины, ограничивающий <math>\varphi_t</math>. <br />
Формальное доказательство леммы громоздкое и здесь приведено не будет, однако сама лемма достаточно интуитивно понятна.<ref>"The following lemma is intuitive; however its formal proof is tedious, and therefore, omitted.", Maximum flow in planar networks, Itai & Shiloach, 1979</ref><br />
}}<br />
<br />
Пусть <math>\xi^s\in\varphi_s</math>, <math>\xi^t\in\varphi_t</math>, <math>\Pi=(\xi^s=\xi_1, \ldots, \xi_k=\xi^t)</math> {{---}} кратчайший путь между <math>\xi^s</math> и <math>\xi^t</math> в <math>G^d</math>, <math>\alpha_i</math> {{---}} ребро между <math>\xi_{i-1}</math> и <math>\xi_i</math> для <math>i=2,\ldots,k</math>. Будем называть ребро <math>\xi-\xi_i\in A</math> <math>\Pi</math>-левым, если оно находится между <math>\alpha_i</math> и <math>\alpha_{i+1}</math> при обходе ребер, входящих в <math>\xi_i</math>, по часовой стрелке от <math>\alpha_i</math>, и <math>\Pi</math>-правым, если оно находится между <math>\alpha_{i+1}</math> и <math>\alpha_i</math>.<br />
Для того, чтобы это определение имело смысл для первой и последней вершин пути, можно добавить две вершины <math>\xi_0</math> и <math>\xi_{k+1}</math> и два ребра <math>\alpha_1=\xi_0-\xi_1</math> и <math>\alpha_{k+1}=\xi_k-\xi_{k+1}</math>. Важно, что никакое ребро не является одновременно <math>\Pi</math>-левым и <math>\Pi</math>-правым.<br />
<br />
[[Файл:Виды_ребер.png|600px|thumb|center|П-левые и П-правые ребра]]<br />
<br />
Будем называть <math>\xi_i</math>-циклом простой цикл, который содержит ровно одно <math>\Pi</math>-левое и одно <math>\Pi</math>-правое ребро, при этом <math>\Pi</math>-левое ребро входит в вершину <math>\xi_i</math>. Любой <math>\xi_i</math>-цикл ограничивает <math>\varphi_t</math>.<br />
<br />
{{Лемма<br />
|statement=<br />
Пусть <math>C</math> {{---}} кратчайший ограничивающий <math>\varphi_t</math> цикл. Тогда существует <math>\xi_i</math>-цикл такой же длины.<br />
|proof=<br />
<math>\Pi</math> {{---}} кратчайший путь между <math>\xi^s</math> и <math>\xi^t</math>, поэтому любой содержащийся в <math>\Pi</math> путь между <math>\xi_i</math> и <math>\xi_j</math> также кратчайший. При этом любой ограничиващий <math>\varphi_t</math> цикл обязан пересекать <math>\Pi</math>. Цикл, не являющийся <math>\xi_i</math>-циклом, не будет кратчайшим, так как его можно будет сократить вдоль пути <math>\Pi</math>.<br />
}}<br />
<br />
Для поиска минимального <math>\xi_i</math>-цикла построим из неориентированного графа <math>G</math> ориентированный граф <math>\vec{G}^d</math> следующим образом: все <math>\Pi</math>-левые ребра ориентируем из вершин <math>\xi\in\Pi</math>, все <math>\Pi</math>-правые ребра ориентируем в вершины <math>\xi\in\Pi</math>, а остальные ребра <math>u\leftrightarrow v</math> заменим на два ребра <math>u\rightarrow v</math> и <math>v\rightarrow u</math>. <br />
<br />
{{Лемма<br />
|statement=<br />
Пусть <math>\xi_i\in\Pi</math>, <math>P_i</math> {{---}} кратчайший нетривиальный путь из <math>\xi_i</math> в <math>\xi_i</math> в <math>\vec{G}^d</math>. Тогда соответствующий путь в <math>G^d</math> является кратчайшим <math>\xi_i</math>-циклом.<br />
|proof=<br />
Из определения <math>\vec{G}^d</math> следует, что если нетривиальный путь из <math>\xi_i</math> в <math>\xi_i</math> содержит больше одного <math>\Pi</math>-правого или <math>\Pi</math>-левого ребра, то в нем есть самопересечение, то есть он не является простым, следовательно, не является кратчайшим <math>\xi_i</math>-циклом.<br />
}}<br />
<br />
Таким образом, нахождение минимального <math>\xi_i</math>-цикла эквивалентно нахождению кратчайшего нетривиального пути из <math>\xi_i</math> в <math>\xi_i</math> в <math>\vec{G}^d</math>. Это можно сделать за <math>O(m\log n)</math>, например, с помощью [[алгоритм Дейкстры | алгоритма Дейкстры]]. Так как в планарных графах <math>m=O(n)</math>, это равно <math>O(n\log n)</math>. Максимум <math>n</math> таких поисков дадут итоговую асимптотику <math>O(n^2\log n)</math>.<br />
<br />
==См. также==<br />
* [[Двойственный граф планарного графа]]<br />
* [[Разрез, лемма о потоке через разрез]]<br />
* [[Укладка графа на плоскости]]<br />
<br />
==Примечания==<br />
<references/><br />
<br />
==Источники информации==<br />
* [http://verona.dei.unipd.it/~prin08/primo_meeting/italiano.pdf Improved Algorithms for Min Cuts and Max Flows in Undirected Planar Graphs]<br />
* [https://pdfs.semanticscholar.org/b838/35db99723f922b7b286d10952b08c68970a7.pdf Maximum flow in planar networks, Itai & Shiloach, 1979]<br />
<br />
[[Категория: Алгоритмы и структуры данных]]<br />
[[Категория: Укладки графов]]</div>Evarandhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A0%D0%B0%D0%B7%D1%80%D0%B5%D0%B7_%D0%B2_%D0%BF%D0%BB%D0%B0%D0%BD%D0%B0%D1%80%D0%BD%D1%8B%D1%85_%D0%B3%D1%80%D0%B0%D1%84%D0%B0%D1%85&diff=58881Разрез в планарных графах2017-01-05T21:26:17Z<p>Evarand: рефакторинг</p>
<hr />
<div>Особенности [[укладка графа на плоскости | планарных графов]] позволяют реализовать поиск [[разрез, лемма о потоке через разрез | минимального разреза]] в планарном графе с лучшей асимптотикой, чем в произвольном графе, где поиск минимального разреза требует поиска максимального потока, то есть работает за <math>O(V^2E)</math>. Лучший известный алгоритм для планарных графов работает с асимптотикой <math>O(V\log V)</math>.<br />
<br />
==Алгоритм за <math>O(n^2 \log n)</math>==<br />
<br />
===Идея алгоритма===<br />
Рассмотрим граф <math>G^d</math>, [[двойственный граф планарного графа | двойственный]] данному графу <math>G</math>. Рассмотрим кратчайший путь <math>\Pi</math> между вершинами <math>\xi^s</math> и <math>\xi^t</math>, принадлежащими граням <math>\varphi_s</math> и <math>\varphi_t</math>, соответствующим вершинам <math>s</math> и <math>t</math> в исходном графе. Определим <math>\Pi</math>-левые и <math>\Pi</math>-правые ребра, <math>\Pi</math>-левые будут лежать "слева" по пути из <math>\xi^s</math> в <math>\xi^t</math>, а <math>\Pi</math>-"правые" справа. Формальное определение будет дано в следующем разделе. Тогда минимальный цикл в <math>G^d</math>, ограничивающий <math>\varphi_t</math>, будет <math>\xi_i</math>-циклом {{---}} циклом, содержащим ровно одно <math>\Pi</math>-левое и одно <math>\Pi</math>-правое ребро, причем <math>\Pi</math>-левое ребро входит в вершину <math>\xi_i</math>. <br />
<br />
[[Файл:Xi_cycles.png|600px|thumb|center|Кси-циклы]]<br />
<br />
Каждый такой цикл соответствует разрезу в <math>G</math>. Тогда алгоритм можно записать так:<br />
# Построим граф <math>G^d</math>, двойственный исходному графу <math>G</math><br />
# Найдем кратчайший путь <math>\Pi</math> между вершинами <math>\xi^s</math> и <math>\xi^t</math><br />
# Для каждой вершины <math>\xi_i\in\Pi</math> найдем кратчайший <math>\xi_i</math>-цикл<br />
# Найдем среди этих циклов цикл минимальной длины и построим соответствующий ему разрез в <math>G</math><br />
<br />
===Корректность и асимптотика===<br />
Рассмотрим неориентированный граф <math>G=(V, E)</math>. Будем считать его трёхсвязным, если это не так, [[триангуляция полигонов (ушная + монотонная) | триангулируем]] его, используя ребра нулевой пропускной способности, это не изменит значение минимального <math>(s-t)-</math> разреза. Минимальный разрез исходного графа будет состоять из ребер минимального разреза нового графа, которые есть и в исходном графе.<br />
<br />
<math>G</math> трёхсвязен, поэтому существует единственный [[двойственный граф планарного графа | двойственный]] ему граф <math>G^d=(X, A)</math>, при этом <math>G^d</math> также трёхсвязен. Будем обозначать множество граней <math>G</math> как <math>F</math>, множество граней <math>G^d</math> как <math>\Phi</math>. Между элементами каждой из пар множеств <math>V-\Phi</math>, <math>E-A</math> и <math>F-X</math> существует взаимно однозначное соответствие. Будем обозначать как <math>\alpha^d\in E</math> элемент, соответствующий <math>\alpha\in A</math>. Тогда длину ребра <math>\alpha</math> определим как <math>l(\alpha)=c(\alpha^d)</math>.<br />
<br />
Будем обозначать грани <math>G^d</math>, соответствующие вершинам <math>s</math> и <math>t</math>, как <math>\varphi_s</math> и <math>\varphi_t</math> соответственно. Далее будем считать, что <math>\varphi_s</math> {{---}} внешняя грань <math>G^d</math>.<br />
<br />
{{Лемма<br />
|statement=<br />
<math>C</math> {{---}} минимальный <math>(s-t)-</math> разрез, тогда <math>C^d=\{\alpha \mid \alpha^d\in C\}</math> {{---}} цикл минимальной длины, ограничивающий <math>\varphi_t</math>. <br />
Формальное доказательство леммы громоздкое и здесь приведено не будет, однако сама лемма достаточно интуитивно понятна.<ref>"The following lemma is intuitive; however its formal proof is tedious, and therefore, omitted.", Maximum flow in planar networks, Itai & Shiloach, 1979</ref><br />
}}<br />
<br />
Пусть <math>\xi^s\in\varphi_s</math>, <math>\xi^t\in\varphi_t</math>, <math>\Pi=(\xi^s=\xi_1, \ldots, \xi_k=\xi^t)</math> {{---}} кратчайший путь между <math>\xi^s</math> и <math>\xi^t</math> в <math>G^d</math>, <math>\alpha_i</math> {{---}} ребро между <math>\xi_{i-1}</math> и <math>\xi_i</math> для <math>i=2,\ldots,k</math>. Будем называть ребро <math>\xi-\xi_i\in A</math> <math>\Pi</math>-левым, если оно находится между <math>\alpha_i</math> и <math>\alpha_{i+1}</math> при обходе ребер, входящих в <math>\xi_i</math>, по часовой стрелке от <math>\alpha_i</math>, и <math>\Pi</math>-правым, если оно находится между <math>\alpha_{i+1}</math> и <math>\alpha_i</math>.<br />
Для того, чтобы это определение имело смысл для первой и последней вершин пути, можно добавить две вершины <math>\xi_0</math> и <math>\xi_{k+1}</math> и два ребра <math>\alpha_1=\xi_0-\xi_1</math> и <math>\alpha_{k+1}=\xi_k-\xi_{k+1}</math>. Важно, что никакое ребро не является одновременно <math>\Pi</math>-левым и <math>\Pi</math>-правым.<br />
<br />
[[Файл:Виды_ребер.png|600px|thumb|center|П-левые и П-правые ребра]]<br />
<br />
Будем называть <math>\xi_i</math>-циклом простой цикл, который содержит ровно одно <math>\Pi</math>-левое и одно <math>\Pi</math>-правое ребро, при этом <math>\Pi</math>-левое ребро входит в вершину <math>\xi_i</math>. Любой <math>\xi_i</math>-цикл ограничивает <math>\varphi_t</math>.<br />
<br />
{{Лемма<br />
|statement=<br />
Пусть <math>C</math> {{---}} кратчайший ограничивающий <math>\varphi_t</math> цикл. Тогда существует <math>\xi_i</math>-цикл такой же длины.<br />
|proof=<br />
<math>\Pi</math> {{---}} кратчайший путь между <math>\xi^s</math> и <math>\xi^t</math>, поэтому любой содержащийся в <math>\Pi</math> путь между <math>\xi_i</math> и <math>\xi_j</math> также кратчайший. При этом любой ограничиващий <math>\varphi_t</math> цикл обязан пересекать <math>\Pi</math>. Цикл, не являющийся <math>\xi_i</math>-циклом, не будет кратчайшим, так как его можно будет сократить вдоль пути <math>\Pi</math>.<br />
}}<br />
<br />
Для поиска минимального <math>\xi_i</math>-цикла построим из неориентированного графа <math>G</math> ориентированный граф <math>\vec{G}^d</math> следующим образом: все <math>\Pi</math>-левые ребра ориентируем из вершин <math>\xi\in\Pi</math>, все <math>\Pi</math>-правые ребра ориентируем в вершины <math>\xi\in\Pi</math>, а остальные ребра <math>u\leftrightarrow v</math> заменим на два ребра <math>u\rightarrow v</math> и <math>v\rightarrow u</math>. <br />
<br />
{{Лемма<br />
|statement=<br />
Пусть <math>\xi_i\in\Pi</math>, <math>P_i</math> {{---}} кратчайший нетривиальный путь из <math>\xi_i</math> в <math>\xi_i</math> в <math>\vec{G}^d</math>. Тогда соответствующий путь в <math>G^d</math> является кратчайшим <math>\xi_i</math>-циклом.<br />
|proof=<br />
Из определения <math>\vec{G}^d</math> следует, что если нетривиальный путь из <math>\xi_i</math> в <math>\xi_i</math> содержит больше одного <math>\Pi</math>-правого или <math>\Pi</math>-левого ребра, то в нем есть самопересечение, то есть он не является простым, следовательно, не является кратчайшим <math>\xi_i</math>-циклом.<br />
}}<br />
<br />
Таким образом, нахождение минимального <math>\xi_i</math>-цикла эквивалентно нахождению кратчайшего нетривиального пути из <math>\xi_i</math> в <math>\xi_i</math> в <math>\vec{G}^d</math>. Это можно сделать за <math>O(m\log n)</math>, например, с помощью [[алгоритм Дейкстры | алгоритма Дейкстры]]. Так как в планарных графах <math>m=O(n)</math>, это равно <math>O(n\log n)</math>. Максимум <math>n</math> таких поисков дадут итоговую асимптотику <math>O(n^2\log n)</math>.<br />
<br />
==См. также==<br />
* [[Двойственный граф планарного графа]]<br />
* [[Разрез, лемма о потоке через разрез]]<br />
* [[Укладка графа на плоскости]]<br />
<br />
==Примечания==<br />
<references/><br />
<br />
==Источники информации==<br />
* [http://verona.dei.unipd.it/~prin08/primo_meeting/italiano.pdf Improved Algorithms for Min Cuts and Max Flows in Undirected Planar Graphs]<br />
* [https://pdfs.semanticscholar.org/b838/35db99723f922b7b286d10952b08c68970a7.pdf Maximum flow in planar networks, Itai & Shiloach, 1979]<br />
<br />
[[Категория: Алгоритмы и структуры данных]]<br />
[[Категория: Укладки графов]]</div>Evarandhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:Xi_cycles.png&diff=58862Файл:Xi cycles.png2017-01-05T20:25:10Z<p>Evarand: Кси-циклы, алгоритм поиска разреза в планарном графе</p>
<hr />
<div>Кси-циклы, алгоритм поиска разреза в планарном графе</div>Evarandhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:%D0%92%D0%B8%D0%B4%D1%8B_%D1%80%D0%B5%D0%B1%D0%B5%D1%80.png&diff=58861Файл:Виды ребер.png2017-01-05T20:16:26Z<p>Evarand: П-левые и П-правые ребра, алгоритм поиска разреза в планарном графе</p>
<hr />
<div>П-левые и П-правые ребра, алгоритм поиска разреза в планарном графе</div>Evarandhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%94%D0%B8%D1%81%D0%BA%D1%80%D0%B5%D1%82%D0%BD%D0%B0%D1%8F_%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0,_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D1%8B_%D0%B8_%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D1%8B_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85&diff=58857Дискретная математика, алгоритмы и структуры данных2017-01-05T20:02:30Z<p>Evarand: /* Укладки графов */ добавлен алгоритм поиска разреза</p>
<hr />
<div>[[Категория:Дискретная математика и алгоритмы]]<br />
[[Категория: Алгоритмы и структуры данных]]<br />
Убедительная просьба читать [[Обсуждение:Дискретная_математика_и_алгоритмы | правила оформления вики-конспектов]].<br />
<br />
Символом <tex> \star </tex> помечены дополнительные темы (возможно, сложные), которые не были подробно рассмотрены (или вообще рассмотрены) в рамках курса.<br />
<br />
= Первый семестр =<br />
<br />
== Отношения ==<br />
*[[Определение отношения]]<br />
*[[Композиция отношений|Композиция отношений, степень отношения, обратное отношение]]<br />
*[[Рефлексивное отношение|Рефлексивное отношение. Антирефлексивное отношение.]]<br />
*[[Симметричное отношение]]<br />
*[[Антисимметричное отношение]]<br />
*[[Транзитивное отношение]]<br />
*[[Отношение порядка]]<br />
*[[Изоморфизмы упорядоченных множеств]]<tex>^\star</tex><br />
*[[Отношение эквивалентности]]<br />
*[[Транзитивное замыкание|Транзитивное замыкание отношения]]<br />
*[[Алгоритм Флойда — Уоршелла|Алгоритм Флойда-Уоршалла построения транзитивного замыкания отношения]]<br />
*[[Транзитивный остов]]<br />
<br />
== Булевы функции ==<br />
*[[Определение булевой функции]]<br />
*[[Побитовые операции]]<tex>^\star</tex><br />
*[[Суперпозиции]]<br />
*[[ДНФ]]<br />
*[[Сокращенная и минимальная ДНФ | Сокращенная и минимальная ДНФ, минимизация ДНФ методами гиперкубов, карт Карно, Квайна]]<br />
*[[КНФ]]<br />
*[[2-SAT]]<br />
*[[XOR-SAT]]<tex>^\star</tex><br />
*[[Специальные формы КНФ|Специальные формы КНФ: КНФ в форме Хорна и КНФ в форме Крома]]<br />
*[[Полином Жегалкина | Полином Жегалкина, преобразование Мёбиуса]]<br />
*[[Полные системы функций. Теорема Поста о полной системе функций]]<br />
*[[Представление функции класса DM с помощью медианы]]<br />
*[[Пороговая функция]]<br />
*[[Троичная логика]]<tex>^\star</tex><br />
<br />
== Схемы из функциональных элементов ==<br />
*[[Реализация булевой функции схемой из функциональных элементов]]<br />
*[[Простейшие методы синтеза схем из функциональных элементов]]<br />
*[[Метод Лупанова синтеза схем]]<br />
*[[Cумматор]]<br />
*[[Каскадный сумматор]]<br />
*[[Двоичный каскадный сумматор]]<br />
*[[Троичный сумматор]]<tex>^\star</tex><br />
*[[Реализация вычитания сумматором]]<br />
*[[Матричный умножитель]]<br />
*[[Дерево Уоллеса]]<br />
*[[Контактная схема]]<br />
*[[Триггеры]]<tex>^\star</tex><br />
*[[Квантовые гейты]]<tex>^\star</tex><br />
<br />
== Представление информации ==<br />
*[[Кодирование информации]]<br />
*[[Представление целых чисел: прямой код, код со сдвигом, дополнительный код]]<br />
*[[Представление вещественных чисел]]<br />
*[[Представление символов, таблицы кодировок]]<tex>^\star</tex><br />
<br />
== Алгоритмы сжатия ==<br />
* [[Алгоритм Хаффмана]]<br />
* [[Оптимальное хранение словаря в алгоритме Хаффмана]]<br />
* [[Алгоритм Хаффмана за O(n)]]<br />
* [[Алгоритм Ху-Таккера]]<tex>^\star</tex><br />
* [[Неравенство Крафта]]<br />
* [[Неравенство Макмиллана]]<br />
* [[Код Шеннона]]<br />
* [[Оптимальный префиксный код с длиной кодового слова не более L бит]]<tex>^\star</tex><br />
* [[Алгоритмы LZ77 и LZ78]]<br />
* [[Алгоритм LZW]]<br />
* [[Алгоритм LZSS]]<tex>^\star</tex><br />
* [[Алгоритм LZMA]]<tex>^\star</tex><br />
* [[Преобразование Барроуза-Уиллера | Преобразование Барроуза-Уиллера и обратное ему]]<br />
* [[Преобразование MTF]]<br />
* [[Расстояние Хэмминга]]<br />
* [[Избыточное кодирование, код Хэмминга]]<br />
* [[Гамма-, дельта- и омега-код Элиаса]]<tex>^\star</tex><br />
<br />
== Комбинаторика ==<br />
=== Комбинаторные объекты ===<br />
* [[Комбинаторные объекты]]<br />
* [[Лексикографический порядок]]<br />
* [[Коды Грея]]<br />
* [[Коды Грея для перестановок]]<br />
* [[Коды антигрея]]<br />
* [[Монотонный код Грея]]<br />
* [[Цепные коды]]<br />
* [[Правильные скобочные последовательности]]<br />
<br />
=== Генерация комбинаторных объектов ===<br />
* [[Генерация комбинаторных объектов в лексикографическом порядке]]<br />
* [[Получение номера по объекту]]<br />
* [[Получение объекта по номеру]]<br />
* [[Получение следующего объекта]]<br />
* [[Получение предыдущего объекта]]<tex>^\star</tex> <br />
* [[Метод генерации случайной перестановки, алгоритм Фишера-Йетса]]<br />
* [[Методы генерации случайного сочетания]]<tex>^\star</tex><br />
<br />
=== Подсчёт числа объектов ===<br />
* [[Формула включения-исключения | Формула включения-исключения, подсчет числа беспорядков]]<br />
* [[Нахождение количества разбиений числа на слагаемые | Нахождение количества разбиений числа на слагаемые. Пентагональная теорема Эйлера]]<br />
* [[Производящая функция]]<br />
* [[Лемма Бёрнсайда и Теорема Пойа]]<br />
* [[Задача об ожерельях]]<br />
* [[Числа Стирлинга первого рода]]<br />
* [[Числа Стирлинга второго рода]]<br />
* [[Числа Эйлера I и II рода | Числа Эйлера первого и второго рода. Подъемы в перестановках]]<tex>^\star</tex><br />
* [[Числа Каталана]]<br />
<br />
=== Свойства комбинаторных объектов ===<br />
* [[Умножение перестановок, обратная перестановка, группа перестановок]]<br />
* [[Действие перестановки на набор из элементов, представление в виде циклов]]<br />
* [[Таблица инверсий]]<br />
* [[Теорема Кэли]]<br />
* [[Матричное представление перестановок]]<br />
* [[Задача о минимуме/максимуме скалярного произведения]]<br />
* [[Задача о монотонных подпоследовательностях, теорема о связи длины НВП и НУП]]<br />
<br />
== [[Динамическое программирование]] ==<br />
=== Классические задачи динамического программирования ===<br />
*[[Кратчайший путь в ациклическом графе]]<br />
*[[Задача о числе путей в ациклическом графе]]<br />
*[[Задача о расстановке знаков в выражении]]<br />
*[[Задача о порядке перемножения матриц]]<br />
*[[Задача о наибольшей общей подпоследовательности]]<br />
*[[Задача о наибольшей возрастающей подпоследовательности]]<br />
*[[Задача коммивояжера, ДП по подмножествам]]<br />
*[[Задача о редакционном расстоянии, алгоритм Вагнера-Фишера]]<br />
*[[Задача о рюкзаке]]<br />
<br />
=== Способы оптимизации методов динамического программирования ===<br />
*[[Метод четырех русских для умножения матриц]]<br />
*[[Применение метода четырех русских в задачах ДП на примере задачи о НОП]]<tex>^\star</tex><br />
*[[Задача об оптимальном префиксном коде с сохранением порядка. Монотонность точки разреза]]<br />
*[[Meet-in-the-middle]]<tex>^\star</tex><br />
<br />
=== Другие задачи ===<br />
*[[Задача о расстоянии Дамерау-Левенштейна]]<tex>^\star</tex><br />
*[[Задача о выводе в контекстно-свободной грамматике, алгоритм Кока-Янгера-Касами]]<br />
*[[Задача о наибольшей подпоследовательности-палиндроме]]<br />
*[[Наибольшая общая возрастающая подпоследовательность]]<tex>^\star</tex><br />
*[[Задача о наибольшей общей палиндромной подпоследовательности]]<tex>^\star</tex><br />
*[[Динамическое программирование по профилю]]<tex>^\star</tex><br />
*[[Динамика по поддеревьям]]<br />
<br />
== Теория вероятностей ==<br />
*[[Вероятностное пространство, элементарный исход, событие]]<br />
*[[Независимые события]]<br />
*[[Условная вероятность]]<br />
*[[Формула полной вероятности]]<br />
*[[Формула Байеса]]<br />
*[[Дискретная случайная величина]]<br />
*[[Независимые случайные величины]]<br />
*[[Математическое ожидание случайной величины]]<br />
*[[Дисперсия случайной величины]]<br />
*[[Ковариация случайных величин]]<br />
*[[Корреляция случайных величин]]<br />
*[[Неравенство Маркова]]<br />
*[[Энтропия случайного источника]]<br />
*[[Симуляция одним распределением другого]]<br />
*[[Арифметическое кодирование]]<br />
*[[Парадоксы теории вероятностей]]<tex>^\star</tex><br />
*[[Схема Бернулли]]<tex>^\star</tex><br />
<br />
== Марковские цепи ==<br />
<br />
* [[Марковская цепь]]<br />
* [[Теорема о поглощении]]<br />
* [[Фундаментальная матрица]]<br />
* [[Математическое ожидание времени поглощения]]<br />
* [[Расчет вероятности поглощения в состоянии]]<br />
* [[Эргодическая марковская цепь]]<br />
* [[Регулярная марковская цепь]]<br />
* [[Примеры использования Марковских цепей]]<br />
* [[Скрытые Марковские модели]]<tex>^\star</tex><br />
* [[Алгоритм Витерби]]<tex>^\star</tex><br />
* [[Алгоритм "Вперед-Назад"]]<tex>^\star</tex><br />
* [[Алгоритм Баума-Велша]]<tex>^\star</tex><br />
<br />
= Второй семестр =<br />
<br />
== Амортизационный анализ ==<br />
* [[Амортизационный анализ]]<br />
* [[Динамический массив]]<br />
* [[Hashed Array Tree]]<tex>^\star</tex><br />
* [[Список]]<br />
* [[Стек]]<br />
* [[Очередь]]<br />
* [[Дек]]<br />
* [[Мажорирующий элемент]]<br />
* [[Счетчик Кнута]]<br />
* [[Мастер-теорема]]<tex>^\star</tex><br />
* [[List order maintenance]]<tex>^\star</tex><br />
<br />
== Персистентные структуры данных ==<br />
* [[Персистентные структуры данных]]<br />
* [[Персистентный стек]]<br />
* [[Персистентная очередь]]<br />
* [[Персистентный дек]]<br />
* [[Персистентная приоритетная очередь]]<br />
<br />
== [[Приоритетные очереди]] ==<br />
* [[Двоичная куча]]<br />
* [[Биномиальная куча]]<br />
* [[Фибоначчиева куча]]<br />
* [[Левосторонняя куча]]<br />
* [[Тонкая куча]]<br />
* [[Толстая куча на избыточном счетчике]]<br />
* [[Куча Бродала-Окасаки]]<tex>^\star</tex><br />
<br />
== Система непересекающихся множеств ==<br />
* [[СНМ (наивные реализации) | Наивные реализации]]<br />
* [[СНМ (списки с весовой эвристикой) | Списки с весовой эвристикой]]<br />
* [[СНМ(реализация с помощью леса корневых деревьев) | Реализация с помощью леса корневых деревьев]]<br />
* [[СНМ с операцией удаления за О(1)]]<tex>^\star</tex><br />
<br />
== [[Поисковые структуры данных]] ==<br />
* [[Упорядоченное множество]]<br />
* [[Дерево поиска, наивная реализация]]<br />
* [[АВЛ-дерево]]<br />
* [[2-3 дерево]]<br />
* [[B-дерево]]<br />
* [[Красно-черное дерево]]<br />
* [[Декартово дерево]]<br />
* [[Декартово дерево по неявному ключу]]<br />
* [[Splay-дерево]]<br />
* [[Взвешенное дерево]]<br />
* [[Tango-дерево]]<tex>^\star</tex><br />
* [[Рандомизированное бинарное дерево поиска]]<br />
* [[Дерево ван Эмде Боаса]]<br />
* [[Список с пропусками]]<br />
* [[Fusion tree]]<tex>^\star</tex><br />
* [[Сверхбыстрый цифровой бор]]<br />
* [[Rope]]<tex>^\star</tex><br />
* [[AA-дерево]]<tex>^\star</tex><br />
<br />
== Дерево отрезков ==<br />
<br />
* [[Статистики на отрезках. Корневая эвристика]]<br />
* [[Дерево отрезков. Построение]]<br />
* [[Реализация запроса в дереве отрезков сверху]]<br />
* [[Реализация запроса в дереве отрезков снизу]]<br />
* [[Несогласованные поддеревья. Реализация массового обновления]]<br />
* [[Многомерное дерево отрезков]]<br />
* [[Сжатое многомерное дерево отрезков]]<br />
<br />
== Дерево Фенвика ==<br />
* [[Дерево Фенвика]]<br />
* [[Встречное дерево Фенвика]]<br />
* [[Дерево Фенвика для некоммутативных операций]]<br />
* [[Многомерное дерево Фенвика]]<br />
<br />
== Хеширование ==<br />
* [[Хеш-таблица]]<br />
* [[Разрешение коллизий]]<br />
* [[Хеширование кукушки]]<br />
* [[Идеальное хеширование]]<br />
* [[Перехеширование]]<br />
* [[Фильтр Блума]]<br />
* [[Quotient filter]]<tex>^\star</tex><br />
* [[Универсальное семейство хеш-функций]]<br />
* [[Расширяемое хеширование]]<tex>^\star</tex><br />
<br />
== [[Сортировки]] ==<br />
=== Квадратичные сортировки ===<br />
* [[Сортировка выбором]]<br />
* [[Сортировка пузырьком]]<br />
* [[Сортировка вставками]]<br />
=== Сортировки на сравнениях ===<br />
* [[Сортировка Шелла]]<tex>^\star</tex><br />
* [[Сортировка кучей]]<br />
* [[Быстрая сортировка]]<br />
* [[Сортировка слиянием]]<br />
* [[Cортировка слиянием с использованием O(1) дополнительной памяти]]<br />
* [[Терпеливая сортировка]]<tex>^\star</tex><br />
* [[Timsort]]<tex>^\star</tex><br />
* [[Smoothsort]]<tex>^\star</tex><br />
* [[Теорема о нижней оценке для сортировки сравнениями]]<br />
<br />
=== Многопоточные сортировки ===<br />
* [[Многопоточная сортировка слиянием]]<tex>^\star</tex><br />
* [[PSRS-сортировка]]<tex>^\star</tex><br />
=== Другие сортировки ===<br />
* [[Поиск k-ой порядковой статистики]]<br />
* [[Поиск k-ой порядковой статистики за линейное время]]<br />
* [[Поиск k-ой порядковой статистики в двух массивах]]<tex>^\star</tex><br />
* [[Сортировка подсчетом]]<br />
* [[Цифровая сортировка]]<br />
* [[Карманная сортировка]]<br />
* [[Сортировка Хана]]<tex>^\star</tex><br />
* [[Задача флага Нидерландов]]<tex>^\star</tex><br />
* [[Блинная сортировка]]<tex>^\star</tex><br />
<br />
== Сортирующие сети ==<br />
* [[Сортирующие сети]]<br />
* [[0-1 принцип | Проверка сети компараторов на то, что она сортирующая. 0-1 принцип]]<br />
* [[Сортирующие сети для квадратичных сортировок]]<br />
* [[Сортировочные сети с особыми свойствами]]<tex>^\star</tex><br />
* [[Сеть Бетчера]]<br />
<br />
== Алгоритмы поиска ==<br />
* [[Целочисленный двоичный поиск]]<br />
* [[Поиск в матрице]]<tex>^\star</tex><br />
* [[Вещественный двоичный поиск]]<br />
* [[Троичный поиск]]<br />
* [[Поиск с помощью золотого сечения]]<br />
* [[Интерполяционный поиск]]<br />
* [[Метод Фибоначчи]]<tex>^\star</tex><br />
<br />
== Связь между структурами данных ==<br />
* [[Связь между структурами данных]]<br />
<br />
= Третий семестр =<br />
<br />
== Основные определения теории графов ==<br />
* [[Основные определения теории графов|Основные определения: граф, ребро, вершина, степень, петля, путь, цикл]]<br />
* [[Лемма о рукопожатиях]]<br />
* [[Теорема о существовании простого пути в случае существования пути]]<br />
* [[Теорема о существовании простого цикла в случае существования цикла]]<br />
* [[Матрица смежности графа]]<br />
* [[Матрица инцидентности графа]]<br />
* [[Циклическое пространство графа]]<tex>^\star</tex><br />
* [[Фундаментальные циклы графа]]<tex>^\star</tex><br />
* [[Дерево, эквивалентные определения]]<br />
* [[Алгоритмы на деревьях]]<tex>^\star</tex><br />
* [[Двудольные графы]]<br />
* [[Дополнительный, самодополнительный граф]]<br />
* [[Теоретико-множественные операции над графами]]<tex>^\star</tex><br />
* [[Рёберное ядро]]<br />
* [[Факторизация графов]]<tex>^\star</tex><br />
* [[Группы графов]]<tex>^\star</tex><br />
* [[Гиперграфы]]<tex>^\star</tex><br />
<br />
== Связность в графах ==<br />
* [[Отношение связности, компоненты связности]]<br />
* [[Отношение реберной двусвязности]]<br />
* [[Отношение вершинной двусвязности]]<br />
* [[Точка сочленения, эквивалентные определения]]<br />
* [[Мост, эквивалентные определения]]<br />
* [[Граф компонент реберной двусвязности]]<br />
* [[Граф блоков-точек сочленения]]<br />
* [[k-связность]]<br />
* [[Теорема Менгера]]<br />
* [[Теорема Менгера, альтернативное доказательство]]<br />
* [[Вершинная, реберная связность, связь между ними и минимальной степенью вершины]]<br />
<br />
== Остовные деревья ==<br />
=== Построение остовных деревьев ===<br />
* [[Остовные деревья: определения, лемма о безопасном ребре]]<br />
* [[Алгоритм Прима]]<br />
* [[Алгоритм Краскала]]<br />
* [[Алгоритм Борувки]]<br />
* [[Критерий Тарьяна минимальности остовного дерева|Теорема Тарьяна (критерий минимальности остовного дерева)]]<br />
* [[Алгоритм двух китайцев]]<br />
<br />
=== Свойства остовных деревьев ===<br />
* [[Матрица Кирхгофа]]<br />
* [[Связь матрицы Кирхгофа и матрицы инцидентности]]<br />
* [[Подсчет числа остовных деревьев с помощью матрицы Кирхгофа]]<br />
* [[Количество помеченных деревьев]]<br />
* [[Коды Прюфера]]<br />
<br />
== Обходы графов ==<br />
=== Эйлеровы графы ===<br />
* [[Эйлеров цикл, Эйлеров путь, Эйлеровы графы, Эйлеровость орграфов]]<br />
* [[Покрытие ребер графа путями]]<br />
* [[Алгоритм построения Эйлерова цикла]]<br />
* [[Произвольно вычерчиваемые из заданной вершины графы]]<br />
* [[Деревья Эйлерова обхода]]<tex>^\star</tex><br />
<br />
=== Гамильтоновы графы ===<br />
* [[Гамильтоновы графы]]<br />
* [[Теорема Хватала]]<br />
* [[Теорема Дирака]]<br />
* [[Теорема Оре]]<br />
* [[Теорема Поша]]<tex>^\star</tex><br />
* [[Теорема Гуйя-Ури]]<tex>^\star</tex><br />
* [[Алгоритм нахождения Гамильтонова цикла в условиях теорем Дирака и Оре]]<br />
* [[Теорема Гринберга]]<tex>^\star</tex><br />
* [[Турниры]]<br />
* [[Теорема Редеи-Камиона]]<br />
<br />
== Укладки графов ==<br />
* [[Укладка графа на плоскости]]<br />
* [[Формула Эйлера]]<br />
* [[Непланарность K5 и K3,3|Непланарность <tex>K_5</tex> и <tex>K_{3,3}</tex>]]<br />
* [[Укладка дерева]]<br />
* [[Укладка графа с планарными компонентами реберной двусвязности]]<br />
* [[Укладка графа с планарными компонентами вершинной двусвязности]]<br />
* [[Теорема Понтрягина-Куратовского]]<br />
* [[Теорема Вагнера]]<br />
* [[Род, толщина, крупность, число скрещиваний]]<tex>^\star</tex><br />
* [[Двойственный граф планарного графа]]<br />
* [[Теорема Фари]]<tex>^\star</tex><br />
* [[Гамма-алгоритм]]<br />
* [[Разрез в планарных графах]]<br />
<br />
== Раскраски графов ==<br />
* [[Раскраска графа]]<br />
* [[Двудольные графы и раскраска в 2 цвета]]<br />
* [[Хроматический многочлен]]<br />
* [[Формула Зыкова]]<br />
* [[Формула Уитни]]<br />
* [[Теорема Брукса]]<br />
* [[Верхние и нижние оценки хроматического числа]]<tex>^\star</tex><br />
* [[Хроматическое число планарного графа]]<br />
* [[Многочлен Татта]]<tex>^\star</tex><br />
* [[Теория Рамсея]]<tex>^\star</tex><br />
<br />
== Обход в глубину ==<br />
* [[Обход в глубину, цвета вершин]]<br />
* [[Лемма о белых путях]]<br />
* [[Использование обхода в глубину для проверки связности]]<br />
* [[Использование обхода в глубину для поиска цикла]]<br />
* [[Использование обхода в глубину для топологической сортировки]]<br />
* [[Использование обхода в глубину для поиска компонент сильной связности]]<br />
* [[Использование обхода в глубину для поиска точек сочленения]]<br />
* [[Построение компонент вершинной двусвязности]]<br />
* [[Использование обхода в глубину для поиска мостов]]<br />
* [[Построение компонент реберной двусвязности]]<br />
<br />
== Кратчайшие пути в графах ==<br />
* [[Обход в ширину]]<br />
* [[Алгоритм Форда-Беллмана]]<br />
* [[Алгоритм Дейкстры]]<br />
* [[Алгоритм Флойда]]<br />
* [[Алгоритм Джонсона]]<br />
* [[Алгоритм Левита]]<tex>^\star</tex><br />
* [[Алгоритм A*]] <tex>^\star</tex><br />
* [[Алгоритм D*]] <tex>^\star</tex><br />
* [[Эвристики для поиска кратчайших путей]]<tex>^\star</tex><br />
<br />
== Задача о паросочетании ==<br />
* [[Паросочетания: основные определения, теорема о максимальном паросочетании и дополняющих цепях]]<br />
* [[Алгоритм Форда-Фалкерсона для поиска максимального паросочетания]]<br />
* [[Алгоритм Куна для поиска максимального паросочетания]]<br />
* [[Теорема Холла]]<br />
* [[Связь максимального паросочетания и минимального вершинного покрытия в двудольных графах]]<br />
* [[Связь вершинного покрытия и независимого множества]]<br />
* [[Рёберное ядро]]<tex>^\star</tex><br />
* [[Матрица Татта и связь с размером максимального паросочетания в двудольном графе]]<br />
* [[Теорема Татта о существовании полного паросочетания]]<br />
* [[Алгоритм вырезания соцветий|Паросочетания в недвудольных графах. Алгоритм вырезания соцветий]]<br />
* [[Декомпозиция Эдмондса-Галлаи]]<br />
* [[Задача об устойчивом паросочетании]]<tex>^\star</tex><br />
* [[Совершенное паросочетание в кубическом графе]]<tex>^\star</tex><br />
<br />
== Задача о максимальном потоке ==<br />
* [[Определение сети, потока]]<br />
* [[Разрез, лемма о потоке через разрез]]<br />
* [[Дополняющая сеть, дополняющий путь]]<br />
* [[Сложение и разность потоков]]<br />
* [[Теорема Форда-Фалкерсона]]<br />
* [[Алгоритм Форда-Фалкерсона, реализация с помощью поиска в глубину]]<br />
* [[Алоритм Эдмондса-Карпа]]<br />
* [[Алгоритм масштабирования потока]]<br />
* [[Блокирующий поток]]<br />
* [[Схема алгоритма Диница]]<br />
* [[Теоремы Карзанова о числе итераций алгоритма Диница в сети с целочисленными пропускными способностями]]<br />
* [[Алгоритм Голдберга-Тарьяна]]<tex>^\star</tex><br />
* [[Алгоритм поиска блокирующего потока в ациклической сети]]<br />
* [[Метод проталкивания предпотока]]<br />
* [[Алгоритм "поднять-в-начало"]]<br />
* [[Теорема о декомпозиции]]<br />
* [[Теорема о декомпозиционном барьере]]<br />
* [[Циркуляция потока]]<br />
* [[Алгоритм Каргера для нахождения минимального разреза]]<tex>^\star</tex><br />
* [[Примеры сведения к задачам поиска потока]]<br />
<br />
== Задача о потоке минимальной стоимости ==<br />
* [[Поток минимальной стоимости]]<br />
* [[Теорема Форда-Фалкерсона о потоке минимальной стоимости]]<br />
* [[Лемма об эквивалентности свойства потока быть минимальной стоимости и отсутствии отрицательных циклов в остаточной сети]]<br />
* [[Поиск потока минимальной стоимости методом дополнения вдоль путей минимальной стоимости]]<br />
* [[Использование потенциалов Джонсона при поиске потока минимальной стоимости]]<br />
* [[Сведение задачи о назначениях к задаче о потоке минимальной стоимости]]<br />
* [[Венгерский алгоритм решения задачи о назначениях]]<br />
* [[Алгоритм отмены цикла минимального среднего веса]]<br />
<br />
= Четвертый семестр =<br />
<br />
== Основные определения. Простые комбинаторные свойства слов ==<br />
* [[Основные определения, связанные со строками]]<br />
* [[Период и бордер, их связь]]<br />
* [[Слово Фибоначчи]]<br />
* [[Слово Туэ-Морса]]<br />
* [[Декомпозиция Линдона]]<tex>^\star</tex><br />
* [[Алгоритм Ландау-Шмидта]]<tex>^\star</tex><br />
* [[Алгоритм Крочемора]]<tex>^\star</tex><br />
* [[Алгоритм Мейна-Лоренца]]<tex>^\star</tex><br />
* [[Алгоритм Манакера]]<tex>^\star</tex><br />
* [[Дерево палиндромов]]<tex>^\star</tex><br />
<br />
== [[Поиск подстроки в строке]] ==<br />
=== Точный поиск ===<br />
* [[Наивный алгоритм поиска подстроки в строке]]<br />
* [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа]]<br />
* [[Поиск наибольшей общей подстроки двух строк с использованием хеширования]]<br />
* [[Префикс-функция]]<br />
* [[Алгоритм Кнута-Морриса-Пратта]]<br />
* [[Автомат Кнута-Морриса-Пратта]]<br />
* [[Z-функция]]<br />
* [[Бор]]<br />
* [[Алгоритм Ахо-Корасик]]<br />
* [[Суффиксный автомат]]<br />
* [[Алгоритм Бойера-Мура]]<br />
* [[Алгоритм Апостолико-Крочемора]]<tex>^\star</tex><br />
* [[Алгоритм Колусси]]<tex>^\star</tex><br />
* [[Алгоритм Райта]]<tex>^\star</tex><br />
* [[Алгоритм Shift-And]]<tex>^\star</tex><br />
* [[Двусторонний алгоритм]]<tex>^\star</tex><br />
* [[Турбо-алгоритм Бойера-Мура]]<tex>^\star</tex><br />
<br />
=== Нечёткий поиск ===<br />
* [[Алгоритм Ландау-Вишкина (k несовпадений)]]<tex>^\star</tex><br />
* [[Алгоритм Ландау-Вишкина (k различий)]]<tex>^\star</tex><br />
<br />
== Суффиксное дерево ==<br />
* [[Суффиксный бор]]<br />
* [[Сжатое суффиксное дерево]]<br />
* [[Алгоритм Укконена]]<br />
* [[Алгоритм МакКрейта]]<tex>^\star</tex><br />
* [[Алгоритм Фарача]]<tex>^\star</tex><br />
<br />
== Суффиксный массив ==<br />
* [[Суффиксный массив]]<br />
* [[Построение суффиксного массива с помощью стандартных методов сортировки]]<br />
* [[Алгоритм цифровой сортировки суффиксов циклической строки]]<br />
* [[Алгоритм Касаи и др.]]<br />
* [[Алгоритм Карккайнена-Сандерса]]<br />
* [[Алгоритм поиска подстроки в строке с помощью суффиксного массива]]<br />
* [[Количество подпалиндромов в строке]]<tex>^\star</tex><br />
<br />
== Задача о наименьшем общем предке ==<br />
* [[Сведение задачи LCA к задаче RMQ]]<br />
* [[Сведение задачи RMQ к задаче LCA]]<br />
* [[Метод двоичного подъема]]<br />
* [[Решение RMQ с помощью разреженной таблицы]]<br />
* [[Алгоритм Фарака-Колтона и Бендера]] (решение +/-1 RMQ с помощью метода четырех русских)<br />
* [[Алгоритм Хьюи]]<br />
* [[Heavy-light декомпозиция]]<br />
* [[Алгоритм Шибера-Вишкина]]<tex>^\star</tex><br />
* [[Алгоритм Тарьяна поиска LCA за O(1) в оффлайн]]<tex>^\star</tex><br />
* [[Link-Cut Tree]]<tex>^\star</tex><br />
* [[Rake-Compress деревья]]<tex>^\star</tex><br />
<br />
== Матроиды ==<br />
=== Основные факты теории матроидов ===<br />
* [[Определение матроида]]<br />
* [[Примеры матроидов]]<br />
* [[Прямая сумма матроидов]]<br />
* [[Теорема Радо-Эдмондса (жадный алгоритм)]]<br />
* [[Теорема о базах]]<br />
* [[Аксиоматизация матроида базами]]<br />
* [[Теорема о циклах]]<br />
* [[Аксиоматизация матроида циклами]]<br />
* [[Ранговая функция, полумодулярность]]<br />
* [[Аксиоматизация матроида рангами]]<br />
* [[Двойственный матроид]]<br />
* [[Оператор замыкания для матроидов]]<br />
* [[Покрытия, закрытые множества]]<br />
* [[Матроид Вамоса]]<tex>^\star</tex><br />
<br />
=== Пересечение матроидов ===<br />
* [[Пересечение матроидов, определение, примеры]]<br />
* [[Граф замен]]<br />
* [[Алгоритм построения базы в пересечении матроидов]]<br />
<br />
=== Объединение матроидов ===<br />
* [[Объединение матроидов, проверка множества на независимость]]<br />
* [[Объединение матроидов, доказательство того, что объединение является матроидом]]<br />
* [[Алгоритм построения базы в объединении матроидов]]<br />
<br />
== Теория расписаний ==<br />
=== Общая теория ===<br />
* [[Классификация задач]]<br />
* [[Методы решения задач теории расписаний]]<br />
* [[Правило Лаулера]]<br />
<br />
=== Задачи с одним станком ===<br />
* [[1sumu|<tex>1 \mid \mid \sum U_{i}</tex>]]<br />
* [[1sumwu|<tex> 1 \mid\mid \sum w_i U_i </tex>]]<br />
* [[1sumwT|<tex> 1 \mid\mid \sum w_i T_i </tex>]]<br />
* [[1p1sumu|<tex>1 \mid p_{i} = 1 \mid \sum U_{i}</tex>]]<br />
* [[1ridipi1|<tex>1 \mid r_{i}, d_{i}, p_{i} = 1 \mid -</tex>]]<br />
* [[1pi1sumwu|<tex>1 \mid p_{i} = 1 \mid \sum w_{i}U_{i}</tex>]]<br />
* [[1ripi1sumwc|<tex>1 \mid r_{i}, p_i=1\mid \sum w_{i}C_{i}</tex>]]<br />
* [[1ripi1sumf|<tex>1 \mid r_i, p_i = 1 \mid \sum f_i</tex>]]<br />
* [[1ripipsumwu|<tex> 1 \mid r_i,p_i=p \mid \sum w_i U_i</tex>]]<br />
* [[1ripippmtnsumwu| <tex> 1 \mid r_i,p_i=p, pmtn \mid \sum w_i U_i</tex>]]<br />
* [[1ripmtnsumwu|<tex>1 \mid r_i, pmtn \mid \sum w_{i}U_{i}</tex>]]<br />
* [[1outtreesumwc | <tex>1 \mid outtree \mid \sum w_i C_i</tex>]]<br />
* [[1precpmtnrifmax|<tex>1 \mid prec, pmtn, r_i \mid f_{\max}</tex>]]<br />
* [[1precripi1Lmax|<tex>1 \mid prec; r_i; p_i = 1 \mid L_{max}</tex>]]<br />
<br />
=== Специальные случаи задач для двух станков ===<br />
* [[P2precpi1Lmax|<tex>P2 \mid prec, p_i = 1 \mid L_{\max}</tex>]]<br />
* [[R2Cmax|<tex>R2 \mid \mid C_{max}</tex>]]<br />
* [[F2Cmax|<tex>F2 \mid \mid C_{max}</tex>]]<br />
* [[O2Cmax|<tex>O2 \mid \mid C_{max}</tex>]]<br />
* [[J2ni2Cmax|<tex>J2 \mid n_{i} \leqslant 2 \mid C_{max}</tex>]]<br />
* [[J2pij1Lmax| <tex>J2\mid p_{ij} = 1\mid L_{max}</tex>]]<br />
<br />
=== Задачи для произвольного числа станков ===<br />
* [[Flow shop]]<br />
* [[Fpij1sumwu|<tex>F \mid p_{ij} = 1 \mid \sum w_i U_i</tex>]]<br />
* [[PSumCi|<tex>P \mid \mid \sum C_{i}</tex>]]<br />
* [[Pintreepi1Lmax|<tex>P \mid intree, p_{i} = 1 \mid L_{max}</tex>]]<br />
* [[PpmtnriLmax|<tex>P \mid pmtn, r_i \mid L_{max}</tex>]]<br />
* [[Ppi1sumwu|<tex>P \mid p_i=1 \mid \sum w_i U_i</tex>]]<br />
* [[Ppi1riintegerLmax|<tex>P \mid p_i=1; r_i - integer \mid L_{max}</tex>]]<br />
* [[RSumCi|<tex>R \mid \mid \sum C_i</tex>]]<br />
* [[RpmtnCmax|<tex>R \mid pmtn \mid C_{max}</tex>]]<br />
* [[QpmtnCmax|<tex>Q \mid pmtn \mid C_{max}</tex>]]<br />
* [[QpmtnSumCi|<tex> Q \mid pmtn \mid \sum C_i </tex>]]<br />
* [[QpmtnriLmax|<tex>Q \mid pmtn, r_{i} \mid L_{max}</tex>]]<br />
* [[QSumCi|<tex>Q\mid\mid\sum{C_i}</tex>]]<br />
* [[Opi1sumu|<tex>O \mid p_{ij} = 1 \mid \sum U_i</tex>]]<br />
* [[Opij1di|<tex>O \mid p_{ij} = 1, d_i \mid - </tex>]]<br />
* [[Opij1sumwu|<tex> O \mid p_{i,j} = 1 \mid \sum w_{i} U_{i} </tex>]]<br />
* [[Opij1SumTi|<tex> O \mid p_{i,j} = 1 \mid \sum T_{i} </tex>]]<br />
* [[Opij1Cmax|<tex> O \mid p_{ij} = 1 \mid C_{max} </tex>]]<br />
* [[Opij1Sumwc|<tex> O \mid p_{ij} = 1 \mid \sum w_i C_i </tex>]]</div>Evarandhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A0%D0%B0%D0%B7%D1%80%D0%B5%D0%B7_%D0%B2_%D0%BF%D0%BB%D0%B0%D0%BD%D0%B0%D1%80%D0%BD%D1%8B%D1%85_%D0%B3%D1%80%D0%B0%D1%84%D0%B0%D1%85&diff=58623Разрез в планарных графах2017-01-04T00:05:58Z<p>Evarand: Алгоритм за O(n^2 logn)</p>
<hr />
<div>Особенности [[укладка графа на плоскости | планарных графов]] позволяют реализовать поиск [[разрез, лемма о потоке через разрез | минимального разреза]] в планарном графе с лучшей асимптотикой, чем в произвольном графе. Лучший известный алгоритм работает с асимптотикой <math>O(n\log n)</math>.<br />
<br />
==Алгоритм за <math>O(n^2 \log n)</math>==<br />
Рассмотрим неориентированный граф <math>G=(V, E)</math>. Будем считать его трёхсвязным, если это не так, [[теорема Фари | триангулируем]] его, используя ребра нулевой пропускной способности, это не изменит значение минимального <math>(s-t)-</math> разреза. Минимальный разрез исходного графа будет состоять из ребер минимального разреза нового графа, которые есть и в исходном графе.<br />
<br />
<math>G</math> трёхсвязен, поэтому существует единственный [[двойственный граф планарного графа | двойственный]] ему граф <math>G^d=(X, A)</math>, при этом <math>G^d</math> также трёхсвязен. Будем обозначать множество граней <math>G</math> как <math>F</math>, множество граней <math>G^d</math> как <math>\Phi</math>. Между элементами каждой из пар множеств <math>V-\Phi</math>, <math>E-A</math> и <math>F-X</math> существует взаимно однозначное соответствие. Будем обозначать как <math>\alpha^d\in E</math> элемент, соответствующий <math>\alpha\in A</math>. Тогда длину ребра <math>\alpha</math> определим как <math>l(\alpha)=c(\alpha^d)</math>.<br />
<br />
Будем обозначать грани <math>G^d</math>, соответствующие вершинам <math>s</math> и <math>t</math>, как <math>\varphi_s</math> и <math>\varphi_t</math> соответственно. Далее будем считать, что <math>\varphi_s</math> {{---}} внешняя грань <math>G^d</math>.<br />
<br />
{{Лемма<br />
|statement=<br />
<math>C</math> {{---}} минимальный <math>(s-t)-</math> разрез, тогда <math>C^d=\{\alpha | \alpha^d\in C\}</math> {{---}} цикл минимальной длины, ограничивающий <math>\varphi_t</math>.<br />
}}<br />
<br />
Формальное доказательство леммы громоздкое и здесь приведено не будет, однако сама лемма достаточно интуитивно понятна.<br />
<br />
Пусть <math>\xi^s\in\varphi_s</math>, <math>\xi^t\in\varphi_t</math>, <math>\Pi=(\xi^s=\xi_1, \ldots, \xi_k=\xi^t)</math> {{---}} кратчайший путь между <math>\xi^s</math> и <math>\xi^t</math> в <math>G^d</math>, <math>\alpha_i</math> {{---}} ребро между <math>\xi_{i-1}</math> и <math>\xi_i</math> для <math>i=2,\ldots,k</math>. Будем называть ребро <math>\xi-\xi_i\in A</math> <math>\Pi-</math> левым, если оно находится между <math>\alpha_i</math> и <math>\alpha_{i+1}</math> при обходе ребер, входящих в <math>\xi_i</math>, по часовой стрелке от <math>\alpha_i</math>, и <math>\Pi-</math> правым, если оно находится между <math>\alpha_{i+1}</math> и <math>\alpha_i</math>.<br />
Для того, чтобы это определение имело смысл для первой и последней вершин пути, можно добавить две вершины <math>\xi_0</math> и <math>\xi_{k+1}</math> и два ребра <math>\alpha_1=\xi_0-\xi_1</math> и <math>\alpha_{k+1}=\xi_k-\xi_{k+1}</math>. Важно, что никакое ребро не является одновременно <math>\Pi-</math> левым и <math>\Pi-</math> правым.<br />
<br />
Будем называть <math>\xi_i</math> - циклом простой цикл, который содержит ровно одно <math>\Pi-</math> левое и одно <math>\Pi-</math> правое ребро, при этом <math>\Pi-</math> левое ребро входит в вершину <math>\xi_i</math>. Любой <math>\xi_i</math> - цикл ограничивает <math>\varphi_t</math>.<br />
<br />
{{Лемма<br />
|statement=<br />
Пусть <math>C</math> {{---}} кратчайший ограничивающий <math>\varphi_t</math> цикл. Тогда существует <math>\xi_i</math> - цикл такой же длины.<br />
|proof=<br />
<math>\Pi</math> {{---}} кратчайший путь между <math>\xi^s</math> и <math>\xi^t</math>, поэтому любой содержащийся в <math>\Pi</math> путь между <math>\xi_i</math> и <math>\xi_j</math> также кратчайший. При этом любой ограничиващий <math>\varphi_t</math> цикл обязан пересекать <math>\Pi</math>. Цикл, не являющийся <math>\xi_i</math> - циклом, не будет кратчайшим, так как его можно будет сократить вдоль пути <math>\Pi</math>.<br />
}}<br />
<br />
Из леммы следует алгоритм нахождения минимального ограничивающего <math>\varphi_t</math> цикла:<br />
# Для <math>i=1,\ldots,k</math> найдем минимальный <math>\xi_i</math> - цикл<br />
# Кратчайший из этих <math>k</math> путей будет минимальным ограничивающим <math>\varphi_t</math> циклом<br />
<br />
Для поиска минимального <math>\xi_i</math> - цикла построим из неориентированного графа <math>G</math> ориентированный граф <math>\vec{G}^d</math> следующим образом: все <math>\Pi-</math> левые ребра ориентируем из вершин <math>\xi\in\Pi</math>, все <math>\Pi-</math> правые ребра ориентируем в вершины <math>\xi\in\Pi</math>, а остальные ребра <math>u-v</math> заменим на два ребра <math>u\rightarrow v</math> и <math>v\rightarrow u</math>. <br />
<br />
{{Лемма<br />
|statement=<br />
Пусть <math>\xi_i\in\Pi</math>, <math>P_i</math> {{---}} кратчайший нетривиальный путь из <math>\xi_i</math> в <math>\xi_i</math> в <math>\vec{G}^d</math>. Тогда соответствующий путь в <math>G^d</math> является кратчайшим <math>\xi_i</math> - циклом.<br />
|proof=<br />
Из определения <math>\vec{G}^d</math> следует, что если нетривиальный путь из <math>\xi_i</math> в <math>\xi_i</math> содержит больше одного <math>\Pi-</math> правого или <math>\Pi-</math> левого ребра, то в нем есть самопересечение, то есть он не является простым, следовательно, не является кратчайшим <math>\xi_i</math> - циклом.<br />
}}<br />
<br />
Таким образом, нахождение минимального <math>\xi_i</math> - цикла эквивалентно нахождению кратчайшего нетривиального пути из <math>\xi_i</math> в <math>\xi_i</math> в <math>\vec{G}^d</math>. Это можно сделать за <math>O(m\log n)</math>, например, с помощью [[алгоритм Дейкстры | алгоритма Дейкстры]]. Так как в планарных графах <math>m=O(n)</math>, это равно <math>O(n\log n)</math>. Максимум <math>n</math> таких поисков дадут итоговую асимптотику <math>O(n^2\log n)</math>.<br />
<br />
==См. также==<br />
* [[Двойственный граф планарного графа]]<br />
* [[Разрез, лемма о потоке через разрез]]<br />
* [[Укладка графа на плоскости]]<br />
<br />
==Источники информации==<br />
* [http://verona.dei.unipd.it/~prin08/primo_meeting/italiano.pdf: Improved Algorithms for Min Cuts and Max Flows in Undirected Planar Graphs]<br />
* [https://pdfs.semanticscholar.org/b838/35db99723f922b7b286d10952b08c68970a7.pdf: Maximum flow in planar networks, Itai & Shiloach, 1979]<br />
<br />
[[Категория: Алгоритмы и структуры данных]]<br />
[[Категория: Укладки графов]]</div>Evarandhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%91%D0%B0%D1%80%D1%80%D0%BE%D1%83%D0%B7%D0%B0-%D0%A3%D0%B8%D0%BB%D0%B5%D1%80%D0%B0&diff=50191Преобразование Барроуза-Уилера2015-12-12T19:36:32Z<p>Evarand: </p>
<hr />
<div><br />
'''Преобразование Барроуза {{---}} Уилера''' (англ. ''Burrows-Wheeler transform'') {{---}} алгоритм, используемый для предварительной обработки данных перед сжатием, разработанный для улучшения эффективности последующего кодирования. Преобразование Барроуза {{---}} Уилера меняет порядок символов во входной строке таким образом, что повторяющиеся подстроки образуют на выходе идущие подряд последовательности одинаковых символов.<br />
<br />
== Описание алгоритма ==<br />
<br />
Преобразование выполняется в три этапа:<br />
# Составляется таблица всех циклических сдвигов входной строки.<br />
# Производится лексикографическая (в алфавитном порядке) сортировка строк таблицы.<br />
# В качестве выходной строки выбирается последний столбец таблицы преобразования и номер строки, совпадающей с исходной.<br />
<br />
== Пример работы алгоритма ==<br />
<br />
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA". <br />
<br />
{| class="wikitable"<br />
!colspan="4"|Трансформация<br />
|-<br />
! Вход || Все<br />циклические <br /> сдвиги || Сортировка<br />строк || Выход<br />
|-<br />
|<br />
<font color="red">ABACABA</font><br />
|style="text-align:center;"|<br />
<font color="red">ABACABA</font> <br/><br />
BACABAA<br/><br />
ACABAAB<br/><br />
CABAABA<br/><br />
ABAABAC<br/><br />
BAABACA<br/><br />
AABACAB<br/><br />
|style="text-align:center;"|<br />
AABACAB<br/><br />
ABAABAC<br/><br />
<font color="red">ABACABA</font><br/><br />
ACABAAB<br/><br />
BAABACA<br/><br />
BACABAA<br/><br />
CABAABA <br/><br />
|<br />
BCABAAA, 3<br />
|}<br />
<br />
Результат можно записать так: <tex>$BWT(s) = $(</tex>"BCABAAA", <tex>3)</tex>, где <tex>3</tex> {{---}} номер исходной строки в отсортированной матрице. Он нужен для обратного преобразования. <br />
<br />
<br />
Следует заметить, что иногда в исходной строке приводится так называемый символ конца строки <tex>\$</tex>, который в преобразовании будет считаться последним (максимальным) символом, тогда сохранение номера исходной строки не требуется.<br />
<br />
<br />
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA$".<br />
<br />
{| class="wikitable"<br />
!colspan="4"|Трансформация<br />
|-<br />
! Вход || Все<br /> циклические <br/> сдвиги || Сортировка<br />строк || Выход<br />
|-<br />
|<br />
<font color="red">ABACABA$</font><br />
|style="text-align:center;"|<br />
<font color="red">ABACABA$</font><br/><br />
BACABA$A<br/><br />
ACABA$AB<br/><br />
CABA$ABA<br/><br />
ABA$ABAC<br/><br />
BA$ABACA<br/><br />
A$ABACAB<br/><br />
$ABACABA<br />
|style="text-align:center;"|<br />
<font color="red">ABACABA$</font><br/><br />
ABA$ABAC<br/><br />
ACABA$AB<br/><br />
A$ABACAB<br/><br />
BACABA$A<br/><br />
BA$ABACA<br/><br />
CABA$ABA <br/><br />
$ABACABA<br />
|<br />
$CBBAAAA<br />
|} <br />
<br />
<br />
<br />
При аналогичном вышеприведённом преобразовании та строчка в матрице, которая будет заканчиваться на символ конца строки, и будет исходной: ("ABACABA$"). Тогда результат можно записать так: <tex>$BWT(s) =$</tex> "$CBBAAAA".<br />
<br />
== Обратное преобразование ==<br />
<br />
===Наивный алгоритм===<br />
<br />
Пусть нам дано: <tex>$BWT(s) =$(</tex>"BCABAAA", <tex>3)</tex>. Тогда выпишем в столбик нашу преобразованную последовательность символов "BCABAAA". Запишем её как последний столбик предыдущей матрицы (при прямом преобразовании Барроуза {{---}} Уилера), при этом все предыдущие столбцы оставляем пустыми. Далее построчно [[Сортировки | отсортируем]] матрицу, затем в предыдущий столбец запишем "BCABAAA". Опять построчно отсортируем матрицу. Продолжая таким образом, можно восстановить полный список всех циклических сдвигов строки, которую нам надо найти. Выстроив полный отсортированный список сдвигов, выберем строку с номером, который нам был изначально дан. В итоге мы получим искомую строку.<br />
Алгоритм обратного преобразования описан в таблице ниже:<br />
<br />
{| class="wikitable"<br />
!colspan="8"| Обратное преобразование<br />
|-<br />
!colspan="8"| Вход<br />
|-<br />
|align="center" colspan="8"|<br />
BCABAAA<br />
|-<br />
! Добавление 1 || Сортировка 1 || Добавление 2 || Сортировка 2 || Добавление 3 || Сортировка 3 || Добавление 4 <br />
|-align="right"<br />
|<br />
B<br />
C<br />
A<br />
B<br />
A<br />
A<br />
A<br />
|<br />
A<br />
A<br />
A<br />
A<br />
B<br />
B<br />
C<br />
|<br />
BA<br />
CA<br />
AA<br />
BA<br />
AB<br />
AB<br />
AC<br />
|<br />
AA<br />
AB<br />
AB<br />
AC<br />
BA<br />
BA<br />
CA<br />
|<br />
BAA<br />
CAB<br />
AAB<br />
BAC<br />
ABA<br />
ABA<br />
ACA<br />
|<br />
AAB<br />
ABA<br />
ABA<br />
ACA<br />
BAA<br />
BAC<br />
CAB<br />
|<br />
BAAB<br />
CABA<br />
AABA<br />
BACA<br />
ABAA<br />
ABAC<br />
ACAB<br />
|-<br />
! Сортировка 4 || Добавление 5 || Сортировка 5 || Добавление 6 || Сортировка 6 || Добавление 7 || Сортировка 7<br />
<br />
|-align="right"<br />
|<br />
AABA<br />
ABAA<br />
ABAC<br />
ACAB<br />
BAAB<br />
BACA<br />
CABA<br />
|<br />
BAABA<br />
CABAA<br />
AABAC<br />
BACAB<br />
ABAAB<br />
ABACA<br />
ACABA<br />
|<br />
AABAC<br />
ABAAB<br />
ABACA<br />
ACABA<br />
BAABA<br />
BACAB<br />
CABAA<br />
|<br />
BAABAC<br />
CABAAB<br />
AABACA<br />
BACABA<br />
ABAABA<br />
ABACAB<br />
ACABAA<br />
|<br />
AABACA<br />
ABAABA<br />
ABACAB<br />
ACABAA<br />
BAABAC<br />
BACABA<br />
CABAAB<br />
|<br />
BAABACA<br />
CABAABA<br />
AABACAB<br />
BACABAA<br />
ABAABAC<br />
ABACABA<br />
ACABAAB<br />
|<br />
AABACAB<br />
ABAABAC<br />
<font color="red">ABACABA</font><br />
ACABAAB<br />
BAABACA<br />
BACABAA<br />
CABAABA<br />
|-<br />
<br />
!colspan="8"| Результат<br />
|-<br />
|align="center" colspan="8"|<br />
<font color="red">ABACABA</font><br />
|}<br />
<br />
Следует также заметить, что если нам было бы дано <tex>$BWT(s) = $</tex> "$CBBAAAA", то мы также получили бы нашу исходную строку, только с символом конца строки <tex>\$</tex> на конце: ABACABA$.<br />
<br />
Временная сложность данного алгоритма <tex>O(N^3\log{N}) </tex>, пространственная <tex>O(N^2)</tex>.<br />
<br />
====Доказательство корректности====<br />
<br />
Пусть дана строка <tex>$s$</tex>, к которой было применено преобразование BWT. Докажем, что при использовании наивного алгоритма на каждом шаге получающийся набор строк соответствует суффиксам циклических сдвигов исходной строки, методом математической индукции.<br />
* '''База'''. Циклически сдвинем все строки исходной таблицы на <tex>1</tex> влево. Тогда в столбце <tex>n</tex> будут находиться символы, добавленные на первом шаге алгоритма, а в столбце <tex>n - 1</tex> символы, изначально стоявшие в таблице до первого шага алгоритма. Таким образом, полученные на первом шаге алгоритма строки являются суффиксами циклических сдвигов строки <tex>$s$</tex>.<br />
* '''Предположение'''. Пусть на <tex>k</tex> шаге алгоритма все полученные строки являются суффиксами циклических сдвигов строки <tex>$s$</tex>.<br />
* '''Переход'''. Рассмотрим <tex>k+1</tex>-ый шаг алгоритма. Все строки отсортированы, поэтому самый левый столбец совпадет с <tex>1</tex> столбцом исходной таблицы. Циклически сдвинем все строки исходной таблицы на <tex>n - k</tex> символов вправо. Теперь по предположению первые <tex>k</tex> символов справа в каждой строке совпадают у исходной таблицы и у таблицы, полученной в результате работы алгоритма. <tex>k</tex>-ые справа столбцы также совпадают. Добавленный на <tex>k+1</tex>-ом шаге столбец также совпадает с <tex>k+1</tex>-ым справа столбцом сдвинутой исходной таблицы, так как совпадает с последним столбцом исходной таблицы, которая была сдвинута на <tex>n-k</tex>.<br />
<br />
{| class="wikitable"<br />
!colspan="3" | <tex>$k+1$</tex> шаг алгоритма при <tex>$k=3$</tex><br />
|-<br />
! Исходная <br /> таблица || Сдвинутая <br /> таблица || Результат <br /> работы <br /> алгоритма<br />
|-<br />
|style="text-align:center;"|<br />
<font color="red">A</font><font color="green">ABA</font>CA<font color="blue">B</font><br/><br />
<font color="red">A</font><font color="green">BAA</font>BA<font color="blue">C</font><br/><br />
<font color="red">A</font><font color="green">BAC</font>AB<font color="blue">A</font><br/><br />
<font color="red">A</font><font color="green">CAB</font>AA<font color="blue">B</font><br/><br />
<font color="red">B</font><font color="green">AAB</font>AC<font color="blue">A</font><br/><br />
<font color="red">B</font><font color="green">ACA</font>BA<font color="blue">A</font><br/><br />
<font color="red">C</font><font color="green">ABA</font>AB<font color="blue">A</font><br />
|style="text-align:center;"|<br />
CA<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font><br/><br />
BA<font color="blue">C</font><font color="red">A</font><font color="green">BAA</font><br/><br />
AB<font color="blue">A</font><font color="red">A</font><font color="green">BAC</font><br/><br />
AA<font color="blue">B</font><font color="red">A</font><font color="green">CAB</font><br/><br />
AC<font color="blue">A</font><font color="red">B</font><font color="green">AAB</font><br/><br />
BA<font color="blue">A</font><font color="red">B</font><font color="green">ACA</font><br/><br />
AB<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font><br />
|style="text-align:right;"|<br />
<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font> <br/><br />
<font color="blue">C</font><font color="red">A</font><font color="green">BAA</font> <br/><br />
<font color="blue">A</font><font color="red">A</font><font color="green">BAC</font> <br/><br />
<font color="blue">B</font><font color="red">A</font><font color="green">CAB</font> <br/><br />
<font color="blue">A</font><font color="red">B</font><font color="green">AAB</font> <br/><br />
<font color="blue">A</font><font color="red">B</font><font color="green">ACA</font> <br/><br />
<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font> <br/><br />
|-<br />
|}<br />
<br />
Таким образом, поскольку на каждом шаге алгоритма получившиеся строки являлись суффиксами циклических сдвигов <tex> $s$ </tex>, после последнего шага получившиеся строки будут совпадать с циклическими сдвигами <tex> $s$ </tex>.<br />
<br />
===Оптимизированный наивный алгоритм===<br />
<br />
Наивный алгоритм можно оптимизировать. Заметим, что при каждом проявлении неизвестного столбца выполнялись одни и те же действия. К предыдущему приписывался новый столбец и имеющиеся данные сортировались. На каждом шаге к строке, которая находилась на <tex> i </tex>-ом месте, приписывался в начало <tex> i </tex> -ый элемент столбца входных данных. Пусть изначально известно, каким по порядку является приписанный в начало символ (то есть каким по порядку в столбце). Из предыдущего шага известно, какое место занимала строка без этого первого символа (<tex> i </tex> -ое). Тогда несложно заметить, что при выполнении такой операции строка с номером <tex> i </tex> всегда будет перемещаться на позицию с номером <tex> j </tex>.<br />
<br />
{| class="wikitable"<br />
|0||а||&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;||р||9<br />
|-<br />
|1||а||||д||7<br />
|-<br />
|2||а|| ||a||0<br />
|-<br />
|3||а|| ||к||8<br />
|-<br />
|4||а|| ||р||10<br />
|-<br />
|5||б|| ||a||1<br />
|-<br />
|6||б|| ||a||2<br />
|-<br />
|7||д|| ||a||3<br />
|-<br />
|8||к|| ||a||4<br />
|-<br />
|9||р|| ||б||5<br />
|-<br />
|10||р|| ||б||6<br />
|}<br />
<br />
Здесь слева отсортированный данный столбец, чтобы мы знали, какое место в лексикографическом порядке занимает приписываемый нами символ среди всех элементов данного нам изначально столбца. Справа - изначально данный столбец и соответствующее ему число. Поскольку в нашем алгоритме новый столбец приписывается в начало, то мы из состояния <tex> i </tex> (левый столбец) переходим в состояние <tex> j </tex> (правый). Для того, чтобы восстановить строку, нам необходимо от последней такой цифры по пути из <tex> j </tex> в <tex> i </tex> восстановить строку.<br />
{|<br />
|<br />
{| class="wikitable"<br />
|6<br />
|→<br />
|10<br />
|→<br />
|4 <br />
|→<br />
|8<br />
|→ <br />
|3<br />
|→<br />
|7<br />
|→<br />
|1<br />
|→<br />
|5<br />
|→<br />
|9<br />
|→<br />
|0<br />
|→<br />
|2<br />
|-<br />
|а<br />
|<br />
|б<br />
|<br />
|р<br />
|<br />
|а<br />
|<br />
|к<br />
|<br />
|а<br />
|<br />
|д<br />
|<br />
|а<br />
|<br />
|б<br />
|<br />
|р<br />
|<br />
|а<br />
|}<br />
====Сложность оптимизированного алгоритма====<br />
Данный алгоритм работает за <tex>O(N\log{N})</tex> времени и требует <tex>O(N)</tex> памяти. Однако, если размер алфавита не очень большой, то для выяснения первого столбца матрицы можно использовать сортировку подсчетом, в этом случае алгоритм работает за <tex>O(N+M)</tex> действий и требует <tex>O(N+M)</tex> памяти, где <tex>M</tex> — размер алфавита.<br />
<br />
====Псевдокод оптимизированного алгоритма====<br />
Пусть <tex> N </tex> — количество символов во входной строке, <tex> M </tex> — количество символов в алфавите, <tex> k </tex> — номер исходной строки в матрице сдвигов, <tex> s </tex> — входящая строка, <tex> count </tex> — массив для сортировки подсчетом, <tex> t </tex> — вектор обратного преобразования, <tex> x </tex> — номер данной нам строки в таблице.<br />
<br />
'''function''' reverseBWT(N : Int, M : Int, k : Int, s : String): Int[]<br />
<font color="green">// Cчитаем частоты символов</font><br />
'''for''' i = 0 .. M <br />
count[i] = 0<br />
'''for''' i = 0 .. N <br />
count[s[i]]++<br />
<font color="green">// Упорядочиваем символы, чтобы получить первый столбец исходной матрицы</font><br />
<font color="green">// count[i] указывает на первую позицию символа i в первом столбце</font><br />
sum = 0<br />
'''for''' i = 0 .. M<br />
sum = sum + count[i]<br />
count[i] = sum - count[i]<br />
<font color="green">// Cоздаем вектор обратного преобразования</font><br />
'''for''' i = 0 .. N<br />
t[count[s[i]]] = i<br />
count[s[i]]++<br />
<font color="green">// И восстанавливаем исходный текст</font><br />
j = t[x]<br />
'''for''' i = 0 .. N<br />
answer[i] = s[j]<br />
j = t[j]<br />
'''return''' answer<br />
<br />
====Доказательство корректности====<br />
<br />
Пусть текст <tex>T</tex> состоит из <tex>N + 1</tex> символов, занумерованных с нуля: <tex>T[0..N]</tex>. Буквы <tex>T[i]</tex> принадлежат некоторому алфавиту <tex>A</tex>. Лексикографический порядок (строгий) на строках из алфавита <tex>A</tex> будем обозначать <tex>\preceq (\prec)</tex>. Обозначим через <tex>S_{k}T</tex> циклический сдвиг текста <tex>T</tex> на <tex>k</tex> символов влево:<br />
:{|<br />
<tex> S_{k}T = T[(j + k) (\bmod\ N + 1)] </tex><br />
|}<br />
<br />
Существует перестановка <tex>p</tex> чисел <tex>\{0, ..., N\}</tex>, которая удовлетворяет условию: <br />
:{|<br />
<tex> S_{p(i)}T \preceq S_{p(i + 1)}T,\ i = 0, ..., N - 1\ \ \textbf{(1)}</tex><br />
|}<br />
<br />
Преобразование Барроуза-Уилера текста <tex>T</tex> есть текст <tex>B[0..N] = BW(T)</tex>, буквы которого заданы соотношением:<br />
:{|<br />
<tex>B[i] = S_{p(i)}T[N]</tex>, другими словами <tex>B[i] = S_{p(i) - 1}T[0] = T[(p(i) - 1) (\bmod\ N + 1)] \ \ \textbf{(2)}</tex><br />
|}<br />
<br />
Пусть <tex>\sigma</tex> {{---}} перестановка чисел <tex>\{0, ..., N\}</tex>, удовлетворяющая условию:<br />
:{|<br />
<tex>B_{\sigma(i)} \preceq B_{\sigma(i + 1)}</tex>, при <tex>i = 0, ..., N - 1\ \ \textbf{(3)}</tex>,<br />
|}<br />
и в случае равенства <tex>B_{\sigma(i)}</tex> и <tex>B_{\sigma(i + 1)}</tex> выполнено {{---}} <tex>\sigma(i) < \sigma(i + 1)</tex>. Перестановка однозначно определяется текстом <tex>B</tex> и ее можно посчитать за <tex>O(N)</tex>, используя сортировку подсчетом. Рассмотрим перестановку <tex>\sigma</tex> как отображение <tex>\sigma : \{0, ..., N\} \to \{0, ..., N\}</tex>. Пусть <tex>\sigma^{k}</tex> копмозиция <tex>k</tex> отображений <tex>\sigma^{k} = \sigma^{k - 1} \circ \sigma</tex>, где <tex>\sigma^{1} = \sigma, \sigma^{0} \equiv i</tex>.<br />
<br />
{{Теорема<br />
|statement=<br />
<br />
''При всех <tex>m = 1, ..., N + 1</tex> верны утверждения,<br />
:<tex>B_{\sigma(i)}...B_{\sigma^{m}(i)} \preceq B_{\sigma(i + 1)}...B_{\sigma^{m}(i + 1)}</tex>, при <tex>i = 0, ..., N - 1\ \ \textbf{(4)}</tex><br />
:<tex>B_iB_{\sigma(i)}...B_{\sigma^{m - 1}(i)} = S_{p(i) - 1}T[0..m - 1]</tex>, при <tex>i = 0, ..., N\ \ \textbf{(5)}</tex><br />
''<br />
<br />
|proof=<br />
<br />
Если лексикографически отсортировать буквы последнего столбца и поместить их в первый столбец, то получится таблица<br />
<br />
| class="wikitable" style="text-align:center"<br />
|-<br />
!Таблица<br />
|-<br />
|a||b||c<br />
|-<br />
|a||b||c<br />
|<br />
<br />
<br />
}}<br />
<br />
{{Теорема<br />
|statement=<br />
<br />
''Для восстановления исходного текста <tex>T</tex> из преобразования <tex>B</tex> достаточно знать число <tex>I</tex>, отвечающее условию <tex>p(I) = 0</tex>, другими словами <tex>S_{p(I)}T = T</tex>.''<br />
<br />
}}<br />
<br />
===Алгоритм за линейное время===<br />
<br />
Будем обозначать <tex>s^i</tex> <tex>i</tex>-ую циклический сдвиг <tex>$s$</tex>. Пусть <tex>s^0 = s_0 s_1 \ldots s_{n-1}</tex>, <tex>$BWT(s)$\;= L</tex> и <tex>L = L_0L_1\ldots L_{n-1}</tex>, <tex>I</tex> -- номер строки <tex>s^0</tex> в таблице. Предподсчитаем следующие величины:<br />
* Для каждого <tex>L_i</tex> количество символов на подстроке <tex>l_0, \ldots , l_{i-1}</tex>, равных <tex>L_i</tex><br />
* Для каждого уникального <tex>L_i</tex> количество символов в <tex>L</tex>, лексикографически меньших, чем <tex>L_i</tex><br />
<br />
Пример для <tex>$BWT(s) =$</tex> "BCABAAA":<br />
<br />
{| class="wikitable" <br />
!colspan="3" | Таблица первого предподсчёта<br />
|-<br />
! Позиция || Символ || Результат<br />
|-align="center"<br />
! 0 || B || 0<br />
|-<br />
! 1 || C || 0<br />
|-<br />
! 2 || A || 0<br />
|-<br />
! 3 || B || 1<br />
|-<br />
! 4 || A || 1<br />
|-<br />
! 5 || A || 2<br />
|-<br />
! 6 || A || 3<br />
|}<br />
<br />
{| class="wikitable"<br />
!colspan="2" | Таблица второго предподсчёта<br />
|-<br />
! Символ || Количество <br /> меньших<br />
|-align="center"<br />
! A || 0<br />
|-<br />
! B || 4<br />
|-<br />
! C || 6<br />
|}<br />
<br />
Для удобства пронумеруем известные нам данные:<br />
# <tex>L</tex>, последний столбец таблицы сдвигов<br />
# <tex>I</tex>, номер строки <tex>$s$</tex> в таблице сдвигов<br />
# Частота, с которой символ <tex>L_{i}</tex> встречается в подстроке <tex>l_0, \ldots , l_{i-1}</tex><br />
# Для каждого уникального символа количество лексикографически меньших символов в <tex>L</tex><br />
<br />
Символ <tex>s_{n-1}</tex> находится в строке <tex>L</tex> под номером <tex>I</tex>, так как в таблице строка <tex>s^0</tex> имела номер <tex>I</tex>. Найдём символ <tex>s_{n-2}</tex>.<br />
<br />
Символ <tex>s_{n-2}</tex> имеет в строке <tex>L</tex> тот же номер, что строка <tex>s^{n-1}</tex> имела в таблице сдвигов: строка <tex>s^{n-1}</tex> начинается с символа <tex>s_{n-1}</tex>, <tex>s_{n-2}</tex> находится на 1 левее его и из-за циклического сдвига оказывается в последнем столбце. Нам известен символ <tex>s_{n-1}</tex>. Посчитаем, на каком месте в таблице будет стоять строка, начинающаяся с этого символа.<br />
<br />
Из 4 известно количество символов, меньших <tex>s_{n-1}</tex>. Все строки, начинающиеся с этих символов, стоят в таблице раньше <tex>s^{n-1}</tex>. Кроме того, в таблице есть строки, начинающиеся с того же символа, что и <tex>s^{n-1}</tex>. Из 3 известно, сколько их: если символ, равный <tex>s_{n-1}</tex>, встречался в <tex>L</tex> раньше, чем <tex>s_{n-1}</tex>, то в таблице строка, начинающаяся с этого символа, тоже стоит раньше строки, начинающейся с <tex>s_{n-1}</tex>, так как префикс строки, оканчивающейся на этот символ, меньше префикса строки, оканчивающейся на <tex>s_{n-1}</tex>.<br />
<br />
Тогда сумма этих двух величин является номером символа <tex>s_{n-2}</tex> в строке <tex>L</tex>. Зная <tex>s_{n-1}</tex> и <tex>s_{n-2}</tex>, аналогично найдём <tex>s_{n-3}\ldots s_0</tex>.<br />
<br />
Предподсчёт занимает <tex>O(n)</tex> времени, восстановление каждого из <tex>n</tex> символов занимает <tex>O(1)</tex> времени. Суммарное время работы алгоритма <tex>O(n)</tex>.<br />
<br />
Пример работы для <tex>$BWT(s) = ($</tex>"BCABAAA", 2<tex>)</tex> (нумерация с 0):<br />
* <tex>s^0 = .......</tex><br />
* <tex>s_6=L_2 = A</tex>. Тогда <tex>s^0=......</tex>A<br />
* Суммируем значения из двух таблиц: <tex>0+0=0</tex>, <tex>s_5=L_0=B</tex>, <tex>s^0=.....</tex>BA<br />
* Суммируем: <tex>0+4=4</tex>, <tex>s_4=L_4=A</tex>, <tex>s^0=....</tex>ABA<br />
* Суммируем: <tex>1+0=1</tex>, <tex>s_3=L_1=C</tex>, <tex>s^0=...</tex>CABA<br />
* Суммируем: <tex>0+6=6</tex>, <tex>s_2=L_6=A</tex>, <tex>s^0=..</tex>ACABA<br />
* Суммируем: <tex>3+0=3</tex>, <tex>s_2=L_3=B</tex>, <tex>s^0=.</tex>BACABA<br />
* Суммируем: <tex>1+4=5</tex>, <tex>s_2=L_5=A</tex>, <tex>s^0=</tex> ABACABA<br />
<br />
== Замечания ==<br />
<br />
* bzip2<ref>[https://ru.wikipedia.org/wiki/Bzip2 bzip2]</ref> использует преобразование Барроуза {{---}} Уилера для превращения последовательностей многократно чередующихся символов в строки одинаковых символов, затем применяет преобразование [[Преобразование_MTF | MTF]], и в конце кодирование Хаффмана.<br />
<br />
== См. также ==<br />
* [[Алгоритм_Хаффмана | Алгоритм Хаффмана]]<br />
* [[Алгоритмы_LZ77_и_LZ78 | Алгоритмы LZ77 и LZ78]]<br />
* [[Арифметическое_кодирование | Арифметическое кодирование]]<br />
<br />
== Примечания ==<br />
<references/><br />
<br />
== Источники информации ==<br />
*[http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%91%D0%B0%D1%80%D1%80%D0%BE%D1%83%D0%B7%D0%B0_%E2%80%94_%D0%A3%D0%B8%D0%BB%D0%B5%D1%80%D0%B0 Википедия: Преобразование Барроуза {{---}} Уилера]<br />
<br />
*[http://www.cs.karelia.ru/~aborod/inf/2010/schedule.php.ru cs.karelia.ru: Преобразование Барроуза {{---}} Уилера]<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Алгоритмы сжатия ]]</div>Evarandhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%91%D0%B0%D1%80%D1%80%D0%BE%D1%83%D0%B7%D0%B0-%D0%A3%D0%B8%D0%BB%D0%B5%D1%80%D0%B0&diff=50190Преобразование Барроуза-Уилера2015-12-12T19:16:55Z<p>Evarand: </p>
<hr />
<div><br />
'''Преобразование Барроуза {{---}} Уилера''' (англ. ''Burrows-Wheeler transform'') {{---}} алгоритм, используемый для предварительной обработки данных перед сжатием, разработанный для улучшения эффективности последующего кодирования. Преобразование Барроуза {{---}} Уилера меняет порядок символов во входной строке таким образом, что повторяющиеся подстроки образуют на выходе идущие подряд последовательности одинаковых символов.<br />
<br />
== Описание алгоритма ==<br />
<br />
Преобразование выполняется в три этапа:<br />
# Составляется таблица всех циклических сдвигов входной строки.<br />
# Производится лексикографическая (в алфавитном порядке) сортировка строк таблицы.<br />
# В качестве выходной строки выбирается последний столбец таблицы преобразования и номер строки, совпадающей с исходной.<br />
<br />
== Пример работы алгоритма ==<br />
<br />
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA". <br />
<br />
{| class="wikitable"<br />
!colspan="4"|Трансформация<br />
|-<br />
! Вход || Все<br />циклические <br /> сдвиги || Сортировка<br />строк || Выход<br />
|-<br />
|<br />
<font color="red">ABACABA</font><br />
|style="text-align:center;"|<br />
<font color="red">ABACABA</font> <br/><br />
BACABAA<br/><br />
ACABAAB<br/><br />
CABAABA<br/><br />
ABAABAC<br/><br />
BAABACA<br/><br />
AABACAB<br/><br />
|style="text-align:center;"|<br />
AABACAB<br/><br />
ABAABAC<br/><br />
<font color="red">ABACABA</font><br/><br />
ACABAAB<br/><br />
BAABACA<br/><br />
BACABAA<br/><br />
CABAABA <br/><br />
|<br />
BCABAAA, 3<br />
|}<br />
<br />
Результат можно записать так: <tex>$BWT(s) = $(</tex>"BCABAAA", <tex>3)</tex>, где <tex>3</tex> {{---}} номер исходной строки в отсортированной матрице. Он нужен для обратного преобразования. <br />
<br />
<br />
Следует заметить, что иногда в исходной строке приводится так называемый символ конца строки <tex>\$</tex>, который в преобразовании будет считаться последним (максимальным) символом, тогда сохранение номера исходной строки не требуется.<br />
<br />
<br />
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA$".<br />
<br />
{| class="wikitable"<br />
!colspan="4"|Трансформация<br />
|-<br />
! Вход || Все<br />Перестановки || Сортировка<br />Строк || Выход<br />
|-<br />
|<br />
<font color="red">ABACABA$</font><br />
|style="text-align:center;"|<br />
<font color="red">ABACABA$</font><br/><br />
BACABA$A<br/><br />
ACABA$AB<br/><br />
CABA$ABA<br/><br />
ABA$ABAC<br/><br />
BA$ABACA<br/><br />
A$ABACAB<br/><br />
$ABACABA<br />
|style="text-align:center;"|<br />
<font color="red">ABACABA$</font><br/><br />
ABA$ABAC<br/><br />
ACABA$AB<br/><br />
A$ABACAB<br/><br />
BACABA$A<br/><br />
BA$ABACA<br/><br />
CABA$ABA <br/><br />
$ABACABA<br />
|<br />
$CBBAAAA<br />
|} <br />
<br />
<br />
<br />
При аналогичном вышеприведённом преобразовании та строчка в матрице, которая будет заканчиваться на символ конца строки, и будет исходной: ("ABACABA$"). Тогда результат можно записать так: <tex>$BWT(s) =$</tex> "$CBBAAAA".<br />
<br />
== Обратное преобразование ==<br />
<br />
===Наивный алгоритм===<br />
<br />
Пусть нам дано: <tex>$BWT(s) =$(</tex>"BCABAAA", <tex>3)</tex>. Тогда выпишем в столбик нашу преобразованную последовательность символов "BCABAAA". Запишем её как последний столбик предыдущей матрицы (при прямом преобразовании Барроуза {{---}} Уилера), при этом все предыдущие столбцы оставляем пустыми. Далее построчно [[Сортировки | отсортируем]] матрицу, затем в предыдущий столбец запишем "BCABAAA". Опять построчно отсортируем матрицу. Продолжая таким образом, можно восстановить полный список всех циклических перестановок строки, которую нам надо найти. Выстроив полный отсортированный список перестановок, выберем строку с номером, который нам был изначально дан. В итоге мы получим искомую строку.<br />
Алгоритм обратного преобразования описан в таблице ниже:<br />
<br />
{| class="wikitable"<br />
!colspan="8"| Обратное преобразование<br />
|-<br />
!colspan="8"| Вход<br />
|-<br />
|align="center" colspan="8"|<br />
BCABAAA<br />
|-<br />
! Добавление 1 || Сортировка 1 || Добавление 2 || Сортировка 2 || Добавление 3 || Сортировка 3 || Добавление 4 <br />
|-align="right"<br />
|<br />
B<br />
C<br />
A<br />
B<br />
A<br />
A<br />
A<br />
|<br />
A<br />
A<br />
A<br />
A<br />
B<br />
B<br />
C<br />
|<br />
BA<br />
CA<br />
AA<br />
BA<br />
AB<br />
AB<br />
AC<br />
|<br />
AA<br />
AB<br />
AB<br />
AC<br />
BA<br />
BA<br />
CA<br />
|<br />
BAA<br />
CAB<br />
AAB<br />
BAC<br />
ABA<br />
ABA<br />
ACA<br />
|<br />
AAB<br />
ABA<br />
ABA<br />
ACA<br />
BAA<br />
BAC<br />
CAB<br />
|<br />
BAAB<br />
CABA<br />
AABA<br />
BACA<br />
ABAA<br />
ABAC<br />
ACAB<br />
|-<br />
! Сортировка 4 || Добавление 5 || Сортировка 5 || Добавление 6 || Сортировка 6 || Добавление 7 || Сортировка 7<br />
<br />
|-align="right"<br />
|<br />
AABA<br />
ABAA<br />
ABAC<br />
ACAB<br />
BAAB<br />
BACA<br />
CABA<br />
|<br />
BAABA<br />
CABAA<br />
AABAC<br />
BACAB<br />
ABAAB<br />
ABACA<br />
ACABA<br />
|<br />
AABAC<br />
ABAAB<br />
ABACA<br />
ACABA<br />
BAABA<br />
BACAB<br />
CABAA<br />
|<br />
BAABAC<br />
CABAAB<br />
AABACA<br />
BACABA<br />
ABAABA<br />
ABACAB<br />
ACABAA<br />
|<br />
AABACA<br />
ABAABA<br />
ABACAB<br />
ACABAA<br />
BAABAC<br />
BACABA<br />
CABAAB<br />
|<br />
BAABACA<br />
CABAABA<br />
AABACAB<br />
BACABAA<br />
ABAABAC<br />
ABACABA<br />
ACABAAB<br />
|<br />
AABACAB<br />
ABAABAC<br />
<font color="red">ABACABA</font><br />
ACABAAB<br />
BAABACA<br />
BACABAA<br />
CABAABA<br />
|-<br />
<br />
!colspan="8"| Результат<br />
|-<br />
|align="center" colspan="8"|<br />
<font color="red">ABACABA</font><br />
|}<br />
<br />
Следует также заметить, что если нам было бы дано <tex>$BWT(s) = $</tex> "$CBBAAAA", то мы также получили бы нашу исходную строку, только с символом конца строки <tex>\$</tex> на конце: ABACABA$.<br />
<br />
Временная сложность данного алгоритма <tex>O(N^3\log{N}) </tex>, пространственная <tex>O(N^2)</tex>.<br />
<br />
====Доказательство корректности====<br />
<br />
Пусть дана строка <tex>$s$</tex>, к которой было применено преобразование BWT. Докажем, что при использовании наивного алгоритма на каждом шаге получающийся набор строк соответствует суффиксам циклических перестановок исходной строки, методом математической индукции.<br />
* '''База'''. Циклически сдвинем все строки исходной таблицы на <tex>1</tex> влево. Тогда в столбце <tex>n</tex> будут находиться символы, добавленные на первом шаге алгоритма, а в столбце <tex>n - 1</tex> символы, изначально стоявшие в таблице до первого шага алгоритма. Таким образом, полученные на первом шаге алгоритма строки являются суффиксами циклических перестановок строки <tex>$s$</tex>.<br />
* '''Предположение'''. Пусть на <tex>k</tex> шаге алгоритма все полученные строки являются суффиксами циклических перестановок строки <tex>$s$</tex>.<br />
* '''Переход'''. Рассмотрим <tex>k+1</tex>-ый шаг алгоритма. Все строки отсортированы, поэтому самый левый столбец совпадет с <tex>1</tex> столбцом исходной таблицы. Циклически сдвинем все строки исходной таблицы на <tex>n - k</tex> символов вправо. Теперь по предположению первые <tex>k</tex> символов справа в каждой строке совпадают у исходной таблицы и у таблицы, полученной в результате работы алгоритма. <tex>k</tex>-ые справа столбцы также совпадают. Добавленный на <tex>k+1</tex>-ом шаге столбец также совпадает с <tex>k+1</tex>-ым справа столбцом сдвинутой исходной таблицы, так как совпадает с последним столбцом исходной таблицы, которая была сдвинута на <tex>n-k</tex>.<br />
<br />
{| class="wikitable"<br />
!colspan="3" | <tex>$k+1$</tex> шаг алгоритма при <tex>$k=3$</tex><br />
|-<br />
! Исходная <br /> таблица || Сдвинутая <br /> таблица || Результат <br /> работы <br /> алгоритма<br />
|-<br />
|style="text-align:center;"|<br />
<font color="red">A</font><font color="green">ABA</font>CA<font color="blue">B</font><br/><br />
<font color="red">A</font><font color="green">BAA</font>BA<font color="blue">C</font><br/><br />
<font color="red">A</font><font color="green">BAC</font>AB<font color="blue">A</font><br/><br />
<font color="red">A</font><font color="green">CAB</font>AA<font color="blue">B</font><br/><br />
<font color="red">B</font><font color="green">AAB</font>AC<font color="blue">A</font><br/><br />
<font color="red">B</font><font color="green">ACA</font>BA<font color="blue">A</font><br/><br />
<font color="red">C</font><font color="green">ABA</font>AB<font color="blue">A</font><br />
|style="text-align:center;"|<br />
CA<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font><br/><br />
BA<font color="blue">C</font><font color="red">A</font><font color="green">BAA</font><br/><br />
AB<font color="blue">A</font><font color="red">A</font><font color="green">BAC</font><br/><br />
AA<font color="blue">B</font><font color="red">A</font><font color="green">CAB</font><br/><br />
AC<font color="blue">A</font><font color="red">B</font><font color="green">AAB</font><br/><br />
BA<font color="blue">A</font><font color="red">B</font><font color="green">ACA</font><br/><br />
AB<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font><br />
|style="text-align:right;"|<br />
<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font> <br/><br />
<font color="blue">C</font><font color="red">A</font><font color="green">BAA</font> <br/><br />
<font color="blue">A</font><font color="red">A</font><font color="green">BAC</font> <br/><br />
<font color="blue">B</font><font color="red">A</font><font color="green">CAB</font> <br/><br />
<font color="blue">A</font><font color="red">B</font><font color="green">AAB</font> <br/><br />
<font color="blue">A</font><font color="red">B</font><font color="green">ACA</font> <br/><br />
<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font> <br/><br />
|-<br />
|}<br />
<br />
Таким образом, поскольку на каждом шаге алгоритма получившиеся строки являлись суффиксами циклических перестановок <tex> $s$ </tex>, после последнего шага получившиеся строки будут совпадать с циклическими перестановками <tex> $s$ </tex>.<br />
<br />
===Оптимизированный наивный алгоритм===<br />
<br />
Наивный алгоритм можно оптимизировать. Заметим, что при каждом проявлении неизвестного столбца выполнялись одни и те же действия. Мы приписывали новый столбец и сортировали имеющиеся данные. На каждом шагу мы к строке, которая находилась на <tex> i </tex>-ом месте приписываем в начало <tex> i </tex> -ый элемент столбца входных данных. Пусть изначально мы знаем каким по порядку является приписанный нами в начало символ (то есть каким по порядку в столбце). И конечно же мы знаем исходя из предыдущего шага какое место занимала наша строка без этого первого символа (<tex> i </tex> -ое). Тогда несложно заметить, что при выполнении такой операции строка с номером <tex> i </tex> всегда будет перемещаться на позицию с номером <tex> j </tex>.<br />
<br />
{| class="wikitable"<br />
|0||а||&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;||р||9<br />
|-<br />
|1||а||||д||7<br />
|-<br />
|2||а|| ||a||0<br />
|-<br />
|3||а|| ||к||8<br />
|-<br />
|4||а|| ||р||10<br />
|-<br />
|5||б|| ||a||1<br />
|-<br />
|6||б|| ||a||2<br />
|-<br />
|7||д|| ||a||3<br />
|-<br />
|8||к|| ||a||4<br />
|-<br />
|9||р|| ||б||5<br />
|-<br />
|10||р|| ||б||6<br />
|}<br />
<br />
Здесь слева отсортированный данный столбец, чтобы мы знали, какое место в лексикографическом порядке занимает приписываемый нами символ среди всех элементов данного нам изначально столбца. Справа - изначально данный столбец и соответствующее ему число. Поскольку в нашем алгоритме новый столбец приписывается в начало, то мы из состояния <tex> i </tex> (левый столбец) переходим в состояние <tex> j </tex> (правый). Для того, чтобы восстановить строку, нам необходимо от последней такой цифры по пути из <tex> j </tex> в <tex> i </tex> восстановить строку.<br />
{|<br />
|<br />
{| class="wikitable"<br />
|6<br />
|→<br />
|10<br />
|→<br />
|4 <br />
|→<br />
|8<br />
|→ <br />
|3<br />
|→<br />
|7<br />
|→<br />
|1<br />
|→<br />
|5<br />
|→<br />
|9<br />
|→<br />
|0<br />
|→<br />
|2<br />
|-<br />
|а<br />
|<br />
|б<br />
|<br />
|р<br />
|<br />
|а<br />
|<br />
|к<br />
|<br />
|а<br />
|<br />
|д<br />
|<br />
|а<br />
|<br />
|б<br />
|<br />
|р<br />
|<br />
|а<br />
|}<br />
====Сложность оптимизированного алгоритма====<br />
Данный алгоритм работает за <tex>O(N\log{N})</tex> времени и требует <tex>O(N)</tex> памяти. Однако, если размер алфавита не очень большой, то для выяснения первого столбца матрицы можно использовать сортировку подсчетом, в этом случае алгоритм работает за <tex>O(N+M)</tex> действий и требует <tex>O(N+M)</tex> памяти, где <tex>M</tex> — размер алфавита.<br />
<br />
====Псевдокод оптимизированного алгоритма====<br />
Пусть <tex> N </tex> — количество символов во входной строке, <tex> M </tex> — количество символов в алфавите, <tex> k </tex> — номер исходной строки в матрице перестановок, <tex> s </tex> — входящая строка, <tex> count </tex> — массив для сортировки подсчетом, <tex> t </tex> — вектор обратного преобразования, <tex> x </tex> — номер данной нам строки в таблице.<br />
<br />
'''function''' reverseBWT(N : Int, M : Int, k : Int, s : String): Int[]<br />
<font color="green">// Cчитаем частоты символов</font><br />
'''for''' i = 0 .. M <br />
count[i] = 0<br />
'''for''' i = 0 .. N <br />
count[s[i]]++<br />
<font color="green">// Упорядочиваем символы, чтобы получить первый столбец исходной матрицы</font><br />
<font color="green">// count[i] указывает на первую позицию символа i в первом столбце</font><br />
sum = 0<br />
'''for''' i = 0 .. M<br />
sum = sum + count[i]<br />
count[i] = sum - count[i]<br />
<font color="green">// Cоздаем вектор обратного преобразования</font><br />
'''for''' i = 0 .. N<br />
t[count[s[i]]] = i<br />
count[s[i]]++<br />
<font color="green">// И восстанавливаем исходный текст</font><br />
j = t[x]<br />
'''for''' i = 0 .. N<br />
answer[i] = s[j]<br />
j = t[j]<br />
'''return''' answer<br />
<br />
====Доказательство корректности====<br />
<br />
Пусть текст <tex>T</tex> состоит из <tex>N + 1</tex> символов, занумерованных с нуля: <tex>T[0..N]</tex>. Буквы <tex>T[i]</tex> принадлежат некоторому алфавиту <tex>A</tex>. Лексикографический порядок (строгий) на строках из алфавита <tex>A</tex> будем обозначать <tex>\preceq (\prec)</tex>. Обозначим через <tex>S_{k}T</tex> циклический сдвиг текста <tex>T</tex> на <tex>k</tex> символов влево:<br />
:{|<br />
<tex> S_{k}T = T[(j + k) (\bmod\ N + 1)] </tex><br />
|}<br />
<br />
Существует перестановка <tex>p</tex> чисел <tex>\{0, ..., N\}</tex>, которая удовлетворяет условию: <br />
:{|<br />
<tex> S_{p(i)}T \preceq S_{p(i + 1)}T,\ i = 0, ..., N - 1\ \ \textbf{(1)}</tex><br />
|}<br />
<br />
Преобразование Барроуза-Уилера текста <tex>T</tex> есть текст <tex>B[0..N] = BW(T)</tex>, буквы которого заданы соотношением:<br />
:{|<br />
<tex>B[i] = S_{p(i)}T[N]</tex>, другими словами <tex>B[i] = S_{p(i) - 1}T[0] = T[(p(i) - 1) (\bmod\ N + 1)] \ \ \textbf{(2)}</tex><br />
|}<br />
<br />
Пусть <tex>\sigma</tex> {{---}} перестановка чисел <tex>\{0, ..., N\}</tex>, удовлетворяющая условию:<br />
:{|<br />
<tex>B_{\sigma(i)} \preceq B_{\sigma(i + 1)}</tex>, при <tex>i = 0, ..., N - 1\ \ \textbf{(3)}</tex>,<br />
|}<br />
и в случае равенства <tex>B_{\sigma(i)}</tex> и <tex>B_{\sigma(i + 1)}</tex> выполнено {{---}} <tex>\sigma(i) < \sigma(i + 1)</tex>. Перестановка однозначно определяется текстом <tex>B</tex> и ее можно посчитать за <tex>O(N)</tex>, используя сортировку подсчетом. Рассмотрим перестановку <tex>\sigma</tex> как отображение <tex>\sigma : \{0, ..., N\} \to \{0, ..., N\}</tex>. Пусть <tex>\sigma^{k}</tex> копмозиция <tex>k</tex> отображений <tex>\sigma^{k} = \sigma^{k - 1} \circ \sigma</tex>, где <tex>\sigma^{1} = \sigma, \sigma^{0} \equiv i</tex>.<br />
<br />
{{Теорема<br />
|statement=<br />
<br />
''При всех <tex>m = 1, ..., N + 1</tex> верны утверждения,<br />
:<tex>B_{\sigma(i)}...B_{\sigma^{m}(i)} \preceq B_{\sigma(i + 1)}...B_{\sigma^{m}(i + 1)}</tex>, при <tex>i = 0, ..., N - 1\ \ \textbf{(4)}</tex><br />
:<tex>B_iB_{\sigma(i)}...B_{\sigma^{m - 1}(i)} = S_{p(i) - 1}T[0..m - 1]</tex>, при <tex>i = 0, ..., N\ \ \textbf{(5)}</tex><br />
''<br />
<br />
|proof=<br />
<br />
Если лексикографически отсортировать буквы последнего столбца и поместить их в первый столбец, то получится таблица<br />
<br />
| class="wikitable" style="text-align:center"<br />
|-<br />
!Таблица<br />
|-<br />
|a||b||c<br />
|-<br />
|a||b||c<br />
|<br />
<br />
<br />
}}<br />
<br />
{{Теорема<br />
|statement=<br />
<br />
''Для восстановления исходного текста <tex>T</tex> из преобразования <tex>B</tex> достаточно знать число <tex>I</tex>, отвечающее условию <tex>p(I) = 0</tex>, другими словами <tex>S_{p(I)}T = T</tex>.''<br />
<br />
}}<br />
<br />
===Алгоритм за линейное время===<br />
<br />
Будем обозначать <tex>s^i</tex> <tex>i</tex>-ую циклическую перестановку <tex>$s$</tex>. Пусть <tex>s^0 = s_0 s_1 \ldots s_{n-1}</tex>, <tex>$BWT(s)$\;= L</tex> и <tex>L = L_0L_1\ldots L_{n-1}</tex>, <tex>I</tex> -- номер строки <tex>s^0</tex> в таблице. Предподсчитаем следующие величины:<br />
* Для каждого <tex>L_i</tex> количество символов на подстроке <tex>l_0, \ldots , l_{i-1}</tex>, равных <tex>L_i</tex><br />
* Для каждого уникального <tex>L_i</tex> количество символов в <tex>L</tex>, лексикографически меньших, чем <tex>L_i</tex><br />
<br />
Пример для <tex>$BWT(s) =$</tex> "BCABAAA":<br />
<br />
{| class="wikitable" <br />
!colspan="3" | Таблица первого предподсчёта<br />
|-<br />
! Позиция || Символ || Результат<br />
|-align="center"<br />
! 0 || B || 0<br />
|-<br />
! 1 || C || 0<br />
|-<br />
! 2 || A || 0<br />
|-<br />
! 3 || B || 1<br />
|-<br />
! 4 || A || 1<br />
|-<br />
! 5 || A || 2<br />
|-<br />
! 6 || A || 3<br />
|}<br />
<br />
{| class="wikitable"<br />
!colspan="2" | Таблица второго предподсчёта<br />
|-<br />
! Символ || Количество <br /> меньших<br />
|-align="center"<br />
! A || 0<br />
|-<br />
! B || 4<br />
|-<br />
! C || 6<br />
|}<br />
<br />
Для удобства пронумеруем известные нам данные:<br />
# <tex>L</tex>, последний столбец таблицы перестановок<br />
# <tex>I</tex>, номер строки <tex>$s$</tex> в таблице перестановок<br />
# Частота, с которой символ <tex>L_{i}</tex> встречается в подстроке <tex>l_0, \ldots , l_{i-1}</tex><br />
# Для каждого уникального символа количество лексикографически меньших символов в <tex>L</tex><br />
<br />
Символ <tex>s_{n-1}</tex> находится в строке <tex>L</tex> под номером <tex>I</tex>, так как в таблице строка <tex>s^0</tex> имела номер <tex>I</tex>. Найдём символ <tex>s_{n-2}</tex>.<br />
<br />
Символ <tex>s_{n-2}</tex> имеет в строке <tex>L</tex> тот же номер, что строка <tex>s^{n-1}</tex> имела в таблице перестановок: строка <tex>s^{n-1}</tex> начинается с символа <tex>s_{n-1}</tex>, <tex>s_{n-2}</tex> находится на 1 левее его и из-за циклического сдвига оказывается в последнем столбце. Нам известен символ <tex>s_{n-1}</tex>. Посчитаем, на каком месте в таблице будет стоять строка, начинающаяся с этого символа.<br />
<br />
Из 4 известно количество символов, меньших <tex>s_{n-1}</tex>. Все строки, начинающиеся с этих символов, стоят в таблице раньше <tex>s^{n-1}</tex>. Кроме того, в таблице есть строки, начинающиеся с того же символа, что и <tex>s^{n-1}</tex>. Из 3 известно, сколько их: если символ, равный <tex>s_{n-1}</tex>, встречался в <tex>L</tex> раньше, чем <tex>s_{n-1}</tex>, то в таблице строка, начинающаяся с этого символа, тоже стоит раньше строки, начинающейся с <tex>s_{n-1}</tex>, так как префикс строки, оканчивающейся на этот символ, меньше префикса строки, оканчивающейся на <tex>s_{n-1}</tex>.<br />
<br />
Тогда сумма этих двух величин является номером символа <tex>s_{n-2}</tex> в строке <tex>L</tex>. Зная <tex>s_{n-1}</tex> и <tex>s_{n-2}</tex>, аналогично найдём <tex>s_{n-3}\ldots s_0</tex>.<br />
<br />
Предподсчёт занимает <tex>O(n)</tex> времени, восстановление каждого из <tex>n</tex> символов занимает <tex>O(1)</tex> времени. Суммарное время работы алгоритма <tex>O(n)</tex>.<br />
<br />
Пример работы для <tex>$BWT(s) = ($</tex>"BCABAAA", 2<tex>)</tex> (нумерация с 0):<br />
* <tex>s^0 = .......</tex><br />
* <tex>s_6=L_2 = A</tex>. Тогда <tex>s^0=......</tex>A<br />
* Суммируем значения из двух таблиц: <tex>0+0=0</tex>, <tex>s_5=L_0=B</tex>, <tex>s^0=.....</tex>BA<br />
* Суммируем: <tex>0+4=4</tex>, <tex>s_4=L_4=A</tex>, <tex>s^0=....</tex>ABA<br />
* Суммируем: <tex>1+0=1</tex>, <tex>s_3=L_1=C</tex>, <tex>s^0=...</tex>CABA<br />
* Суммируем: <tex>0+6=6</tex>, <tex>s_2=L_6=A</tex>, <tex>s^0=..</tex>ACABA<br />
* Суммируем: <tex>3+0=3</tex>, <tex>s_2=L_3=B</tex>, <tex>s^0=.</tex>BACABA<br />
* Суммируем: <tex>1+4=5</tex>, <tex>s_2=L_5=A</tex>, <tex>s^0=</tex> ABACABA<br />
<br />
== Дополнительно ==<br />
<br />
* bzip2<ref>[https://ru.wikipedia.org/wiki/Bzip2 bzip2]</ref> использует преобразование Барроуза {{---}} Уилера для превращения последовательностей многократно чередующихся символов в строки одинаковых символов, затем применяет преобразование [[Преобразование_MTF | MTF]], и в конце кодирование Хаффмана.<br />
<br />
== См. также ==<br />
* [[Алгоритм_Хаффмана | Алгоритм Хаффмана]]<br />
* [[Алгоритмы_LZ77_и_LZ78 | Алгоритмы LZ77 и LZ78]]<br />
* [[Арифметическое_кодирование | Арифметическое кодирование]]<br />
<br />
== Источники информации ==<br />
*[http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%91%D0%B0%D1%80%D1%80%D0%BE%D1%83%D0%B7%D0%B0_%E2%80%94_%D0%A3%D0%B8%D0%BB%D0%B5%D1%80%D0%B0 Википедия: Преобразование Барроуза {{---}} Уилера]<br />
<br />
*[http://www.cs.karelia.ru/~aborod/inf/2010/schedule.php.ru cs.karelia.ru: Преобразование Барроуза {{---}} Уилера]<br />
<br />
== Примечания ==<br />
<references/><br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Алгоритмы сжатия ]]</div>Evarandhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%91%D0%B0%D1%80%D1%80%D0%BE%D1%83%D0%B7%D0%B0-%D0%A3%D0%B8%D0%BB%D0%B5%D1%80%D0%B0&diff=50189Преобразование Барроуза-Уилера2015-12-12T19:16:19Z<p>Evarand: </p>
<hr />
<div><br />
'''Преобразование Барроуза {{---}} Уилера''' (англ. ''Burrows-Wheeler transform'') {{---}} алгоритм, используемый для предварительной обработки данных перед сжатием, разработанный для улучшения эффективности последующего кодирования. Преобразование Барроуза {{---}} Уилера меняет порядок символов во входной строке таким образом, что повторяющиеся подстроки образуют на выходе идущие подряд последовательности одинаковых символов.<br />
<br />
== Описание алгоритма ==<br />
<br />
Преобразование выполняется в три этапа:<br />
# Составляется таблица всех циклических сдвигов входной строки.<br />
# Производится лексикографическая (в алфавитном порядке) сортировка строк таблицы.<br />
# В качестве выходной строки выбирается последний столбец таблицы преобразования и номер строки, совпадающей с исходной.<br />
<br />
== Пример работы алгоритма ==<br />
<br />
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA". <br />
<br />
{| class="wikitable"<br />
!colspan="4"|Трансформация<br />
|-<br />
! Вход || Все<br />циклические <br /> сдвиги || Сортировка<br />строк || Выход<br />
|-<br />
|<br />
<font color="red">ABACABA</font><br />
|style="text-align:center;"|<br />
<font color="red">ABACABA</font> <br/><br />
BACABAA<br/><br />
ACABAAB<br/><br />
CABAABA<br/><br />
ABAABAC<br/><br />
BAABACA<br/><br />
AABACAB<br/><br />
|style="text-align:center;"|<br />
AABACAB<br/><br />
ABAABAC<br/><br />
<font color="red">ABACABA</font><br/><br />
ACABAAB<br/><br />
BAABACA<br/><br />
BACABAA<br/><br />
CABAABA <br/><br />
|<br />
BCABAAA, 3<br />
|}<br />
<br />
Результат можно записать так: <tex>$BWT(s) = $(</tex>"BCABAAA", <tex>3)</tex>, где <tex>3</tex> {{---}} номер исходной строки в отсортированной матрице. Он нужен для обратного преобразования. <br />
<br />
<br />
Следует заметить, что иногда в исходной строке приводится так называемый символ конца строки <tex>\$</tex>, который в преобразовании будет считаться последним (максимальным) символом, тогда сохранение номера исходной строки не требуется.<br />
<br />
<br />
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA$".<br />
<br />
{| class="wikitable"<br />
!colspan="4"|Трансформация<br />
|-<br />
! Вход || Все<br />Перестановки || Сортировка<br />Строк || Выход<br />
|-<br />
|<br />
<font color="red">ABACABA$</font><br />
|style="text-align:center;"|<br />
<font color="red">ABACABA$</font><br/><br />
BACABA$A<br/><br />
ACABA$AB<br/><br />
CABA$ABA<br/><br />
ABA$ABAC<br/><br />
BA$ABACA<br/><br />
A$ABACAB<br/><br />
$ABACABA<br />
|style="text-align:center;"|<br />
<font color="red">ABACABA$</font><br/><br />
ABA$ABAC<br/><br />
ACABA$AB<br/><br />
A$ABACAB<br/><br />
BACABA$A<br/><br />
BA$ABACA<br/><br />
CABA$ABA <br/><br />
$ABACABA<br />
|<br />
$CBBAAAA<br />
|} <br />
<br />
<br />
<br />
При аналогичном вышеприведённом преобразовании та строчка в матрице, которая будет заканчиваться на символ конца строки, и будет исходной: ("ABACABA$"). Тогда результат можно записать так: <tex>$BWT(s) =$</tex> "$CBBAAAA".<br />
<br />
== Обратное преобразование ==<br />
<br />
===Наивный алгоритм===<br />
<br />
Пусть нам дано: <tex>$BWT(s) =$(</tex>"BCABAAA", <tex>3)</tex>. Тогда выпишем в столбик нашу преобразованную последовательность символов "BCABAAA". Запишем её как последний столбик предыдущей матрицы (при прямом преобразовании Барроуза {{---}} Уилера), при этом все предыдущие столбцы оставляем пустыми. Далее построчно [[Сортировки | отсортируем]] матрицу, затем в предыдущий столбец запишем "BCABAAA". Опять построчно отсортируем матрицу. Продолжая таким образом, можно восстановить полный список всех циклических перестановок строки, которую нам надо найти. Выстроив полный отсортированный список перестановок, выберем строку с номером, который нам был изначально дан. В итоге мы получим искомую строку.<br />
Алгоритм обратного преобразования описан в таблице ниже:<br />
<br />
{| class="wikitable"<br />
!colspan="8"| Обратное преобразование<br />
|-<br />
!colspan="8"| Вход<br />
|-<br />
|align="center" colspan="8"|<br />
BCABAAA<br />
|-<br />
! Добавление 1 || Сортировка 1 || Добавление 2 || Сортировка 2 || Добавление 3 || Сортировка 3 || Добавление 4 <br />
|-align="right"<br />
|<br />
B<br />
C<br />
A<br />
B<br />
A<br />
A<br />
A<br />
|<br />
A<br />
A<br />
A<br />
A<br />
B<br />
B<br />
C<br />
|<br />
BA<br />
CA<br />
AA<br />
BA<br />
AB<br />
AB<br />
AC<br />
|<br />
AA<br />
AB<br />
AB<br />
AC<br />
BA<br />
BA<br />
CA<br />
|<br />
BAA<br />
CAB<br />
AAB<br />
BAC<br />
ABA<br />
ABA<br />
ACA<br />
|<br />
AAB<br />
ABA<br />
ABA<br />
ACA<br />
BAA<br />
BAC<br />
CAB<br />
|<br />
BAAB<br />
CABA<br />
AABA<br />
BACA<br />
ABAA<br />
ABAC<br />
ACAB<br />
|-<br />
! Сортировка 4 || Добавление 5 || Сортировка 5 || Добавление 6 || Сортировка 6 || Добавление 7 || Сортировка 7<br />
<br />
|-align="right"<br />
|<br />
AABA<br />
ABAA<br />
ABAC<br />
ACAB<br />
BAAB<br />
BACA<br />
CABA<br />
|<br />
BAABA<br />
CABAA<br />
AABAC<br />
BACAB<br />
ABAAB<br />
ABACA<br />
ACABA<br />
|<br />
AABAC<br />
ABAAB<br />
ABACA<br />
ACABA<br />
BAABA<br />
BACAB<br />
CABAA<br />
|<br />
BAABAC<br />
CABAAB<br />
AABACA<br />
BACABA<br />
ABAABA<br />
ABACAB<br />
ACABAA<br />
|<br />
AABACA<br />
ABAABA<br />
ABACAB<br />
ACABAA<br />
BAABAC<br />
BACABA<br />
CABAAB<br />
|<br />
BAABACA<br />
CABAABA<br />
AABACAB<br />
BACABAA<br />
ABAABAC<br />
ABACABA<br />
ACABAAB<br />
|<br />
AABACAB<br />
ABAABAC<br />
<font color="red">ABACABA</font><br />
ACABAAB<br />
BAABACA<br />
BACABAA<br />
CABAABA<br />
|-<br />
<br />
!colspan="8"| Результат<br />
|-<br />
|align="center" colspan="8"|<br />
<font color="red">ABACABA</font><br />
|}<br />
<br />
Следует также заметить, что если нам было бы дано <tex>$BWT(s) = $</tex> "$CBBAAAA", то мы также получили бы нашу исходную строку, только с символом конца строки <tex>\$</tex> на конце: ABACABA$.<br />
<br />
Временная сложность данного алгоритма <tex>O(N^3\log{N}) </tex>, пространственная <tex>O(N^2)</tex>.<br />
<br />
====Доказательство корректности====<br />
<br />
Пусть дана строка <tex>$s$</tex>, к которой было применено преобразование BWT. Докажем, что при использовании наивного алгоритма на каждом шаге получающийся набор строк соответствует суффиксам циклических перестановок исходной строки, методом математической индукции.<br />
* '''База'''. Циклически сдвинем все строки исходной таблицы на <tex>1</tex> влево. Тогда в столбце <tex>n</tex> будут находиться символы, добавленные на первом шаге алгоритма, а в столбце <tex>n - 1</tex> символы, изначально стоявшие в таблице до первого шага алгоритма. Таким образом, полученные на первом шаге алгоритма строки являются суффиксами циклических перестановок строки <tex>$s$</tex>.<br />
* '''Предположение'''. Пусть на <tex>k</tex> шаге алгоритма все полученные строки являются суффиксами циклических перестановок строки <tex>$s$</tex>.<br />
* '''Переход'''. Рассмотрим <tex>k+1</tex>-ый шаг алгоритма. Все строки отсортированы, поэтому самый левый столбец совпадет с <tex>1</tex> столбцом исходной таблицы. Циклически сдвинем все строки исходной таблицы на <tex>n - k</tex> символов вправо. Теперь по предположению первые <tex>k</tex> символов справа в каждой строке совпадают у исходной таблицы и у таблицы, полученной в результате работы алгоритма. <tex>k</tex>-ые справа столбцы также совпадают. Добавленный на <tex>k+1</tex>-ом шаге столбец также совпадает с <tex>k+1</tex>-ым справа столбцом сдвинутой исходной таблицы, так как совпадает с последним столбцом исходной таблицы, которая была сдвинута на <tex>n-k</tex>.<br />
<br />
{| class="wikitable"<br />
!colspan="3" | <tex>$k+1$</tex> шаг алгоритма при <tex>$k=3$</tex><br />
|-<br />
! Исходная <br /> таблица || Сдвинутая <br /> таблица || Результат <br /> работы <br /> алгоритма<br />
|-<br />
|style="text-align:center;"|<br />
<font color="red">A</font><font color="green">ABA</font>CA<font color="blue">B</font><br/><br />
<font color="red">A</font><font color="green">BAA</font>BA<font color="blue">C</font><br/><br />
<font color="red">A</font><font color="green">BAC</font>AB<font color="blue">A</font><br/><br />
<font color="red">A</font><font color="green">CAB</font>AA<font color="blue">B</font><br/><br />
<font color="red">B</font><font color="green">AAB</font>AC<font color="blue">A</font><br/><br />
<font color="red">B</font><font color="green">ACA</font>BA<font color="blue">A</font><br/><br />
<font color="red">C</font><font color="green">ABA</font>AB<font color="blue">A</font><br />
|style="text-align:center;"|<br />
CA<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font><br/><br />
BA<font color="blue">C</font><font color="red">A</font><font color="green">BAA</font><br/><br />
AB<font color="blue">A</font><font color="red">A</font><font color="green">BAC</font><br/><br />
AA<font color="blue">B</font><font color="red">A</font><font color="green">CAB</font><br/><br />
AC<font color="blue">A</font><font color="red">B</font><font color="green">AAB</font><br/><br />
BA<font color="blue">A</font><font color="red">B</font><font color="green">ACA</font><br/><br />
AB<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font><br />
|style="text-align:right;"|<br />
<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font> <br/><br />
<font color="blue">C</font><font color="red">A</font><font color="green">BAA</font> <br/><br />
<font color="blue">A</font><font color="red">A</font><font color="green">BAC</font> <br/><br />
<font color="blue">B</font><font color="red">A</font><font color="green">CAB</font> <br/><br />
<font color="blue">A</font><font color="red">B</font><font color="green">AAB</font> <br/><br />
<font color="blue">A</font><font color="red">B</font><font color="green">ACA</font> <br/><br />
<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font> <br/><br />
|-<br />
|}<br />
<br />
Таким образом, поскольку на каждом шаге алгоритма получившиеся строки являлись суффиксами циклических перестановок <tex> $s$ </tex>, после последнего шага получившиеся строки будут совпадать с циклическими перестановками <tex> $s$ </tex>.<br />
<br />
===Оптимизированный наивный алгоритм===<br />
<br />
Наивный алгоритм можно оптимизировать. Заметим, что при каждом проявлении неизвестного столбца выполнялись одни и те же действия. Мы приписывали новый столбец и сортировали имеющиеся данные. На каждом шагу мы к строке, которая находилась на <tex> i </tex>-ом месте приписываем в начало <tex> i </tex> -ый элемент столбца входных данных. Пусть изначально мы знаем каким по порядку является приписанный нами в начало символ (то есть каким по порядку в столбце). И конечно же мы знаем исходя из предыдущего шага какое место занимала наша строка без этого первого символа (<tex> i </tex> -ое). Тогда несложно заметить, что при выполнении такой операции строка с номером <tex> i </tex> всегда будет перемещаться на позицию с номером <tex> j </tex>.<br />
<br />
{| class="wikitable"<br />
|0||а||&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;||р||9<br />
|-<br />
|1||а||||д||7<br />
|-<br />
|2||а|| ||a||0<br />
|-<br />
|3||а|| ||к||8<br />
|-<br />
|4||а|| ||р||10<br />
|-<br />
|5||б|| ||a||1<br />
|-<br />
|6||б|| ||a||2<br />
|-<br />
|7||д|| ||a||3<br />
|-<br />
|8||к|| ||a||4<br />
|-<br />
|9||р|| ||б||5<br />
|-<br />
|10||р|| ||б||6<br />
|}<br />
<br />
Здесь слева отсортированный данный столбец, чтобы мы знали, какое место в лексикографическом порядке занимает приписываемый нами символ среди всех элементов данного нам изначально столбца. Справа - изначально данный столбец и соответствующее ему число. Поскольку в нашем алгоритме новый столбец приписывается в начало, то мы из состояния <tex> i </tex> (левый столбец) переходим в состояние <tex> j </tex> (правый). Для того, чтобы восстановить строку, нам необходимо от последней такой цифры по пути из <tex> j </tex> в <tex> i </tex> восстановить строку.<br />
{|<br />
|<br />
{| class="wikitable"<br />
|6<br />
|→<br />
|10<br />
|→<br />
|4 <br />
|→<br />
|8<br />
|→ <br />
|3<br />
|→<br />
|7<br />
|→<br />
|1<br />
|→<br />
|5<br />
|→<br />
|9<br />
|→<br />
|0<br />
|→<br />
|2<br />
|-<br />
|а<br />
|<br />
|б<br />
|<br />
|р<br />
|<br />
|а<br />
|<br />
|к<br />
|<br />
|а<br />
|<br />
|д<br />
|<br />
|а<br />
|<br />
|б<br />
|<br />
|р<br />
|<br />
|а<br />
|}<br />
====Сложность оптимизированного алгоритма====<br />
Данный алгоритм работает за <tex>O(N\log{N})</tex> времени и требует <tex>O(N)</tex> памяти. Однако, если размер алфавита не очень большой, то для выяснения первого столбца матрицы можно использовать сортировку подсчетом, в этом случае алгоритм работает за <tex>O(N+M)</tex> действий и требует <tex>O(N+M)</tex> памяти, где <tex>M</tex> — размер алфавита.<br />
<br />
====Псевдокод оптимизированного алгоритма====<br />
Пусть <tex> N </tex> — количество символов во входной строке, <tex> M </tex> — количество символов в алфавите, <tex> k </tex> — номер исходной строки в матрице перестановок, <tex> s </tex> — входящая строка, <tex> count </tex> — массив для сортировки подсчетом, <tex> t </tex> — вектор обратного преобразования, <tex> x </tex> — номер данной нам строки в таблице.<br />
<br />
'''function''' reverseBWT(N : Int, M : Int, k : Int, s : String): Int[]<br />
<font color="green">// Cчитаем частоты символов</font><br />
'''for''' i = 0 .. M <br />
count[i] = 0<br />
'''for''' i = 0 .. N <br />
count[s[i]]++<br />
<font color="green">// Упорядочиваем символы, чтобы получить первый столбец исходной матрицы</font><br />
<font color="green">// count[i] указывает на первую позицию символа i в первом столбце</font><br />
sum = 0<br />
'''for''' i = 0 .. M<br />
sum = sum + count[i]<br />
count[i] = sum - count[i]<br />
<font color="green">// Cоздаем вектор обратного преобразования</font><br />
'''for''' i = 0 .. N<br />
t[count[s[i]]] = i<br />
count[s[i]]++<br />
<font color="green">// И восстанавливаем исходный текст</font><br />
j = t[x]<br />
'''for''' i = 0 .. N<br />
answer[i] = s[j]<br />
j = t[j]<br />
return answer<br />
<br />
====Доказательство корректности====<br />
<br />
Пусть текст <tex>T</tex> состоит из <tex>N + 1</tex> символов, занумерованных с нуля: <tex>T[0..N]</tex>. Буквы <tex>T[i]</tex> принадлежат некоторому алфавиту <tex>A</tex>. Лексикографический порядок (строгий) на строках из алфавита <tex>A</tex> будем обозначать <tex>\preceq (\prec)</tex>. Обозначим через <tex>S_{k}T</tex> циклический сдвиг текста <tex>T</tex> на <tex>k</tex> символов влево:<br />
:{|<br />
<tex> S_{k}T = T[(j + k) (\bmod\ N + 1)] </tex><br />
|}<br />
<br />
Существует перестановка <tex>p</tex> чисел <tex>\{0, ..., N\}</tex>, которая удовлетворяет условию: <br />
:{|<br />
<tex> S_{p(i)}T \preceq S_{p(i + 1)}T,\ i = 0, ..., N - 1\ \ \textbf{(1)}</tex><br />
|}<br />
<br />
Преобразование Барроуза-Уилера текста <tex>T</tex> есть текст <tex>B[0..N] = BW(T)</tex>, буквы которого заданы соотношением:<br />
:{|<br />
<tex>B[i] = S_{p(i)}T[N]</tex>, другими словами <tex>B[i] = S_{p(i) - 1}T[0] = T[(p(i) - 1) (\bmod\ N + 1)] \ \ \textbf{(2)}</tex><br />
|}<br />
<br />
Пусть <tex>\sigma</tex> {{---}} перестановка чисел <tex>\{0, ..., N\}</tex>, удовлетворяющая условию:<br />
:{|<br />
<tex>B_{\sigma(i)} \preceq B_{\sigma(i + 1)}</tex>, при <tex>i = 0, ..., N - 1\ \ \textbf{(3)}</tex>,<br />
|}<br />
и в случае равенства <tex>B_{\sigma(i)}</tex> и <tex>B_{\sigma(i + 1)}</tex> выполнено {{---}} <tex>\sigma(i) < \sigma(i + 1)</tex>. Перестановка однозначно определяется текстом <tex>B</tex> и ее можно посчитать за <tex>O(N)</tex>, используя сортировку подсчетом. Рассмотрим перестановку <tex>\sigma</tex> как отображение <tex>\sigma : \{0, ..., N\} \to \{0, ..., N\}</tex>. Пусть <tex>\sigma^{k}</tex> копмозиция <tex>k</tex> отображений <tex>\sigma^{k} = \sigma^{k - 1} \circ \sigma</tex>, где <tex>\sigma^{1} = \sigma, \sigma^{0} \equiv i</tex>.<br />
<br />
{{Теорема<br />
|statement=<br />
<br />
''При всех <tex>m = 1, ..., N + 1</tex> верны утверждения,<br />
:<tex>B_{\sigma(i)}...B_{\sigma^{m}(i)} \preceq B_{\sigma(i + 1)}...B_{\sigma^{m}(i + 1)}</tex>, при <tex>i = 0, ..., N - 1\ \ \textbf{(4)}</tex><br />
:<tex>B_iB_{\sigma(i)}...B_{\sigma^{m - 1}(i)} = S_{p(i) - 1}T[0..m - 1]</tex>, при <tex>i = 0, ..., N\ \ \textbf{(5)}</tex><br />
''<br />
<br />
|proof=<br />
<br />
Если лексикографически отсортировать буквы последнего столбца и поместить их в первый столбец, то получится таблица<br />
<br />
| class="wikitable" style="text-align:center"<br />
|-<br />
!Таблица<br />
|-<br />
|a||b||c<br />
|-<br />
|a||b||c<br />
|<br />
<br />
<br />
}}<br />
<br />
{{Теорема<br />
|statement=<br />
<br />
''Для восстановления исходного текста <tex>T</tex> из преобразования <tex>B</tex> достаточно знать число <tex>I</tex>, отвечающее условию <tex>p(I) = 0</tex>, другими словами <tex>S_{p(I)}T = T</tex>.''<br />
<br />
}}<br />
<br />
===Алгоритм за линейное время===<br />
<br />
Будем обозначать <tex>s^i</tex> <tex>i</tex>-ую циклическую перестановку <tex>$s$</tex>. Пусть <tex>s^0 = s_0 s_1 \ldots s_{n-1}</tex>, <tex>$BWT(s)$\;= L</tex> и <tex>L = L_0L_1\ldots L_{n-1}</tex>, <tex>I</tex> -- номер строки <tex>s^0</tex> в таблице. Предподсчитаем следующие величины:<br />
* Для каждого <tex>L_i</tex> количество символов на подстроке <tex>l_0, \ldots , l_{i-1}</tex>, равных <tex>L_i</tex><br />
* Для каждого уникального <tex>L_i</tex> количество символов в <tex>L</tex>, лексикографически меньших, чем <tex>L_i</tex><br />
<br />
Пример для <tex>$BWT(s) =$</tex> "BCABAAA":<br />
<br />
{| class="wikitable" <br />
!colspan="3" | Таблица первого предподсчёта<br />
|-<br />
! Позиция || Символ || Результат<br />
|-align="center"<br />
! 0 || B || 0<br />
|-<br />
! 1 || C || 0<br />
|-<br />
! 2 || A || 0<br />
|-<br />
! 3 || B || 1<br />
|-<br />
! 4 || A || 1<br />
|-<br />
! 5 || A || 2<br />
|-<br />
! 6 || A || 3<br />
|}<br />
<br />
{| class="wikitable"<br />
!colspan="2" | Таблица второго предподсчёта<br />
|-<br />
! Символ || Количество <br /> меньших<br />
|-align="center"<br />
! A || 0<br />
|-<br />
! B || 4<br />
|-<br />
! C || 6<br />
|}<br />
<br />
Для удобства пронумеруем известные нам данные:<br />
# <tex>L</tex>, последний столбец таблицы перестановок<br />
# <tex>I</tex>, номер строки <tex>$s$</tex> в таблице перестановок<br />
# Частота, с которой символ <tex>L_{i}</tex> встречается в подстроке <tex>l_0, \ldots , l_{i-1}</tex><br />
# Для каждого уникального символа количество лексикографически меньших символов в <tex>L</tex><br />
<br />
Символ <tex>s_{n-1}</tex> находится в строке <tex>L</tex> под номером <tex>I</tex>, так как в таблице строка <tex>s^0</tex> имела номер <tex>I</tex>. Найдём символ <tex>s_{n-2}</tex>.<br />
<br />
Символ <tex>s_{n-2}</tex> имеет в строке <tex>L</tex> тот же номер, что строка <tex>s^{n-1}</tex> имела в таблице перестановок: строка <tex>s^{n-1}</tex> начинается с символа <tex>s_{n-1}</tex>, <tex>s_{n-2}</tex> находится на 1 левее его и из-за циклического сдвига оказывается в последнем столбце. Нам известен символ <tex>s_{n-1}</tex>. Посчитаем, на каком месте в таблице будет стоять строка, начинающаяся с этого символа.<br />
<br />
Из 4 известно количество символов, меньших <tex>s_{n-1}</tex>. Все строки, начинающиеся с этих символов, стоят в таблице раньше <tex>s^{n-1}</tex>. Кроме того, в таблице есть строки, начинающиеся с того же символа, что и <tex>s^{n-1}</tex>. Из 3 известно, сколько их: если символ, равный <tex>s_{n-1}</tex>, встречался в <tex>L</tex> раньше, чем <tex>s_{n-1}</tex>, то в таблице строка, начинающаяся с этого символа, тоже стоит раньше строки, начинающейся с <tex>s_{n-1}</tex>, так как префикс строки, оканчивающейся на этот символ, меньше префикса строки, оканчивающейся на <tex>s_{n-1}</tex>.<br />
<br />
Тогда сумма этих двух величин является номером символа <tex>s_{n-2}</tex> в строке <tex>L</tex>. Зная <tex>s_{n-1}</tex> и <tex>s_{n-2}</tex>, аналогично найдём <tex>s_{n-3}\ldots s_0</tex>.<br />
<br />
Предподсчёт занимает <tex>O(n)</tex> времени, восстановление каждого из <tex>n</tex> символов занимает <tex>O(1)</tex> времени. Суммарное время работы алгоритма <tex>O(n)</tex>.<br />
<br />
Пример работы для <tex>$BWT(s) = ($</tex>"BCABAAA", 2<tex>)</tex> (нумерация с 0):<br />
* <tex>s^0 = .......</tex><br />
* <tex>s_6=L_2 = A</tex>. Тогда <tex>s^0=......</tex>A<br />
* Суммируем значения из двух таблиц: <tex>0+0=0</tex>, <tex>s_5=L_0=B</tex>, <tex>s^0=.....</tex>BA<br />
* Суммируем: <tex>0+4=4</tex>, <tex>s_4=L_4=A</tex>, <tex>s^0=....</tex>ABA<br />
* Суммируем: <tex>1+0=1</tex>, <tex>s_3=L_1=C</tex>, <tex>s^0=...</tex>CABA<br />
* Суммируем: <tex>0+6=6</tex>, <tex>s_2=L_6=A</tex>, <tex>s^0=..</tex>ACABA<br />
* Суммируем: <tex>3+0=3</tex>, <tex>s_2=L_3=B</tex>, <tex>s^0=.</tex>BACABA<br />
* Суммируем: <tex>1+4=5</tex>, <tex>s_2=L_5=A</tex>, <tex>s^0=</tex> ABACABA<br />
<br />
== Дополнительно ==<br />
<br />
* bzip2<ref>[https://ru.wikipedia.org/wiki/Bzip2 bzip2]</ref> использует преобразование Барроуза {{---}} Уилера для превращения последовательностей многократно чередующихся символов в строки одинаковых символов, затем применяет преобразование [[Преобразование_MTF | MTF]], и в конце кодирование Хаффмана.<br />
<br />
== См. также ==<br />
* [[Алгоритм_Хаффмана | Алгоритм Хаффмана]]<br />
* [[Алгоритмы_LZ77_и_LZ78 | Алгоритмы LZ77 и LZ78]]<br />
* [[Арифметическое_кодирование | Арифметическое кодирование]]<br />
<br />
== Источники информации ==<br />
*[http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%91%D0%B0%D1%80%D1%80%D0%BE%D1%83%D0%B7%D0%B0_%E2%80%94_%D0%A3%D0%B8%D0%BB%D0%B5%D1%80%D0%B0 Википедия: Преобразование Барроуза {{---}} Уилера]<br />
<br />
*[http://www.cs.karelia.ru/~aborod/inf/2010/schedule.php.ru cs.karelia.ru: Преобразование Барроуза {{---}} Уилера]<br />
<br />
== Примечания ==<br />
<references/><br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Алгоритмы сжатия ]]</div>Evarandhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%91%D0%B0%D1%80%D1%80%D0%BE%D1%83%D0%B7%D0%B0-%D0%A3%D0%B8%D0%BB%D0%B5%D1%80%D0%B0&diff=50188Преобразование Барроуза-Уилера2015-12-12T19:15:21Z<p>Evarand: Косметические изменения</p>
<hr />
<div><br />
'''Преобразование Барроуза {{---}} Уилера''' (англ. ''Burrows-Wheeler transform'') {{---}} алгоритм, используемый для предварительной обработки данных перед сжатием, разработанный для улучшения эффективности последующего кодирования. Преобразование Барроуза {{---}} Уилера меняет порядок символов во входной строке таким образом, что повторяющиеся подстроки образуют на выходе идущие подряд последовательности одинаковых символов.<br />
<br />
== Описание алгоритма ==<br />
<br />
Преобразование выполняется в три этапа:<br />
# Составляется таблица всех циклических сдвигов входной строки.<br />
# Производится лексикографическая (в алфавитном порядке) сортировка строк таблицы.<br />
# В качестве выходной строки выбирается последний столбец таблицы преобразования и номер строки, совпадающей с исходной.<br />
<br />
== Пример работы алгоритма ==<br />
<br />
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA". <br />
<br />
{| class="wikitable"<br />
!colspan="4"|Трансформация<br />
|-<br />
! Вход || Все<br />циклические <br /> сдвиги || Сортировка<br />строк || Выход<br />
|-<br />
|<br />
<font color="red">ABACABA</font><br />
|style="text-align:center;"|<br />
<font color="red">ABACABA</font> <br/><br />
BACABAA<br/><br />
ACABAAB<br/><br />
CABAABA<br/><br />
ABAABAC<br/><br />
BAABACA<br/><br />
AABACAB<br/><br />
|style="text-align:center;"|<br />
AABACAB<br/><br />
ABAABAC<br/><br />
<font color="red">ABACABA</font><br/><br />
ACABAAB<br/><br />
BAABACA<br/><br />
BACABAA<br/><br />
CABAABA <br/><br />
|<br />
BCABAAA, 3<br />
|}<br />
<br />
Результат можно записать так: <tex>$BWT(s) = $(</tex>"BCABAAA", <tex>3)</tex>, где <tex>3</tex> {{---}} номер исходной строки в отсортированной матрице. Он нужен для обратного преобразования. <br />
<br />
<br />
Следует заметить, что иногда в исходной строке приводится так называемый символ конца строки <tex>\$</tex>, который в преобразовании будет считаться последним (максимальным) символом, тогда сохранение номера исходной строки не требуется.<br />
<br />
<br />
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA$".<br />
<br />
{| class="wikitable"<br />
!colspan="4"|Трансформация<br />
|-<br />
! Вход || Все<br />Перестановки || Сортировка<br />Строк || Выход<br />
|-<br />
|<br />
<font color="red">ABACABA$</font><br />
|style="text-align:center;"|<br />
<font color="red">ABACABA$</font><br/><br />
BACABA$A<br/><br />
ACABA$AB<br/><br />
CABA$ABA<br/><br />
ABA$ABAC<br/><br />
BA$ABACA<br/><br />
A$ABACAB<br/><br />
$ABACABA<br />
|style="text-align:center;"|<br />
<font color="red">ABACABA$</font><br/><br />
ABA$ABAC<br/><br />
ACABA$AB<br/><br />
A$ABACAB<br/><br />
BACABA$A<br/><br />
BA$ABACA<br/><br />
CABA$ABA <br/><br />
$ABACABA<br />
|<br />
$CBBAAAA<br />
|} <br />
<br />
<br />
<br />
При аналогичном вышеприведённом преобразовании та строчка в матрице, которая будет заканчиваться на символ конца строки, и будет исходной: ("ABACABA$"). Тогда результат можно записать так: <tex>$BWT(s) =$</tex> "$CBBAAAA".<br />
<br />
== Обратное преобразование ==<br />
<br />
===Наивный алгоритм===<br />
<br />
Пусть нам дано: <tex>$BWT(s) =$(</tex>"BCABAAA", <tex>3)</tex>. Тогда выпишем в столбик нашу преобразованную последовательность символов "BCABAAA". Запишем её как последний столбик предыдущей матрицы (при прямом преобразовании Барроуза {{---}} Уилера), при этом все предыдущие столбцы оставляем пустыми. Далее построчно [[Сортировки | отсортируем]] матрицу, затем в предыдущий столбец запишем "BCABAAA". Опять построчно отсортируем матрицу. Продолжая таким образом, можно восстановить полный список всех циклических перестановок строки, которую нам надо найти. Выстроив полный отсортированный список перестановок, выберем строку с номером, который нам был изначально дан. В итоге мы получим искомую строку.<br />
Алгоритм обратного преобразования описан в таблице ниже:<br />
<br />
{| class="wikitable"<br />
!colspan="8"| Обратное преобразование<br />
|-<br />
!colspan="8"| Вход<br />
|-<br />
|align="center" colspan="8"|<br />
BCABAAA<br />
|-<br />
! Добавление 1 || Сортировка 1 || Добавление 2 || Сортировка 2 || Добавление 3 || Сортировка 3 || Добавление 4 <br />
|-align="right"<br />
|<br />
B<br />
C<br />
A<br />
B<br />
A<br />
A<br />
A<br />
|<br />
A<br />
A<br />
A<br />
A<br />
B<br />
B<br />
C<br />
|<br />
BA<br />
CA<br />
AA<br />
BA<br />
AB<br />
AB<br />
AC<br />
|<br />
AA<br />
AB<br />
AB<br />
AC<br />
BA<br />
BA<br />
CA<br />
|<br />
BAA<br />
CAB<br />
AAB<br />
BAC<br />
ABA<br />
ABA<br />
ACA<br />
|<br />
AAB<br />
ABA<br />
ABA<br />
ACA<br />
BAA<br />
BAC<br />
CAB<br />
|<br />
BAAB<br />
CABA<br />
AABA<br />
BACA<br />
ABAA<br />
ABAC<br />
ACAB<br />
|-<br />
! Сортировка 4 || Добавление 5 || Сортировка 5 || Добавление 6 || Сортировка 6 || Добавление 7 || Сортировка 7<br />
<br />
|-align="right"<br />
|<br />
AABA<br />
ABAA<br />
ABAC<br />
ACAB<br />
BAAB<br />
BACA<br />
CABA<br />
|<br />
BAABA<br />
CABAA<br />
AABAC<br />
BACAB<br />
ABAAB<br />
ABACA<br />
ACABA<br />
|<br />
AABAC<br />
ABAAB<br />
ABACA<br />
ACABA<br />
BAABA<br />
BACAB<br />
CABAA<br />
|<br />
BAABAC<br />
CABAAB<br />
AABACA<br />
BACABA<br />
ABAABA<br />
ABACAB<br />
ACABAA<br />
|<br />
AABACA<br />
ABAABA<br />
ABACAB<br />
ACABAA<br />
BAABAC<br />
BACABA<br />
CABAAB<br />
|<br />
BAABACA<br />
CABAABA<br />
AABACAB<br />
BACABAA<br />
ABAABAC<br />
ABACABA<br />
ACABAAB<br />
|<br />
AABACAB<br />
ABAABAC<br />
<font color="red">ABACABA</font><br />
ACABAAB<br />
BAABACA<br />
BACABAA<br />
CABAABA<br />
|-<br />
<br />
!colspan="8"| Результат<br />
|-<br />
|align="center" colspan="8"|<br />
<font color="red">ABACABA</font><br />
|}<br />
<br />
Следует также заметить, что если нам было бы дано <tex>$BWT(s) = $</tex> "$CBBAAAA", то мы также получили бы нашу исходную строку, только с символом конца строки <tex>\$</tex> на конце: ABACABA$.<br />
<br />
Временная сложность данного алгоритма <tex>O(N^3\log{N}) </tex>, пространственная <tex>O(N^2)</tex>.<br />
<br />
====Доказательство корректности====<br />
<br />
Пусть дана строка <tex>$s$</tex>, к которой было применено преобразование BWT. Докажем, что при использовании наивного алгоритма на каждом шаге получающийся набор строк соответствует суффиксам циклических перестановок исходной строки, методом математической индукции.<br />
* '''База'''. Циклически сдвинем все строки исходной таблицы на <tex>1</tex> влево. Тогда в столбце <tex>n</tex> будут находиться символы, добавленные на первом шаге алгоритма, а в столбце <tex>n - 1</tex> символы, изначально стоявшие в таблице до первого шага алгоритма. Таким образом, полученные на первом шаге алгоритма строки являются суффиксами циклических перестановок строки <tex>$s$</tex>.<br />
* '''Предположение'''. Пусть на <tex>k</tex> шаге алгоритма все полученные строки являются суффиксами циклических перестановок строки <tex>$s$</tex>.<br />
* '''Переход'''. Рассмотрим <tex>k+1</tex>-ый шаг алгоритма. Все строки отсортированы, поэтому самый левый столбец совпадет с <tex>1</tex> столбцом исходной таблицы. Циклически сдвинем все строки исходной таблицы на <tex>n - k</tex> символов вправо. Теперь по предположению первые <tex>k</tex> символов справа в каждой строке совпадают у исходной таблицы и у таблицы, полученной в результате работы алгоритма. <tex>k</tex>-ые справа столбцы также совпадают. Добавленный на <tex>k+1</tex>-ом шаге столбец также совпадает с <tex>k+1</tex>-ым справа столбцом сдвинутой исходной таблицы, так как совпадает с последним столбцом исходной таблицы, которая была сдвинута на <tex>n-k</tex>.<br />
<br />
{| class="wikitable"<br />
!colspan="3" | <tex>$k+1$</tex> шаг алгоритма при <tex>$k=3$</tex><br />
|-<br />
! Исходная <br /> таблица || Сдвинутая <br /> таблица || Результат <br /> работы <br /> алгоритма<br />
|-<br />
|style="text-align:center;"|<br />
<font color="red">A</font><font color="green">ABA</font>CA<font color="blue">B</font><br/><br />
<font color="red">A</font><font color="green">BAA</font>BA<font color="blue">C</font><br/><br />
<font color="red">A</font><font color="green">BAC</font>AB<font color="blue">A</font><br/><br />
<font color="red">A</font><font color="green">CAB</font>AA<font color="blue">B</font><br/><br />
<font color="red">B</font><font color="green">AAB</font>AC<font color="blue">A</font><br/><br />
<font color="red">B</font><font color="green">ACA</font>BA<font color="blue">A</font><br/><br />
<font color="red">C</font><font color="green">ABA</font>AB<font color="blue">A</font><br />
|style="text-align:center;"|<br />
CA<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font><br/><br />
BA<font color="blue">C</font><font color="red">A</font><font color="green">BAA</font><br/><br />
AB<font color="blue">A</font><font color="red">A</font><font color="green">BAC</font><br/><br />
AA<font color="blue">B</font><font color="red">A</font><font color="green">CAB</font><br/><br />
AC<font color="blue">A</font><font color="red">B</font><font color="green">AAB</font><br/><br />
BA<font color="blue">A</font><font color="red">B</font><font color="green">ACA</font><br/><br />
AB<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font><br />
|style="text-align:right;"|<br />
<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font> <br/><br />
<font color="blue">C</font><font color="red">A</font><font color="green">BAA</font> <br/><br />
<font color="blue">A</font><font color="red">A</font><font color="green">BAC</font> <br/><br />
<font color="blue">B</font><font color="red">A</font><font color="green">CAB</font> <br/><br />
<font color="blue">A</font><font color="red">B</font><font color="green">AAB</font> <br/><br />
<font color="blue">A</font><font color="red">B</font><font color="green">ACA</font> <br/><br />
<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font> <br/><br />
|-<br />
|}<br />
<br />
Таким образом, поскольку на каждом шаге алгоритма получившиеся строки являлись суффиксами циклических перестановок <tex> $s$ </tex>, после последнего шага получившиеся строки будут совпадать с циклическими перестановками <tex> $s$ </tex>.<br />
<br />
===Оптимизированный наивный алгоритм===<br />
<br />
Наивный алгоритм можно оптимизировать. Заметим, что при каждом проявлении неизвестного столбца выполнялись одни и те же действия. Мы приписывали новый столбец и сортировали имеющиеся данные. На каждом шагу мы к строке, которая находилась на <tex> i </tex>-ом месте приписываем в начало <tex> i </tex> -ый элемент столбца входных данных. Пусть изначально мы знаем каким по порядку является приписанный нами в начало символ (то есть каким по порядку в столбце). И конечно же мы знаем исходя из предыдущего шага какое место занимала наша строка без этого первого символа (<tex> i </tex> -ое). Тогда несложно заметить, что при выполнении такой операции строка с номером <tex> i </tex> всегда будет перемещаться на позицию с номером <tex> j </tex>.<br />
<br />
{| class="wikitable"<br />
|0||а||&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;||р||9<br />
|-<br />
|1||а||||д||7<br />
|-<br />
|2||а|| ||a||0<br />
|-<br />
|3||а|| ||к||8<br />
|-<br />
|4||а|| ||р||10<br />
|-<br />
|5||б|| ||a||1<br />
|-<br />
|6||б|| ||a||2<br />
|-<br />
|7||д|| ||a||3<br />
|-<br />
|8||к|| ||a||4<br />
|-<br />
|9||р|| ||б||5<br />
|-<br />
|10||р|| ||б||6<br />
|}<br />
<br />
Здесь слева отсортированный данный столбец, чтобы мы знали, какое место в лексикографическом порядке занимает приписываемый нами символ среди всех элементов данного нам изначально столбца. Справа - изначально данный столбец и соответствующее ему число. Поскольку в нашем алгоритме новый столбец приписывается в начало, то мы из состояния <tex> i </tex> (левый столбец) переходим в состояние <tex> j </tex> (правый). Для того, чтобы восстановить строку, нам необходимо от последней такой цифры по пути из <tex> j </tex> в <tex> i </tex> восстановить строку.<br />
{|<br />
|<br />
{| class="wikitable"<br />
|6<br />
|→<br />
|10<br />
|→<br />
|4 <br />
|→<br />
|8<br />
|→ <br />
|3<br />
|→<br />
|7<br />
|→<br />
|1<br />
|→<br />
|5<br />
|→<br />
|9<br />
|→<br />
|0<br />
|→<br />
|2<br />
|-<br />
|а<br />
|<br />
|б<br />
|<br />
|р<br />
|<br />
|а<br />
|<br />
|к<br />
|<br />
|а<br />
|<br />
|д<br />
|<br />
|а<br />
|<br />
|б<br />
|<br />
|р<br />
|<br />
|а<br />
|}<br />
====Сложность оптимизированного алгоритма====<br />
Данный алгоритм работает за <tex>O(N\log{N})</tex> времени и требует <tex>O(N)</tex> памяти. Однако, если размер алфавита не очень большой, то для выяснения первого столбца матрицы можно использовать сортировку подсчетом, в этом случае алгоритм работает за <tex>O(N+M)</tex> действий и требует <tex>O(N+M)</tex> памяти, где <tex>M</tex> — размер алфавита.<br />
<br />
====Псевдокод оптимизированного алгоритма====<br />
Пусть <tex> N </tex> — количество символов во входной строке, <tex> M </tex> — количество символов в алфавите, <tex> k </tex> — номер исходной строки в матрице перестановок, <tex> s </tex> — входящая строка, <tex> count </tex> — массив для сортировки подсчетом, <tex> t </tex> — вектор обратного преобразования, <tex> x </tex> — номер данной нам строки в таблице.<br />
<br />
function reverseBWT(N : Int, M : Int, k : Int, s : Stirng): Int[]<br />
<font color="green">// Cчитаем частоты символов</font><br />
'''for''' i = 0 .. M <br />
count[i] = 0<br />
'''for''' i = 0 .. N <br />
count[s[i]]++<br />
<font color="green">// Упорядочиваем символы, чтобы получить первый столбец исходной матрицы</font><br />
<font color="green">// count[i] указывает на первую позицию символа i в первом столбце</font><br />
sum = 0<br />
'''for''' i = 0 .. M<br />
sum = sum + count[i]<br />
count[i] = sum - count[i]<br />
<font color="green">// Cоздаем вектор обратного преобразования</font><br />
'''for''' i = 0 .. N<br />
t[count[s[i]]] = i<br />
count[s[i]]++<br />
<font color="green">// И восстанавливаем исходный текст</font><br />
j = t[x]<br />
'''for''' i = 0 .. N<br />
answer[i] = s[j]<br />
j = t[j]<br />
return answer<br />
<br />
====Доказательство корректности====<br />
<br />
Пусть текст <tex>T</tex> состоит из <tex>N + 1</tex> символов, занумерованных с нуля: <tex>T[0..N]</tex>. Буквы <tex>T[i]</tex> принадлежат некоторому алфавиту <tex>A</tex>. Лексикографический порядок (строгий) на строках из алфавита <tex>A</tex> будем обозначать <tex>\preceq (\prec)</tex>. Обозначим через <tex>S_{k}T</tex> циклический сдвиг текста <tex>T</tex> на <tex>k</tex> символов влево:<br />
:{|<br />
<tex> S_{k}T = T[(j + k) (\bmod\ N + 1)] </tex><br />
|}<br />
<br />
Существует перестановка <tex>p</tex> чисел <tex>\{0, ..., N\}</tex>, которая удовлетворяет условию: <br />
:{|<br />
<tex> S_{p(i)}T \preceq S_{p(i + 1)}T,\ i = 0, ..., N - 1\ \ \textbf{(1)}</tex><br />
|}<br />
<br />
Преобразование Барроуза-Уилера текста <tex>T</tex> есть текст <tex>B[0..N] = BW(T)</tex>, буквы которого заданы соотношением:<br />
:{|<br />
<tex>B[i] = S_{p(i)}T[N]</tex>, другими словами <tex>B[i] = S_{p(i) - 1}T[0] = T[(p(i) - 1) (\bmod\ N + 1)] \ \ \textbf{(2)}</tex><br />
|}<br />
<br />
Пусть <tex>\sigma</tex> {{---}} перестановка чисел <tex>\{0, ..., N\}</tex>, удовлетворяющая условию:<br />
:{|<br />
<tex>B_{\sigma(i)} \preceq B_{\sigma(i + 1)}</tex>, при <tex>i = 0, ..., N - 1\ \ \textbf{(3)}</tex>,<br />
|}<br />
и в случае равенства <tex>B_{\sigma(i)}</tex> и <tex>B_{\sigma(i + 1)}</tex> выполнено {{---}} <tex>\sigma(i) < \sigma(i + 1)</tex>. Перестановка однозначно определяется текстом <tex>B</tex> и ее можно посчитать за <tex>O(N)</tex>, используя сортировку подсчетом. Рассмотрим перестановку <tex>\sigma</tex> как отображение <tex>\sigma : \{0, ..., N\} \to \{0, ..., N\}</tex>. Пусть <tex>\sigma^{k}</tex> копмозиция <tex>k</tex> отображений <tex>\sigma^{k} = \sigma^{k - 1} \circ \sigma</tex>, где <tex>\sigma^{1} = \sigma, \sigma^{0} \equiv i</tex>.<br />
<br />
{{Теорема<br />
|statement=<br />
<br />
''При всех <tex>m = 1, ..., N + 1</tex> верны утверждения,<br />
:<tex>B_{\sigma(i)}...B_{\sigma^{m}(i)} \preceq B_{\sigma(i + 1)}...B_{\sigma^{m}(i + 1)}</tex>, при <tex>i = 0, ..., N - 1\ \ \textbf{(4)}</tex><br />
:<tex>B_iB_{\sigma(i)}...B_{\sigma^{m - 1}(i)} = S_{p(i) - 1}T[0..m - 1]</tex>, при <tex>i = 0, ..., N\ \ \textbf{(5)}</tex><br />
''<br />
<br />
|proof=<br />
<br />
Если лексикографически отсортировать буквы последнего столбца и поместить их в первый столбец, то получится таблица<br />
<br />
| class="wikitable" style="text-align:center"<br />
|-<br />
!Таблица<br />
|-<br />
|a||b||c<br />
|-<br />
|a||b||c<br />
|<br />
<br />
<br />
}}<br />
<br />
{{Теорема<br />
|statement=<br />
<br />
''Для восстановления исходного текста <tex>T</tex> из преобразования <tex>B</tex> достаточно знать число <tex>I</tex>, отвечающее условию <tex>p(I) = 0</tex>, другими словами <tex>S_{p(I)}T = T</tex>.''<br />
<br />
}}<br />
<br />
===Алгоритм за линейное время===<br />
<br />
Будем обозначать <tex>s^i</tex> <tex>i</tex>-ую циклическую перестановку <tex>$s$</tex>. Пусть <tex>s^0 = s_0 s_1 \ldots s_{n-1}</tex>, <tex>$BWT(s)$\;= L</tex> и <tex>L = L_0L_1\ldots L_{n-1}</tex>, <tex>I</tex> -- номер строки <tex>s^0</tex> в таблице. Предподсчитаем следующие величины:<br />
* Для каждого <tex>L_i</tex> количество символов на подстроке <tex>l_0, \ldots , l_{i-1}</tex>, равных <tex>L_i</tex><br />
* Для каждого уникального <tex>L_i</tex> количество символов в <tex>L</tex>, лексикографически меньших, чем <tex>L_i</tex><br />
<br />
Пример для <tex>$BWT(s) =$</tex> "BCABAAA":<br />
<br />
{| class="wikitable" <br />
!colspan="3" | Таблица первого предподсчёта<br />
|-<br />
! Позиция || Символ || Результат<br />
|-align="center"<br />
! 0 || B || 0<br />
|-<br />
! 1 || C || 0<br />
|-<br />
! 2 || A || 0<br />
|-<br />
! 3 || B || 1<br />
|-<br />
! 4 || A || 1<br />
|-<br />
! 5 || A || 2<br />
|-<br />
! 6 || A || 3<br />
|}<br />
<br />
{| class="wikitable"<br />
!colspan="2" | Таблица второго предподсчёта<br />
|-<br />
! Символ || Количество <br /> меньших<br />
|-align="center"<br />
! A || 0<br />
|-<br />
! B || 4<br />
|-<br />
! C || 6<br />
|}<br />
<br />
Для удобства пронумеруем известные нам данные:<br />
# <tex>L</tex>, последний столбец таблицы перестановок<br />
# <tex>I</tex>, номер строки <tex>$s$</tex> в таблице перестановок<br />
# Частота, с которой символ <tex>L_{i}</tex> встречается в подстроке <tex>l_0, \ldots , l_{i-1}</tex><br />
# Для каждого уникального символа количество лексикографически меньших символов в <tex>L</tex><br />
<br />
Символ <tex>s_{n-1}</tex> находится в строке <tex>L</tex> под номером <tex>I</tex>, так как в таблице строка <tex>s^0</tex> имела номер <tex>I</tex>. Найдём символ <tex>s_{n-2}</tex>.<br />
<br />
Символ <tex>s_{n-2}</tex> имеет в строке <tex>L</tex> тот же номер, что строка <tex>s^{n-1}</tex> имела в таблице перестановок: строка <tex>s^{n-1}</tex> начинается с символа <tex>s_{n-1}</tex>, <tex>s_{n-2}</tex> находится на 1 левее его и из-за циклического сдвига оказывается в последнем столбце. Нам известен символ <tex>s_{n-1}</tex>. Посчитаем, на каком месте в таблице будет стоять строка, начинающаяся с этого символа.<br />
<br />
Из 4 известно количество символов, меньших <tex>s_{n-1}</tex>. Все строки, начинающиеся с этих символов, стоят в таблице раньше <tex>s^{n-1}</tex>. Кроме того, в таблице есть строки, начинающиеся с того же символа, что и <tex>s^{n-1}</tex>. Из 3 известно, сколько их: если символ, равный <tex>s_{n-1}</tex>, встречался в <tex>L</tex> раньше, чем <tex>s_{n-1}</tex>, то в таблице строка, начинающаяся с этого символа, тоже стоит раньше строки, начинающейся с <tex>s_{n-1}</tex>, так как префикс строки, оканчивающейся на этот символ, меньше префикса строки, оканчивающейся на <tex>s_{n-1}</tex>.<br />
<br />
Тогда сумма этих двух величин является номером символа <tex>s_{n-2}</tex> в строке <tex>L</tex>. Зная <tex>s_{n-1}</tex> и <tex>s_{n-2}</tex>, аналогично найдём <tex>s_{n-3}\ldots s_0</tex>.<br />
<br />
Предподсчёт занимает <tex>O(n)</tex> времени, восстановление каждого из <tex>n</tex> символов занимает <tex>O(1)</tex> времени. Суммарное время работы алгоритма <tex>O(n)</tex>.<br />
<br />
Пример работы для <tex>$BWT(s) = ($</tex>"BCABAAA", 2<tex>)</tex> (нумерация с 0):<br />
* <tex>s^0 = .......</tex><br />
* <tex>s_6=L_2 = A</tex>. Тогда <tex>s^0=......</tex>A<br />
* Суммируем значения из двух таблиц: <tex>0+0=0</tex>, <tex>s_5=L_0=B</tex>, <tex>s^0=.....</tex>BA<br />
* Суммируем: <tex>0+4=4</tex>, <tex>s_4=L_4=A</tex>, <tex>s^0=....</tex>ABA<br />
* Суммируем: <tex>1+0=1</tex>, <tex>s_3=L_1=C</tex>, <tex>s^0=...</tex>CABA<br />
* Суммируем: <tex>0+6=6</tex>, <tex>s_2=L_6=A</tex>, <tex>s^0=..</tex>ACABA<br />
* Суммируем: <tex>3+0=3</tex>, <tex>s_2=L_3=B</tex>, <tex>s^0=.</tex>BACABA<br />
* Суммируем: <tex>1+4=5</tex>, <tex>s_2=L_5=A</tex>, <tex>s^0=</tex> ABACABA<br />
<br />
== Дополнительно ==<br />
<br />
* bzip2<ref>[https://ru.wikipedia.org/wiki/Bzip2 bzip2]</ref> использует преобразование Барроуза {{---}} Уилера для превращения последовательностей многократно чередующихся символов в строки одинаковых символов, затем применяет преобразование [[Преобразование_MTF | MTF]], и в конце кодирование Хаффмана.<br />
<br />
== См. также ==<br />
* [[Алгоритм_Хаффмана | Алгоритм Хаффмана]]<br />
* [[Алгоритмы_LZ77_и_LZ78 | Алгоритмы LZ77 и LZ78]]<br />
* [[Арифметическое_кодирование | Арифметическое кодирование]]<br />
<br />
== Источники информации ==<br />
*[http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%91%D0%B0%D1%80%D1%80%D0%BE%D1%83%D0%B7%D0%B0_%E2%80%94_%D0%A3%D0%B8%D0%BB%D0%B5%D1%80%D0%B0 Википедия: Преобразование Барроуза {{---}} Уилера]<br />
<br />
*[http://www.cs.karelia.ru/~aborod/inf/2010/schedule.php.ru cs.karelia.ru: Преобразование Барроуза {{---}} Уилера]<br />
<br />
== Примечания ==<br />
<references/><br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Алгоритмы сжатия ]]</div>Evarandhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%91%D0%B0%D1%80%D1%80%D0%BE%D1%83%D0%B7%D0%B0-%D0%A3%D0%B8%D0%BB%D0%B5%D1%80%D0%B0&diff=50159Преобразование Барроуза-Уилера2015-12-06T19:37:19Z<p>Evarand: Таблицы</p>
<hr />
<div>== Определение ==<br />
<br />
'''Преобразование Барроуза {{---}} Уилера''' (англ. ''Burrows-Wheeler transform'') {{---}} алгоритм, используемый для предварительной обработки данных перед сжатием, разработанный для улучшения эффективности последующего кодирования. Преобразование Барроуза {{---}} Уилера меняет порядок символов во входной строке таким образом, что повторяющиеся подстроки образуют на выходе идущие подряд последовательности одинаковых символов.<br />
<br />
== Описание алгоритма ==<br />
<br />
Преобразование выполняется в три этапа. <br />
* Составляется таблица всех циклических сдвигов входной строки.<br />
* Производится лексикографическая (в алфавитном порядке) сортировка строк таблицы.<br />
* В качестве выходной строки выбирается последний столбец таблицы преобразования и номер строки, совпадающей с исходной.<br />
<br />
== Пример работы алгоритма ==<br />
<br />
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA". <br />
<br />
{| class="wikitable"<br />
!colspan="4"|Трансформация<br />
|-<br />
! Вход || Все<br />перестановки || Сортировка<br />строк || Выход<br />
|-<br />
|<br />
<font color="red">ABACABA</font><br />
|style="text-align:center;"|<br />
<font color="red">ABACABA</font> <br/><br />
BACABAA<br/><br />
ACABAAB<br/><br />
CABAABA<br/><br />
ABAABAC<br/><br />
BAABACA<br/><br />
AABACAB<br/><br />
|style="text-align:center;"|<br />
AABACAB<br/><br />
ABAABAC<br/><br />
<font color="red">ABACABA</font><br/><br />
ACABAAB<br/><br />
BAABACA<br/><br />
BACABAA<br/><br />
CABAABA <br/><br />
|<br />
BCABAAA, 3<br />
|}<br />
<br />
Результат можно записать так: <tex>$BWT(s) = $(</tex>"BCABAAA", <tex>3)</tex>, где <tex>3</tex> {{---}} номер исходной строки в отсортированной матрице. Он нужен для обратного преобразования. <br />
<br />
<br />
Следует заметить, что иногда в исходной строке приводится так называемый символ конца строки <tex>\$</tex>, который в преобразовании будет считаться последним (максимальным) символом, тогда сохранение номера исходной строки не требуется.<br />
<br />
<br />
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA$".<br />
<br />
{| class="wikitable"<br />
!colspan="4"|Трансформация<br />
|-<br />
! Вход || Все<br />Перестановки || Сортировка<br />Строк || Выход<br />
|-<br />
|<br />
<font color="red">ABACABA$</font><br />
|style="text-align:center;"|<br />
<font color="red">ABACABA$</font><br/><br />
BACABA$A<br/><br />
ACABA$AB<br/><br />
CABA$ABA<br/><br />
ABA$ABAC<br/><br />
BA$ABACA<br/><br />
A$ABACAB<br/><br />
$ABACABA<br />
|style="text-align:center;"|<br />
<font color="red">ABACABA$</font><br/><br />
ABA$ABAC<br/><br />
ACABA$AB<br/><br />
A$ABACAB<br/><br />
BACABA$A<br/><br />
BA$ABACA<br/><br />
CABA$ABA <br/><br />
$ABACABA<br />
|<br />
$CBBAAAA<br />
|} <br />
<br />
<br />
<br />
При аналогичном вышеприведённом преобразовании та строчка в матрице, которая будет заканчиваться на символ конца строки, и будет исходной: ("ABACABA$"). Тогда результат можно записать так: <tex>$BWT(s) =$</tex> "$CBBAAAA".<br />
<br />
== Обратное преобразование ==<br />
<br />
===Наивный алгоритм===<br />
<br />
Пусть нам дано: <tex>$BWT(s) =$(</tex>"BCABAAA", <tex>3)</tex>. Тогда выпишем в столбик нашу преобразованную последовательность символов "BCABAAA". Запишем её как последний столбик предыдущей матрицы (при прямом преобразовании Барроуза {{---}} Уилера), при этом все предыдущие столбцы оставляем пустыми. Далее построчно отсортируем матрицу, затем в предыдущий столбец запишем "BCABAAA". Опять построчно отсортируем матрицу. Продолжая таким образом, можно восстановить полный список всех циклических перестановок строки, которую нам надо найти. Выстроив полный отсортированный список перестановок, выберем строку с номером, который нам был изначально дан. В итоге мы получим искомую строку.<br />
Алгоритм обратного преобразования описан в таблице ниже:<br />
<br />
{| class="wikitable"<br />
!colspan="8"| Обратное преобразование<br />
|-<br />
!colspan="8"| Вход<br />
|-<br />
|align="center" colspan="8"|<br />
BCABAAA<br />
|-<br />
! Добавление 1 || Сортировка 1 || Добавление 2 || Сортировка 2 || Добавление 3 || Сортировка 3 || Добавление 4 <br />
|-align="right"<br />
|<br />
B<br />
C<br />
A<br />
B<br />
A<br />
A<br />
A<br />
|<br />
A<br />
A<br />
A<br />
A<br />
B<br />
B<br />
C<br />
|<br />
BA<br />
CA<br />
AA<br />
BA<br />
AB<br />
AB<br />
AC<br />
|<br />
AA<br />
AB<br />
AB<br />
AC<br />
BA<br />
BA<br />
CA<br />
|<br />
BAA<br />
CAB<br />
AAB<br />
BAC<br />
ABA<br />
ABA<br />
ACA<br />
|<br />
AAB<br />
ABA<br />
ABA<br />
ACA<br />
BAA<br />
BAC<br />
CAB<br />
|<br />
BAAB<br />
CABA<br />
AABA<br />
BACA<br />
ABAA<br />
ABAC<br />
ACAB<br />
|-<br />
! Сортировка 4 || Добавление 5 || Сортировка 5 || Добавление 6 || Сортировка 6 || Добавление 7 || Сортировка 7<br />
<br />
|-align="right"<br />
|<br />
AABA<br />
ABAA<br />
ABAC<br />
ACAB<br />
BAAB<br />
BACA<br />
CABA<br />
|<br />
BAABA<br />
CABAA<br />
AABAC<br />
BACAB<br />
ABAAB<br />
ABACA<br />
ACABA<br />
|<br />
AABAC<br />
ABAAB<br />
ABACA<br />
ACABA<br />
BAABA<br />
BACAB<br />
CABAA<br />
|<br />
BAABAC<br />
CABAAB<br />
AABACA<br />
BACABA<br />
ABAABA<br />
ABACAB<br />
ACABAA<br />
|<br />
AABACA<br />
ABAABA<br />
ABACAB<br />
ACABAA<br />
BAABAC<br />
BACABA<br />
CABAAB<br />
|<br />
BAABACA<br />
CABAABA<br />
AABACAB<br />
BACABAA<br />
ABAABAC<br />
ABACABA<br />
ACABAAB<br />
|<br />
AABACAB<br />
ABAABAC<br />
<font color="red">ABACABA</font><br />
ACABAAB<br />
BAABACA<br />
BACABAA<br />
CABAABA<br />
|-<br />
<br />
!colspan="8"| Результат<br />
|-<br />
|align="center" colspan="8"|<br />
<font color="red">ABACABA</font><br />
|}<br />
<br />
Следует также заметить, что если нам было бы дано <tex>$BWT(s) = $</tex> "$CBBAAAA", то мы также получили бы нашу исходную строку, только с символом конца строки <tex>\$</tex> на конце: ABACABA$.<br />
<br />
Временная сложность данного алгоритма <tex>O(N^3\log{N}) </tex>, пространственная <tex>O(N^2)</tex>.<br />
<br />
====Доказательство корректности====<br />
<br />
Пусть дана строка <tex>$s$</tex>, к которой было применено преобразование BWT. Докажем, что при использовании наивного алгоритма на каждом шаге получающийся набор строк соответствует суффиксам циклических перестановок исходной строки, методом математической индукции.<br />
* База. Циклически сдвинем все строки исходной таблицы на <tex>1</tex> влево. Тогда в столбце <tex>n</tex> будут находиться символы, добавленные на первом шаге алгоритма, а в столбце <tex>n - 1</tex> символы, изначально стоявшие в таблице до первого шага алгоритма. Таким образом, полученные на первом шаге алгоритма строки являются суффиксами циклических перестановок строки <tex>$s$</tex>.<br />
* Предположение. Пусть на <tex>k</tex> шаге алгоритма все полученные строки являются суффиксами циклических перестановок строки <tex>$s$</tex>.<br />
* Переход. Рассмотрим <tex>k+1</tex>-ый шаг алгоритма. Все строки отсортированы, поэтому самый левый столбец совпадет с <tex>1</tex> столбцом исходной таблицы. Циклически сдвинем все строки исходной таблицы на <tex>n - k</tex> символов вправо. Теперь по предположению первые <tex>k</tex> символов справа в каждой строке совпадают у исходной таблицы и у таблицы, полученной в результате работы алгоритма. <tex>k</tex>-ые справа столбцы также совпадают. Добавленный на <tex>k+1</tex>-ом шаге столбец также совпадает с <tex>k+1</tex>-ым справа столбцом сдвинутой исходной таблицы, так как совпадает с последним столбцом исходной таблицы, которая была сдвинута на <tex>n-k</tex>.<br />
<br />
{| class="wikitable"<br />
!colspan="3" | <tex>$k+1$</tex> шаг алгоритма при <tex>$k=3$</tex><br />
|-<br />
! Исходная <br /> таблица || Сдвинутая <br /> таблица || Результат <br /> работы <br /> алгоритма<br />
|-<br />
|style="text-align:center;"|<br />
<font color="red">A</font><font color="green">ABA</font>CA<font color="blue">B</font><br/><br />
<font color="red">A</font><font color="green">BAA</font>BA<font color="blue">C</font><br/><br />
<font color="red">A</font><font color="green">BAC</font>AB<font color="blue">A</font><br/><br />
<font color="red">A</font><font color="green">CAB</font>AA<font color="blue">B</font><br/><br />
<font color="red">B</font><font color="green">AAB</font>AC<font color="blue">A</font><br/><br />
<font color="red">B</font><font color="green">ACA</font>BA<font color="blue">A</font><br/><br />
<font color="red">C</font><font color="green">ABA</font>AB<font color="blue">A</font><br />
|style="text-align:center;"|<br />
CA<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font><br/><br />
BA<font color="blue">C</font><font color="red">A</font><font color="green">BAA</font><br/><br />
AB<font color="blue">A</font><font color="red">A</font><font color="green">BAC</font><br/><br />
AA<font color="blue">B</font><font color="red">A</font><font color="green">CAB</font><br/><br />
AC<font color="blue">A</font><font color="red">B</font><font color="green">AAB</font><br/><br />
BA<font color="blue">A</font><font color="red">B</font><font color="green">ACA</font><br/><br />
AB<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font><br />
|style="text-align:right;"|<br />
<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font> <br/><br />
<font color="blue">C</font><font color="red">A</font><font color="green">BAA</font> <br/><br />
<font color="blue">A</font><font color="red">A</font><font color="green">BAC</font> <br/><br />
<font color="blue">B</font><font color="red">A</font><font color="green">CAB</font> <br/><br />
<font color="blue">A</font><font color="red">B</font><font color="green">AAB</font> <br/><br />
<font color="blue">A</font><font color="red">B</font><font color="green">ACA</font> <br/><br />
<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font> <br/><br />
|-<br />
|}<br />
<br />
Таким образом, поскольку на каждом шаге алгоритма получившиеся строки являлись суффиксами циклических перестановок <tex> $s$ </tex>, после последнего шага получившиеся строки будут совпадать с циклическими перестановками <tex> $s$ </tex>.<br />
<br />
===Оптимизированный наивный алгоритм===<br />
<br />
Наивный алгоритм можно оптимизировать. Заметим, что при каждом проявлении неизвестного столбца выполнялись одни и те же действия. Мы приписывали новый столбец и сортировали имеющиеся данные. На каждом шагу мы к строке, которая находилась на <tex> i </tex>-ом месте приписываем в начало <tex> i </tex> -ый элемент столбца входных данных. Пусть изначально мы знаем каким по порядку является приписанный нами в начало символ (то есть каким по порядку в столбце). И конечно же мы знаем исходя из предыдущего шага какое место занимала наша строка без этого первого символа (<tex> i </tex> -ое). Тогда несложно заметить, что при выполнении такой операции строка с номером <tex> i </tex> всегда будет перемещаться на позицию с номером <tex> j </tex>.<br />
<br />
{| class="wikitable"<br />
|0||а||&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;||р||9<br />
|-<br />
|1||а||||д||7<br />
|-<br />
|2||а|| ||a||0<br />
|-<br />
|3||а|| ||к||8<br />
|-<br />
|4||а|| ||р||10<br />
|-<br />
|5||б|| ||a||1<br />
|-<br />
|6||б|| ||a||2<br />
|-<br />
|7||д|| ||a||3<br />
|-<br />
|8||к|| ||a||4<br />
|-<br />
|9||р|| ||б||5<br />
|-<br />
|10||р|| ||б||6<br />
|}<br />
<br />
Здесь слева отсортированный данный столбец, чтобы мы знали, какое место в лексикографическом порядке занимает приписываемый нами символ среди всех элементов данного нам изначально столбца. Справа - изначально данный столбец и соответствующее ему число. Поскольку в нашем алгоритме новый столбец приписывается в начало, то мы из состояния <tex> i </tex> (левый столбец) переходим в состояние <tex> j </tex> (правый). Для того, чтобы восстановить строку, нам необходимо от последней такой цифры по пути из <tex> j </tex> в <tex> i </tex> восстановить строку.<br />
{|<br />
|<br />
{| class="wikitable"<br />
|6<br />
|→<br />
|10<br />
|→<br />
|4 <br />
|→<br />
|8<br />
|→ <br />
|3<br />
|→<br />
|7<br />
|→<br />
|1<br />
|→<br />
|5<br />
|→<br />
|9<br />
|→<br />
|0<br />
|→<br />
|2<br />
|-<br />
|а<br />
|<br />
|б<br />
|<br />
|р<br />
|<br />
|а<br />
|<br />
|к<br />
|<br />
|а<br />
|<br />
|д<br />
|<br />
|а<br />
|<br />
|б<br />
|<br />
|р<br />
|<br />
|а<br />
|}<br />
====Сложность оптимизированного алгоритма====<br />
Данный алгоритм работает за <tex>O(N\log{N})</tex> времени и требует <tex>O(N)</tex> памяти. Однако, если размер алфавита не очень большой, то для выяснения первого столбца матрицы можно использовать сортировку подсчетом, в этом случае алгоритм работает за <tex>O(N+M)</tex> действий и требует <tex>O(N+M)</tex> памяти, где <tex>M</tex> — размер алфавита.<br />
<br />
====Псевдокод оптимизированного алгоритма====<br />
Пусть <tex> N </tex> — количество символов во входной строке, <tex> M </tex> — количество символов в алфавите, <tex> k </tex> — номер исходной строки в матрице перестановок, <tex> s </tex> — входящая строка, <tex> count </tex> — массив для сортировки подсчетом, <tex> t </tex> — вектор обратного преобразования, <tex> x </tex> — номер данной нам строки в таблице.<br />
<br />
// Cчитаем частоты символов<br />
'''for''' i = 0 .. M <br />
count[i] = 0<br />
'''for''' i = 0 .. N <br />
count[s[i]]++<br />
// Упорядочиваем символы, чтобы получить первый столбец исходной матрицы<br />
// count[i] указывает на первую позицию символа i в первом столбце<br />
sum = 0<br />
'''for''' i = 0 .. M<br />
sum = sum + count[i]<br />
count[i] = sum - count[i]<br />
// Cоздаем вектор обратного преобразования<br />
'''for''' i = 0 .. N<br />
t[count[s[i]]] = i<br />
count[s[i]]++<br />
// И восстанавливаем исходный текст<br />
j = t[x]<br />
'''for''' i = 0 .. N<br />
'''print'''(s[j])<br />
j = t[j]<br />
<br />
====Доказательство корректности====<br />
<br />
Пусть текст <tex>T</tex> состоит из <tex>N + 1</tex> символов, занумерованных с нуля: <tex>T[0..N]</tex>. Буквы <tex>T[i]</tex> принадлежат некоторому алфавиту <tex>A</tex>. Лексикографический порядок (строгий) на строках из алфавита <tex>A</tex> будем обозначать <tex>\preceq (\prec)</tex>. Обозначим через <tex>S_{k}T</tex> циклический сдвиг текста <tex>T</tex> на <tex>k</tex> символов влево:<br />
:{|<br />
<tex> S_{k}T = T[(j + k) (mod\ N + 1)] </tex><br />
|}<br />
<br />
Существует перестановка <tex>p</tex> чисел <tex>\{0, ..., N\}</tex>, которая удовлетворяет условию: <br />
:{|<br />
<tex> S_{p(i)}T \preceq S_{p(i + 1)}T,\ i = 0, ..., N - 1\ \ \textbf{(1)}</tex><br />
|}<br />
<br />
Преобразование Барроуза-Уилера текста <tex>T</tex> есть текст <tex>B[0..N] = BW(T)</tex>, буквы которого заданы соотношением:<br />
:{|<br />
<tex>B[i] = S_{p(i)}T[N]</tex>, другими словами <tex>B[i] = S_{p(i) - 1}T[0] = T[(p(i) - 1) (mod\ N + 1)] \ \ \textbf{(2)}</tex><br />
|}<br />
<br />
Пусть <tex>\sigma</tex> {{---}} перестановка чисел <tex>\{0, ..., N\}</tex>, удовлетворяющая условию:<br />
:{|<br />
<tex>B_{\sigma(i)} \preceq B_{\sigma(i + 1)}</tex>, при <tex>i = 0, ..., N - 1\ \ \textbf{(3)}</tex>,<br />
|}<br />
и в случае равенства <tex>B_{\sigma(i)}</tex> и <tex>B_{\sigma(i + 1)}</tex> выполнено {{---}} <tex>\sigma(i) < \sigma(i + 1)</tex>. Перестановка однозначно определяется текстом <tex>B</tex> и ее можно посчитать за <tex>O(N)</tex>, используя сортировку подсчетом. Рассмотрим перестановку <tex>\sigma</tex> как отображение <tex>\sigma : \{0, ..., N\} \to \{0, ..., N\}</tex>. Пусть <tex>\sigma^{k}</tex> копмозиция <tex>k</tex> отображений <tex>\sigma^{k} = \sigma^{k - 1} \circ \sigma</tex>, где <tex>\sigma^{1} = \sigma, \sigma^{0} \equiv i</tex>.<br />
<br />
{{Теорема<br />
|statement=<br />
<br />
''При всех <tex>m = 1, ..., N + 1</tex> верны утверждения,<br />
:<tex>B_{\sigma(i)}...B_{\sigma^{m}(i)} \preceq B_{\sigma(i + 1)}...B_{\sigma^{m}(i + 1)}</tex>, при <tex>i = 0, ..., N - 1\ \ \textbf{(4)}</tex><br />
:<tex>B_iB_{\sigma(i)}...B_{\sigma^{m - 1}(i)} = S_{p(i) - 1}T[0..m - 1]</tex>, при <tex>i = 0, ..., N\ \ \textbf{(5)}</tex><br />
''<br />
<br />
|proof=<br />
<br />
Если лексикографически отсортировать буквы последнего столбца и поместить их в первый столбец, то получится таблица<br />
<br />
| class="wikitable" style="text-align:center"<br />
|-<br />
!Таблица<br />
|-<br />
|a||b||c<br />
|-<br />
|a||b||c<br />
|<br />
<br />
<br />
}}<br />
<br />
{{Теорема<br />
|statement=<br />
<br />
''Для восстановления исходного текста <tex>T</tex> из преобразования <tex>B</tex> достаточно знать число <tex>I</tex>, отвечающее условию <tex>p(I) = 0</tex>, другими словами <tex>S_{p(I)}T = T</tex>.''<br />
<br />
}}<br />
<br />
===Алгоритм за линейное время===<br />
<br />
Будем обозначать <tex>s^i</tex> <tex>i</tex>-ую циклическую перестановку <tex>$s$</tex>. Пусть <tex>s^0 = s_0 s_1 \ldots s_{n-1}</tex>, <tex>$BWT(s)$\;= L</tex> и <tex>L = L_0L_1\ldots L_{n-1}</tex>, <tex>I</tex> - номер строки <tex>s^0</tex> в таблице. Предподсчитаем следующие величины:<br />
* Для каждого <tex>L_i</tex> количество символов на подстроке <tex>L_0 \ldots L_{i-1}</tex>, равных <tex>L_i</tex><br />
* Для каждого уникального <tex>L_i</tex> количество символов в <tex>L</tex>, лексикографически меньших, чем <tex>L_i</tex><br />
<br />
Пример для <tex>$BWT(s) =$</tex> "BCABAAA":<br />
<br />
{| class="wikitable" <br />
!colspan="3" | Таблица первого предподсчёта<br />
|-<br />
! Позиция || Символ || Результат<br />
|-align="center"<br />
! 0 || B || 0<br />
|-<br />
! 1 || C || 0<br />
|-<br />
! 2 || A || 0<br />
|-<br />
! 3 || B || 1<br />
|-<br />
! 4 || A || 1<br />
|-<br />
! 5 || A || 2<br />
|-<br />
! 6 || A || 3<br />
|}<br />
<br />
{| class="wikitable"<br />
!colspan="2" | Таблица второго предподсчёта<br />
|-<br />
! Символ || Количество <br /> меньших<br />
|-align="center"<br />
! A || 0<br />
|-<br />
! B || 4<br />
|-<br />
! C || 6<br />
|}<br />
<br />
Для удобства пронумеруем известные нам данные:<br />
# <tex>L</tex>, последний столбец таблицы перестановок<br />
# <tex>I</tex>, номер строки <tex>$s$</tex> в таблице перестановок<br />
# Частота, с которой символ <tex>L_{i}</tex> встречается в подстроке <tex>L_0\ldots L_{i-1}</tex><br />
# Для каждого уникального символа количество лексикографически меньших символов в <tex>L</tex><br />
<br />
Символ <tex>s_{n-1}</tex> находится в строке <tex>L</tex> под номером <tex>I</tex>, так как в таблице строка <tex>s^0</tex> имела номер <tex>I</tex>. Найдём символ <tex>s_{n-2}</tex>.<br />
<br />
Символ <tex>s_{n-2}</tex> имеет в строке <tex>L</tex> тот же номер, что строка <tex>s^{n-1}</tex> имела в таблице перестановок: строка <tex>s^{n-1}</tex> начинается с символа <tex>s_{n-1}</tex>, <tex>s_{n-2}</tex> находится на 1 левее его и из-за циклического сдвига оказывается в последнем столбце. Нам известен символ <tex>s_{n-1}</tex>. Посчитаем, на каком месте в таблице будет стоять строка, начинающаяся с этого символа.<br />
<br />
Из 4 известно количество символов, меньших <tex>s_{n-1}</tex>. Все строки, начинающиеся с этих символов, стоят в таблице раньше <tex>s^{n-1}</tex>. Кроме того, в таблице есть строки, начинающиеся с того же символа, что и <tex>s^{n-1}</tex>. Из 3 известно, сколько их: если символ, равный <tex>s_{n-1}</tex>, встречался в <tex>L</tex> раньше, чем <tex>s_{n-1}</tex>, то в таблице строка, начинающаяся с этого символа, тоже стоит раньше строки, начинающейся с <tex>s_{n-1}</tex>, так как префикс строки, оканчивающейся на этот символ, меньше префикса строки, оканчивающейся на <tex>s_{n-1}</tex>.<br />
<br />
Тогда сумма этих двух величин является номером символа <tex>s_{n-2}</tex> в строке <tex>L</tex>. Зная <tex>s_{n-1}</tex> и <tex>s_{n-2}</tex>, аналогично найдём <tex>s_{n-3}\ldots s_0</tex>.<br />
<br />
Предподсчёт занимает <tex>O(n)</tex> времени, восстановление каждого из <tex>n</tex> символов занимает <tex>O(1)</tex> времени. Суммарное время работы алгоритма <tex>O(n)</tex>.<br />
<br />
Пример работы для <tex>$BWT(s) = ($</tex>"BCABAAA", 2<tex>)</tex> (нумерация с 0):<br />
* <tex>s^0 = .......</tex><br />
* <tex>s_6=L_2 = A</tex>. Тогда <tex>s^0=......</tex>A<br />
* Суммируем значения из двух таблиц: <tex>0+0=0</tex>, <tex>s_5=L_0=B</tex>, <tex>s^0=.....</tex>BA<br />
* Суммируем: <tex>0+4=4</tex>, <tex>s_4=L_4=A</tex>, <tex>s^0=....</tex>ABA<br />
* Суммируем: <tex>1+0=1</tex>, <tex>s_3=L_1=C</tex>, <tex>s^0=...</tex>CABA<br />
* Суммируем: <tex>0+6=6</tex>, <tex>s_2=L_6=A</tex>, <tex>s^0=..</tex>ACABA<br />
* Суммируем: <tex>3+0=3</tex>, <tex>s_2=L_3=B</tex>, <tex>s^0=.</tex>BACABA<br />
* Суммируем: <tex>1+4=5</tex>, <tex>s_2=L_5=A</tex>, <tex>s^0=</tex> ABACABA<br />
<br />
== Дополнительно ==<br />
<br />
* bzip2 использует преобразование Барроуза {{---}} Уилера для превращения последовательностей многократно чередующихся символов в строки одинаковых символов, затем применяет преобразование MTF (англ. move-to-front), и в конце кодирование Хаффмана.<br />
<br />
== Источники информации ==<br />
*[http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%91%D0%B0%D1%80%D1%80%D0%BE%D1%83%D0%B7%D0%B0_%E2%80%94_%D0%A3%D0%B8%D0%BB%D0%B5%D1%80%D0%B0 Википедия: Преобразование Барроуза {{---}} Уилера]<br />
<br />
*[http://www.cs.karelia.ru/~aborod/inf/2010/schedule.php.ru cs.karelia.ru: Преобразование Барроуза {{---}} Уилера]<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Алгоритмы сжатия ]]</div>Evarandhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%91%D0%B0%D1%80%D1%80%D0%BE%D1%83%D0%B7%D0%B0-%D0%A3%D0%B8%D0%BB%D0%B5%D1%80%D0%B0&diff=50158Преобразование Барроуза-Уилера2015-12-06T19:12:42Z<p>Evarand: Косметические исправления</p>
<hr />
<div>== Определение ==<br />
<br />
'''Преобразование Барроуза {{---}} Уилера''' (англ. ''Burrows-Wheeler transform'') {{---}} алгоритм, используемый для предварительной обработки данных перед сжатием, разработанный для улучшения эффективности последующего кодирования. Преобразование Барроуза {{---}} Уилера меняет порядок символов во входной строке таким образом, что повторяющиеся подстроки образуют на выходе идущие подряд последовательности одинаковых символов.<br />
<br />
== Описание алгоритма ==<br />
<br />
Преобразование выполняется в три этапа. <br />
* Составляется таблица всех циклических сдвигов входной строки.<br />
* Производится лексикографическая (в алфавитном порядке) сортировка строк таблицы.<br />
* В качестве выходной строки выбирается последний столбец таблицы преобразования и номер строки, совпадающей с исходной.<br />
<br />
== Пример работы алгоритма ==<br />
<br />
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA". <br />
<br />
{| border="1"<br />
!colspan="4"|Трансформация<br />
|-<br />
! Вход || Все<br />Перестановки || Сортировка<br />Строк || Выход<br />
|-<br />
|<br />
<font color="red">ABACABA</font><br />
|<br />
<font color="red">ABACABA</font><br />
BACABAA<br />
ACABAAB<br />
CABAABA<br />
ABAABAC<br />
BAABACA<br />
AABACAB<br />
|<br />
AABACAB<br />
ABAABAC<br />
<font color="red">ABACABA</font><br />
ACABAAB<br />
BAABACA<br />
BACABAA<br />
CABAABA <br />
|<br />
BCABAAA, 3<br />
|}<br />
<br />
Результат можно записать так: <tex>$BWT(s) = $(</tex>"BCABAAA", <tex>3)</tex>, где <tex>3</tex> {{---}} номер исходной строки в отсортированной матрице. Он нужен для обратного преобразования. <br />
<br />
<br />
Следует заметить, что иногда в исходной строке приводится так называемый символ конца строки <tex>\$</tex>, который в преобразовании будет считаться последним (максимальным) символом, тогда сохранение номера исходной строки не требуется.<br />
<br />
<br />
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA$".<br />
<br />
{| border="1"<br />
!colspan="4"|Трансформация<br />
|-<br />
! Вход || Все<br />Перестановки || Сортировка<br />Строк || Выход<br />
|-<br />
|<br />
<font color="red">ABACABA$</font><br />
|<br />
<font color="red">ABACABA$</font><br />
BACABA$A<br />
ACABA$AB<br />
CABA$ABA<br />
ABA$ABAC<br />
BA$ABACA<br />
A$ABACAB<br />
$ABACABA<br />
<br />
|<br />
<font color="red">ABACABA$</font><br />
ABA$ABAC<br />
ACABA$AB<br />
A$ABACAB<br />
BACABA$A<br />
BA$ABACA<br />
CABA$ABA <br />
$ABACABA<br />
|<br />
$CBBAAAA<br />
|} <br />
<br />
<br />
<br />
При аналогичном вышеприведённом преобразовании та строчка в матрице, которая будет заканчиваться на символ конца строки, и будет исходной: ("ABACABA$"). Тогда результат можно записать так: <tex>$BWT(s) =$</tex> "$CBBAAAA".<br />
<br />
== Обратное преобразование ==<br />
<br />
===Наивный алгоритм===<br />
<br />
Пусть нам дано: <tex>$BWT(s) =$(</tex>"BCABAAA", <tex>3)</tex>. Тогда выпишем в столбик нашу преобразованную последовательность символов "BCABAAA". Запишем её как последний столбик предыдущей матрицы (при прямом преобразовании Барроуза {{---}} Уилера), при этом все предыдущие столбцы оставляем пустыми. Далее построчно отсортируем матрицу, затем в предыдущий столбец запишем "BCABAAA". Опять построчно отсортируем матрицу. Продолжая таким образом, можно восстановить полный список всех циклических перестановок строки, которую нам надо найти. Выстроив полный отсортированный список перестановок, выберем строку с номером, который нам был изначально дан. В итоге мы получим искомую строку.<br />
Алгоритм обратного преобразования описан в таблице ниже:<br />
<br />
{| border="1"<br />
!colspan="8"| Обратное преобразование<br />
|-<br />
!colspan="8"| Вход<br />
|-<br />
|align="center" colspan="8"|<br />
BCABAAA<br />
|-<br />
! Добавление 1 || Сортировка 1 || Добавление 2 || Сортировка 2 || Добавление 3 || Сортировка 3 || Добавление 4 <br />
|-align="right"<br />
|<br />
B<br />
C<br />
A<br />
B<br />
A<br />
A<br />
A<br />
|<br />
A<br />
A<br />
A<br />
A<br />
B<br />
B<br />
C<br />
|<br />
BA<br />
CA<br />
AA<br />
BA<br />
AB<br />
AB<br />
AC<br />
|<br />
AA<br />
AB<br />
AB<br />
AC<br />
BA<br />
BA<br />
CA<br />
|<br />
BAA<br />
CAB<br />
AAB<br />
BAC<br />
ABA<br />
ABA<br />
ACA<br />
|<br />
AAB<br />
ABA<br />
ABA<br />
ACA<br />
BAA<br />
BAC<br />
CAB<br />
|<br />
BAAB<br />
CABA<br />
AABA<br />
BACA<br />
ABAA<br />
ABAC<br />
ACAB<br />
|-<br />
! Сортировка 4 || Добавление 5 || Сортировка 5 || Добавление 6 || Сортировка 6 || Добавление 7 || Сортировка 7<br />
<br />
|-align="right"<br />
|<br />
AABA<br />
ABAA<br />
ABAC<br />
ACAB<br />
BAAB<br />
BACA<br />
CABA<br />
|<br />
BAABA<br />
CABAA<br />
AABAC<br />
BACAB<br />
ABAAB<br />
ABACA<br />
ACABA<br />
|<br />
AABAC<br />
ABAAB<br />
ABACA<br />
ACABA<br />
BAABA<br />
BACAB<br />
CABAA<br />
|<br />
BAABAC<br />
CABAAB<br />
AABACA<br />
BACABA<br />
ABAABA<br />
ABACAB<br />
ACABAA<br />
|<br />
AABACA<br />
ABAABA<br />
ABACAB<br />
ACABAA<br />
BAABAC<br />
BACABA<br />
CABAAB<br />
|<br />
BAABACA<br />
CABAABA<br />
AABACAB<br />
BACABAA<br />
ABAABAC<br />
ABACABA<br />
ACABAAB<br />
|<br />
AABACAB<br />
ABAABAC<br />
<font color="red">ABACABA</font><br />
ACABAAB<br />
BAABACA<br />
BACABAA<br />
CABAABA<br />
|-<br />
<br />
!colspan="8"| Результат<br />
|-<br />
|align="center" colspan="8"|<br />
<font color="red">ABACABA</font><br />
|}<br />
<br />
Следует также заметить, что если нам было бы дано <tex>$BWT(s) = $</tex> "$CBBAAAA", то мы также получили бы нашу исходную строку, только с символом конца строки <tex>\$</tex> на конце: ABACABA$.<br />
<br />
Временная сложность данного алгоритма <tex>O(N^3\log{N}) </tex>, пространственная <tex>O(N^2)</tex>.<br />
<br />
====Доказательство корректности====<br />
<br />
Пусть дана строка <tex>$s$</tex>, к которой было применено преобразование BWT. Докажем, что при использовании наивного алгоритма на каждом шаге получающийся набор строк соответствует суффиксам циклических перестановок исходной строки, методом математической индукции.<br />
* База. Циклически сдвинем все строки исходной таблицы на <tex>1</tex> влево. Тогда в столбце <tex>n</tex> будут находиться символы, добавленные на первом шаге алгоритма, а в столбце <tex>n - 1</tex> символы, изначально стоявшие в таблице до первого шага алгоритма. Таким образом, полученные на первом шаге алгоритма строки являются суффиксами циклических перестановок строки <tex>$s$</tex>.<br />
* Предположение. Пусть на <tex>k</tex> шаге алгоритма все полученные строки являются суффиксами циклических перестановок строки <tex>$s$</tex>.<br />
* Переход. Рассмотрим <tex>k+1</tex>-ый шаг алгоритма. Все строки отсортированы, поэтому самый левый столбец совпадет с <tex>1</tex> столбцом исходной таблицы. Циклически сдвинем все строки исходной таблицы на <tex>n - k</tex> символов вправо. Теперь по предположению первые <tex>k</tex> символов справа в каждой строке совпадают у исходной таблицы и у таблицы, полученной в результате работы алгоритма. <tex>k</tex>-ые справа столбцы также совпадают. Добавленный на <tex>k+1</tex>-ом шаге столбец также совпадает с <tex>k+1</tex>-ым справа столбцом сдвинутой исходной таблицы, так как совпадает с последним столбцом исходной таблицы, которая была сдвинута на <tex>n-k</tex>.<br />
<br />
{|border ="1"<br />
!colspan="3" | <tex>$k+1$</tex> шаг алгоритма при <tex>$k=3$</tex><br />
|-<br />
! Исходная <br /> таблица || Сдвинутая <br /> таблица || Результат <br /> работы <br /> алгоритма<br />
|-align="center"<br />
|<br />
<font color="red">A</font><font color="green">ABA</font>CA<font color="blue">B</font><br />
<font color="red">A</font><font color="green">BAA</font>BA<font color="blue">C</font><br />
<font color="red">A</font><font color="green">BAC</font>AB<font color="blue">A</font><br />
<font color="red">A</font><font color="green">CAB</font>AA<font color="blue">B</font><br />
<font color="red">B</font><font color="green">AAB</font>AC<font color="blue">A</font><br />
<font color="red">B</font><font color="green">ACA</font>BA<font color="blue">A</font><br />
<font color="red">C</font><font color="green">ABA</font>AB<font color="blue">A</font><br />
|<br />
CA<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font><br />
BA<font color="blue">C</font><font color="red">A</font><font color="green">BAA</font><br />
AB<font color="blue">A</font><font color="red">A</font><font color="green">BAC</font><br />
AA<font color="blue">B</font><font color="red">A</font><font color="green">CAB</font><br />
AC<font color="blue">A</font><font color="red">B</font><font color="green">AAB</font><br />
BA<font color="blue">A</font><font color="red">B</font><font color="green">ACA</font><br />
AB<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font><br />
|<br />
<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font><br />
<font color="blue">C</font><font color="red">A</font><font color="green">BAA</font><br />
<font color="blue">A</font><font color="red">A</font><font color="green">BAC</font><br />
<font color="blue">B</font><font color="red">A</font><font color="green">CAB</font><br />
<font color="blue">A</font><font color="red">B</font><font color="green">AAB</font><br />
<font color="blue">A</font><font color="red">B</font><font color="green">ACA</font><br />
<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font><br />
|-<br />
|}<br />
<br />
Таким образом, поскольку на каждом шаге алгоритма получившиеся строки являлись суффиксами циклических перестановок <tex> $s$ </tex>, после последнего шага получившиеся строки будут совпадать с циклическими перестановками <tex> $s$ </tex>.<br />
<br />
===Оптимизированный наивный алгоритм===<br />
<br />
Наивный алгоритм можно оптимизировать. Заметим, что при каждом проявлении неизвестного столбца выполнялись одни и те же действия. Мы приписывали новый столбец и сортировали имеющиеся данные. На каждом шагу мы к строке, которая находилась на <tex> i </tex>-ом месте приписываем в начало <tex> i </tex> -ый элемент столбца входных данных. Пусть изначально мы знаем каким по порядку является приписанный нами в начало символ (то есть каким по порядку в столбце). И конечно же мы знаем исходя из предыдущего шага какое место занимала наша строка без этого первого символа (<tex> i </tex> -ое). Тогда несложно заметить, что при выполнении такой операции строка с номером <tex> i </tex> всегда будет перемещаться на позицию с номером <tex> j </tex>.<br />
<br />
{| border="1"<br />
|0||а||&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;||р||9<br />
|-<br />
|1||а||||д||7<br />
|-<br />
|2||а|| ||a||0<br />
|-<br />
|3||а|| ||к||8<br />
|-<br />
|4||а|| ||р||10<br />
|-<br />
|5||б|| ||a||1<br />
|-<br />
|6||б|| ||a||2<br />
|-<br />
|7||д|| ||a||3<br />
|-<br />
|8||к|| ||a||4<br />
|-<br />
|9||р|| ||б||5<br />
|-<br />
|10||р|| ||б||6<br />
|}<br />
<br />
Здесь слева отсортированный данный столбец, чтобы мы знали, какое место в лексикографическом порядке занимает приписываемый нами символ среди всех элементов данного нам изначально столбца. Справа - изначально данный столбец и соответствующее ему число. Поскольку в нашем алгоритме новый столбец приписывается в начало, то мы из состояния <tex> i </tex> (левый столбец) переходим в состояние <tex> j </tex> (правый). Для того, чтобы восстановить строку, нам необходимо от последней такой цифры по пути из <tex> j </tex> в <tex> i </tex> восстановить строку.<br />
{|<br />
|<br />
{| border="1"<br />
|6<br />
|→<br />
|10<br />
|→<br />
|4 <br />
|→<br />
|8<br />
|→ <br />
|3<br />
|→<br />
|7<br />
|→<br />
|1<br />
|→<br />
|5<br />
|→<br />
|9<br />
|→<br />
|0<br />
|→<br />
|2<br />
|-<br />
|а<br />
|<br />
|б<br />
|<br />
|р<br />
|<br />
|а<br />
|<br />
|к<br />
|<br />
|а<br />
|<br />
|д<br />
|<br />
|а<br />
|<br />
|б<br />
|<br />
|р<br />
|<br />
|а<br />
|}<br />
====Сложность оптимизированного алгоритма====<br />
Данный алгоритм работает за <tex>O(N\log{N})</tex> времени и требует <tex>O(N)</tex> памяти. Однако, если размер алфавита не очень большой, то для выяснения первого столбца матрицы можно использовать сортировку подсчетом, в этом случае алгоритм работает за <tex>O(N+M)</tex> действий и требует <tex>O(N+M)</tex> памяти, где <tex>M</tex> — размер алфавита.<br />
<br />
====Псевдокод оптимизированного алгоритма====<br />
Пусть <tex> N </tex> — количество символов во входной строке, <tex> M </tex> — количество символов в алфавите, <tex> k </tex> — номер исходной строки в матрице перестановок, <tex> s </tex> — входящая строка, <tex> count </tex> — массив для сортировки подсчетом, <tex> t </tex> — вектор обратного преобразования, <tex> x </tex> — номер данной нам строки в таблице.<br />
<br />
// Cчитаем частоты символов<br />
'''for''' i = 0 .. M <br />
count[i] = 0<br />
'''for''' i = 0 .. N <br />
count[s[i]]++<br />
// Упорядочиваем символы, чтобы получить первый столбец исходной матрицы<br />
// count[i] указывает на первую позицию символа i в первом столбце<br />
sum = 0<br />
'''for''' i = 0 .. M<br />
sum = sum + count[i]<br />
count[i] = sum - count[i]<br />
// Cоздаем вектор обратного преобразования<br />
'''for''' i = 0 .. N<br />
t[count[s[i]]] = i<br />
count[s[i]]++<br />
// И восстанавливаем исходный текст<br />
j = t[x]<br />
'''for''' i = 0 .. N<br />
'''print'''(s[j])<br />
j = t[j]<br />
<br />
====Доказательство корректности====<br />
<br />
Пусть текст <tex>T</tex> состоит из <tex>N + 1</tex> символов, занумерованных с нуля: <tex>T[0..N]</tex>. Буквы <tex>T[i]</tex> принадлежат некоторому алфавиту <tex>A</tex>. Лексикографический порядок (строгий) на строках из алфавита <tex>A</tex> будем обозначать <tex>\preceq (\prec)</tex>. Обозначим через <tex>S_{k}T</tex> циклический сдвиг текста <tex>T</tex> на <tex>k</tex> символов влево:<br />
:{|<br />
<tex> S_{k}T = T[(j + k) (mod\ N + 1)] </tex><br />
|}<br />
<br />
Существует перестановка <tex>p</tex> чисел <tex>\{0, ..., N\}</tex>, которая удовлетворяет условию: <br />
:{|<br />
<tex> S_{p(i)}T \preceq S_{p(i + 1)}T,\ i = 0, ..., N - 1\ \ \textbf{(1)}</tex><br />
|}<br />
<br />
Преобразование Барроуза-Уилера текста <tex>T</tex> есть текст <tex>B[0..N] = BW(T)</tex>, буквы которого заданы соотношением:<br />
:{|<br />
<tex>B[i] = S_{p(i)}T[N]</tex>, другими словами <tex>B[i] = S_{p(i) - 1}T[0] = T[(p(i) - 1) (mod\ N + 1)] \ \ \textbf{(2)}</tex><br />
|}<br />
<br />
Пусть <tex>\sigma</tex> {{---}} перестановка чисел <tex>\{0, ..., N\}</tex>, удовлетворяющая условию:<br />
:{|<br />
<tex>B_{\sigma(i)} \preceq B_{\sigma(i + 1)}</tex>, при <tex>i = 0, ..., N - 1\ \ \textbf{(3)}</tex>,<br />
|}<br />
и в случае равенства <tex>B_{\sigma(i)}</tex> и <tex>B_{\sigma(i + 1)}</tex> выполнено {{---}} <tex>\sigma(i) < \sigma(i + 1)</tex>. Перестановка однозначно определяется текстом <tex>B</tex> и ее можно посчитать за <tex>O(N)</tex>, используя сортировку подсчетом. Рассмотрим перестановку <tex>\sigma</tex> как отображение <tex>\sigma : \{0, ..., N\} \to \{0, ..., N\}</tex>. Пусть <tex>\sigma^{k}</tex> копмозиция <tex>k</tex> отображений <tex>\sigma^{k} = \sigma^{k - 1} \circ \sigma</tex>, где <tex>\sigma^{1} = \sigma, \sigma^{0} \equiv i</tex>.<br />
<br />
{{Теорема<br />
|statement=<br />
<br />
''При всех <tex>m = 1, ..., N + 1</tex> верны утверждения,<br />
:<tex>B_{\sigma(i)}...B_{\sigma^{m}(i)} \preceq B_{\sigma(i + 1)}...B_{\sigma^{m}(i + 1)}</tex>, при <tex>i = 0, ..., N - 1\ \ \textbf{(4)}</tex><br />
:<tex>B_iB_{\sigma(i)}...B_{\sigma^{m - 1}(i)} = S_{p(i) - 1}T[0..m - 1]</tex>, при <tex>i = 0, ..., N\ \ \textbf{(5)}</tex><br />
''<br />
<br />
|proof=<br />
<br />
Если лексикографически отсортировать буквы последнего столбца и поместить их в первый столбец, то получится таблица<br />
<br />
| class="wikitable" style="text-align:center"<br />
|-<br />
!Таблица<br />
|-<br />
|a||b||c<br />
|-<br />
|a||b||c<br />
|<br />
<br />
<br />
}}<br />
<br />
{{Теорема<br />
|statement=<br />
<br />
''Для восстановления исходного текста <tex>T</tex> из преобразования <tex>B</tex> достаточно знать число <tex>I</tex>, отвечающее условию <tex>p(I) = 0</tex>, другими словами <tex>S_{p(I)}T = T</tex>.''<br />
<br />
}}<br />
<br />
===Алгоритм за линейное время===<br />
<br />
Будем обозначать <tex>s^i</tex> <tex>i</tex>-ую циклическую перестановку <tex>$s$</tex>. Пусть <tex>s^0 = s_0 s_1 \ldots s_{n-1}</tex>, <tex>$BWT(s)$\;= L</tex> и <tex>L = L_0L_1\ldots L_{n-1}</tex>, <tex>I</tex> - номер строки <tex>s^0</tex> в таблице. Предподсчитаем следующие величины:<br />
* Для каждого <tex>L_i</tex> количество символов на подстроке <tex>L_0 \ldots L_{i-1}</tex>, равных <tex>L_i</tex><br />
* Для каждого уникального <tex>L_i</tex> количество символов в <tex>L</tex>, лексикографически меньших, чем <tex>L_i</tex><br />
<br />
Пример для <tex>$BWT(s) =$</tex> "BCABAAA":<br />
<br />
{|border ="1"<br />
!colspan="3" | Таблица первого предподсчёта<br />
|-<br />
! Позиция || Символ || Результат<br />
|-align="center"<br />
! 0 || B || 0<br />
|-<br />
! 1 || C || 0<br />
|-<br />
! 2 || A || 0<br />
|-<br />
! 3 || B || 1<br />
|-<br />
! 4 || A || 1<br />
|-<br />
! 5 || A || 2<br />
|-<br />
! 6 || A || 3<br />
|}<br />
<br />
<br />
{|border ="1"<br />
!colspan="2" | Таблица второго предподсчёта<br />
|-<br />
! Символ || Количество <br /> меньших<br />
|-align="center"<br />
! A || 0<br />
|-<br />
! B || 4<br />
|-<br />
! C || 6<br />
|}<br />
<br />
Для удобства пронумеруем известные нам данные:<br />
# <tex>L</tex>, последний столбец таблицы перестановок<br />
# <tex>I</tex>, номер строки <tex>$s$</tex> в таблице перестановок<br />
# Частота, с которой символ <tex>L_{i}</tex> встречается в подстроке <tex>L_0\ldots L_{i-1}</tex><br />
# Для каждого уникального символа количество лексикографически меньших символов в <tex>L</tex><br />
<br />
Символ <tex>s_{n-1}</tex> находится в строке <tex>L</tex> под номером <tex>I</tex>, так как в таблице строка <tex>s^0</tex> имела номер <tex>I</tex>. Найдём символ <tex>s_{n-2}</tex>.<br />
<br />
Символ <tex>s_{n-2}</tex> имеет в строке <tex>L</tex> тот же номер, что строка <tex>s^{n-1}</tex> имела в таблице перестановок: строка <tex>s^{n-1}</tex> начинается с символа <tex>s_{n-1}</tex>, <tex>s_{n-2}</tex> находится на 1 левее его и из-за циклического сдвига оказывается в последнем столбце. Нам известен символ <tex>s_{n-1}</tex>. Посчитаем, на каком месте в таблице будет стоять строка, начинающаяся с этого символа.<br />
<br />
Из 4 известно количество символов, меньших <tex>s_{n-1}</tex>. Все строки, начинающиеся с этих символов, стоят в таблице раньше <tex>s^{n-1}</tex>. Кроме того, в таблице есть строки, начинающиеся с того же символа, что и <tex>s^{n-1}</tex>. Из 3 известно, сколько их: если символ, равный <tex>s_{n-1}</tex>, встречался в <tex>L</tex> раньше, чем <tex>s_{n-1}</tex>, то в таблице строка, начинающаяся с этого символа, тоже стоит раньше строки, начинающейся с <tex>s_{n-1}</tex>, так как префикс строки, оканчивающейся на этот символ, меньше префикса строки, оканчивающейся на <tex>s_{n-1}</tex>.<br />
<br />
Тогда сумма этих двух величин является номером символа <tex>s_{n-2}</tex> в строке <tex>L</tex>. Зная <tex>s_{n-1}</tex> и <tex>s_{n-2}</tex>, аналогично найдём <tex>s_{n-3}\ldots s_0</tex>.<br />
<br />
Предподсчёт занимает <tex>O(n)</tex> времени, восстановление каждого из <tex>n</tex> символов занимает <tex>O(1)</tex> времени. Суммарное время работы алгоритма <tex>O(n)</tex>.<br />
<br />
Пример работы для <tex>$BWT(s) = ($</tex>"BCABAAA", 2<tex>)</tex> (нумерация с 0):<br />
* <tex>s^0 = .......</tex><br />
* <tex>s_6=L_2 = A</tex>. Тогда <tex>s^0=......</tex>A<br />
* Суммируем значения из двух таблиц: <tex>0+0=0</tex>, <tex>s_5=L_0=B</tex>, <tex>s^0=.....</tex>BA<br />
* Суммируем: <tex>0+4=4</tex>, <tex>s_4=L_4=A</tex>, <tex>s^0=....</tex>ABA<br />
* Суммируем: <tex>1+0=1</tex>, <tex>s_3=L_1=C</tex>, <tex>s^0=...</tex>CABA<br />
* Суммируем: <tex>0+6=6</tex>, <tex>s_2=L_6=A</tex>, <tex>s^0=..</tex>ACABA<br />
* Суммируем: <tex>3+0=3</tex>, <tex>s_2=L_3=B</tex>, <tex>s^0=.</tex>BACABA<br />
* Суммируем: <tex>1+4=5</tex>, <tex>s_2=L_5=A</tex>, <tex>s^0=</tex> ABACABA<br />
<br />
== Дополнительно ==<br />
<br />
* bzip2 использует преобразование Барроуза {{---}} Уилера для превращения последовательностей многократно чередующихся символов в строки одинаковых символов, затем применяет преобразование MTF (англ. move-to-front), и в конце кодирование Хаффмана.<br />
<br />
== Источники информации ==<br />
*[http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%91%D0%B0%D1%80%D1%80%D0%BE%D1%83%D0%B7%D0%B0_%E2%80%94_%D0%A3%D0%B8%D0%BB%D0%B5%D1%80%D0%B0 Википедия: Преобразование Барроуза {{---}} Уилера]<br />
<br />
*[http://www.cs.karelia.ru/~aborod/inf/2010/schedule.php.ru cs.karelia.ru: Преобразование Барроуза {{---}} Уилера]<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Алгоритмы сжатия ]]</div>Evarandhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%91%D0%B0%D1%80%D1%80%D0%BE%D1%83%D0%B7%D0%B0-%D0%A3%D0%B8%D0%BB%D0%B5%D1%80%D0%B0&diff=50153Преобразование Барроуза-Уилера2015-12-06T17:22:40Z<p>Evarand: Алгоритм за O(n)</p>
<hr />
<div>== Определение ==<br />
<br />
'''Преобразование Барроуза {{---}} Уилера''' (англ. ''Burrows-Wheeler transform'') {{---}} алгоритм, используемый для предварительной обработки данных перед сжатием, разработанный для улучшения эффективности последующего кодирования. Преобразование Барроуза {{---}} Уилера меняет порядок символов во входной строке таким образом, что повторяющиеся подстроки образуют на выходе идущие подряд последовательности одинаковых символов.<br />
<br />
== Описание алгоритма ==<br />
<br />
Преобразование выполняется в три этапа. <br />
* Составляется таблица всех циклических сдвигов входной строки.<br />
* Производится лексикографическая (в алфавитном порядке) сортировка строк таблицы.<br />
* В качестве выходной строки выбирается последний столбец таблицы преобразования и номер строки, совпадающей с исходной.<br />
<br />
== Пример работы алгоритма ==<br />
<br />
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA". <br />
<br />
{| border="1"<br />
!colspan="4"|Трансформация<br />
|-<br />
! Вход || Все<br />Перестановки || Сортировка<br />Строк || Выход<br />
|-<br />
|<br />
<font color="red">ABACABA</font><br />
|<br />
<font color="red">ABACABA</font><br />
BACABAA<br />
ACABAAB<br />
CABAABA<br />
ABAABAC<br />
BAABACA<br />
AABACAB<br />
|<br />
AABACAB<br />
ABAABAC<br />
<font color="red">ABACABA</font><br />
ACABAAB<br />
BAABACA<br />
BACABAA<br />
CABAABA <br />
|<br />
BCABAAA, 3<br />
|}<br />
<br />
Результат можно записать так: <tex>$BWT(s) = $(</tex>"BCABAAA", 3<tex>)</tex>, где 3 {{---}} номер исходной строки в отсортированной матрице. Он нужен для обратного преобразования. <br />
<br />
<br />
Следует заметить, что иногда в исходной строке приводится так называемый символ конца строки ''$'', который в преобразовании будет считаться последним (максимальным) символом, тогда сохранение номера исходной строки не требуется.<br />
<br />
<br />
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA$".<br />
<br />
{| border="1"<br />
!colspan="4"|Трансформация<br />
|-<br />
! Вход || Все<br />Перестановки || Сортировка<br />Строк || Выход<br />
|-<br />
|<br />
<font color="red">ABACABA$</font><br />
|<br />
<font color="red">ABACABA$</font><br />
BACABA$A<br />
ACABA$AB<br />
CABA$ABA<br />
ABA$ABAC<br />
BA$ABACA<br />
A$ABACAB<br />
$ABACABA<br />
<br />
|<br />
<font color="red">ABACABA$</font><br />
ABA$ABAC<br />
ACABA$AB<br />
A$ABACAB<br />
BACABA$A<br />
BA$ABACA<br />
CABA$ABA <br />
$ABACABA<br />
|<br />
$CBBAAAA<br />
|} <br />
<br />
<br />
<br />
При аналогичном вышеприведённом преобразовании та строчка в матрице, которая будет заканчиваться на символ конца строки, и будет исходной: ("ABACABA$"). Тогда результат можно записать так: <tex>$BWT(s) =$</tex> "$CBBAAAA".<br />
<br />
== Обратное преобразование ==<br />
<br />
===Наивный алгоритм===<br />
<br />
Пусть нам дано: <tex>$BWT(s) =$(</tex>"BCABAAA", 3<tex>)</tex>. Тогда выпишем в столбик нашу преобразованную последовательность символов "BCABAAA". Запишем её как последний столбик предыдущей матрицы (при прямом преобразовании Барроуза {{---}} Уилера), при этом все предыдущие столбцы оставляем пустыми. Далее построчно отсортируем матрицу, затем в предыдущий столбец запишем "BCABAAA". Опять построчно отсортируем матрицу. Продолжая таким образом, можно восстановить полный список всех циклических перестановок строки, которую нам надо найти. Выстроив полный отсортированный список перестановок, выберем строку с номером, который нам был изначально дан. В итоге мы получим искомую строку.<br />
Алгоритм обратного преобразования описан в таблице ниже:<br />
<br />
{| border="1"<br />
!colspan="8"| Обратное преобразование<br />
|-<br />
!colspan="8"| Вход<br />
|-<br />
|align="center" colspan="8"|<br />
BCABAAA<br />
|-<br />
! Добавление 1 || Сортировка 1 || Добавление 2 || Сортировка 2 || Добавление 3 || Сортировка 3 || Добавление 4 <br />
|-align="right"<br />
|<br />
B<br />
C<br />
A<br />
B<br />
A<br />
A<br />
A<br />
|<br />
A<br />
A<br />
A<br />
A<br />
B<br />
B<br />
C<br />
|<br />
BA<br />
CA<br />
AA<br />
BA<br />
AB<br />
AB<br />
AC<br />
|<br />
AA<br />
AB<br />
AB<br />
AC<br />
BA<br />
BA<br />
CA<br />
|<br />
BAA<br />
CAB<br />
AAB<br />
BAC<br />
ABA<br />
ABA<br />
ACA<br />
|<br />
AAB<br />
ABA<br />
ABA<br />
ACA<br />
BAA<br />
BAC<br />
CAB<br />
|<br />
BAAB<br />
CABA<br />
AABA<br />
BACA<br />
ABAA<br />
ABAC<br />
ACAB<br />
|-<br />
! Сортировка 4 || Добавление 5 || Сортировка 5 || Добавление 6 || Сортировка 6 || Добавление 7 || Сортировка 7<br />
<br />
|-align="right"<br />
|<br />
AABA<br />
ABAA<br />
ABAC<br />
ACAB<br />
BAAB<br />
BACA<br />
CABA<br />
|<br />
BAABA<br />
CABAA<br />
AABAC<br />
BACAB<br />
ABAAB<br />
ABACA<br />
ACABA<br />
|<br />
AABAC<br />
ABAAB<br />
ABACA<br />
ACABA<br />
BAABA<br />
BACAB<br />
CABAA<br />
|<br />
BAABAC<br />
CABAAB<br />
AABACA<br />
BACABA<br />
ABAABA<br />
ABACAB<br />
ACABAA<br />
|<br />
AABACA<br />
ABAABA<br />
ABACAB<br />
ACABAA<br />
BAABAC<br />
BACABA<br />
CABAAB<br />
|<br />
BAABACA<br />
CABAABA<br />
AABACAB<br />
BACABAA<br />
ABAABAC<br />
ABACABA<br />
ACABAAB<br />
|<br />
AABACAB<br />
ABAABAC<br />
<font color="red">ABACABA</font><br />
ACABAAB<br />
BAABACA<br />
BACABAA<br />
CABAABA<br />
|-<br />
<br />
!colspan="8"| Результат<br />
|-<br />
|align="center" colspan="8"|<br />
<font color="red">ABACABA</font><br />
|}<br />
<br />
Следует также заметить, что если нам было бы дано <tex>$BWT(s) = $</tex> "$CBBAAAA", то мы также получили бы нашу исходную строку, только с символом конца строки ''$'' на конце: ''ABACABA$''.<br />
<br />
Временная сложность данного алгоритма <tex>O(N^3\log{N}) </tex>, пространственная <tex>O(N^2)</tex>.<br />
<br />
====Доказательство корректности====<br />
<br />
Пусть дана строка <tex>$s$</tex>, к которой было применено преобразование BWT. Докажем, что при использовании наивного алгоритма на каждом шаге получающийся набор строк соответствует суффиксам циклических перестановок исходной строки, методом математической индукции.<br />
* База. Циклически сдвинем все строки исходной таблицы на 1 влево. Тогда в столбце <tex>n</tex> будут находиться символы, добавленные на первом шаге алгоритма, а в столбце <tex>n - 1</tex> символы, изначально стоявшие в таблице до первого шага алгоритма. Таким образом, полученные на первом шаге алгоритма строки являются суффиксами циклических перестановок строки <tex>$s$</tex>.<br />
* Предположение. Пусть на <tex>k</tex> шаге алгоритма все полученные строки являются суффиксами циклических перестановок строки <tex>$s$</tex>.<br />
* Переход. Рассмотрим <tex>k+1</tex>-ый шаг алгоритма. Все строки отсортированы, поэтому самый левый столбец совпадет с 1 столбцом исходной таблицы. Циклически сдвинем все строки исходной таблицы на <tex>n - k</tex> символов вправо. Теперь по предположению первые <tex>k</tex> символов справа в каждой строке совпадают у исходной таблицы и у таблицы, полученной в результате работы алгоритма. <tex>k</tex>-ые справа столбцы также совпадают. Добавленный на <tex>k+1</tex>-ом шаге столбец также совпадает с <tex>k+1</tex>-ым справа столбцом сдвинутой исходной таблицы, так как совпадает с последним столбцом исходной таблицы, которая была сдвинута на <tex>n-k</tex>.<br />
<br />
{|border ="1"<br />
!colspan="3" | <tex>$k+1$</tex> шаг алгоритма при <tex>$k=3$</tex><br />
|-<br />
! Исходная <br /> таблица || Сдвинутая <br /> таблица || Результат <br /> работы <br /> алгоритма<br />
|-align="center"<br />
|<br />
<font color="red">A</font><font color="green">ABA</font>CA<font color="blue">B</font><br />
<font color="red">A</font><font color="green">BAA</font>BA<font color="blue">C</font><br />
<font color="red">A</font><font color="green">BAC</font>AB<font color="blue">A</font><br />
<font color="red">A</font><font color="green">CAB</font>AA<font color="blue">B</font><br />
<font color="red">B</font><font color="green">AAB</font>AC<font color="blue">A</font><br />
<font color="red">B</font><font color="green">ACA</font>BA<font color="blue">A</font><br />
<font color="red">C</font><font color="green">ABA</font>AB<font color="blue">A</font><br />
|<br />
CA<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font><br />
BA<font color="blue">C</font><font color="red">A</font><font color="green">BAA</font><br />
AB<font color="blue">A</font><font color="red">A</font><font color="green">BAC</font><br />
AA<font color="blue">B</font><font color="red">A</font><font color="green">CAB</font><br />
AC<font color="blue">A</font><font color="red">B</font><font color="green">AAB</font><br />
BA<font color="blue">A</font><font color="red">B</font><font color="green">ACA</font><br />
AB<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font><br />
|<br />
<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font><br />
<font color="blue">C</font><font color="red">A</font><font color="green">BAA</font><br />
<font color="blue">A</font><font color="red">A</font><font color="green">BAC</font><br />
<font color="blue">B</font><font color="red">A</font><font color="green">CAB</font><br />
<font color="blue">A</font><font color="red">B</font><font color="green">AAB</font><br />
<font color="blue">A</font><font color="red">B</font><font color="green">ACA</font><br />
<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font><br />
|-<br />
|}<br />
<br />
Таким образом, поскольку на каждом шаге алгоритма получившиеся строки являлись суффиксами циклических перестановок <tex> $s$ </tex>, после последнего шага получившиеся строки будут совпадать с циклическими перестановками <tex> $s$ </tex>.<br />
<br />
===Оптимизированный наивный алгоритм===<br />
<br />
Наивный алгоритм можно оптимизировать. Заметим, что при каждом проявлении неизвестного столбца выполнялись одни и те же действия. Мы приписывали новый столбец и сортировали имеющиеся данные. На каждом шагу мы к строке, которая находилась на <tex> i </tex>-ом месте приписываем в начало <tex> i </tex> -ый элемент столбца входных данных. Пусть изначально мы знаем каким по порядку является приписанный нами в начало символ (то есть каким по порядку в столбце). И конечно же мы знаем исходя из предыдущего шага какое место занимала наша строка без этого первого символа (<tex> i </tex> -ое). Тогда несложно заметить, что при выполнении такой операции строка с номером <tex> i </tex> всегда будет перемещаться на позицию с номером <tex> j </tex>.<br />
<br />
{| border="1"<br />
|0||а||&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;||р||9<br />
|-<br />
|1||а||||д||7<br />
|-<br />
|2||а|| ||a||0<br />
|-<br />
|3||а|| ||к||8<br />
|-<br />
|4||а|| ||р||10<br />
|-<br />
|5||б|| ||a||1<br />
|-<br />
|6||б|| ||a||2<br />
|-<br />
|7||д|| ||a||3<br />
|-<br />
|8||к|| ||a||4<br />
|-<br />
|9||р|| ||б||5<br />
|-<br />
|10||р|| ||б||6<br />
|}<br />
<br />
Здесь слева отсортированный данный столбец, чтобы мы знали, какое место в лексикографическом порядке занимает приписываемый нами символ среди всех элементов данного нам изначально столбца. Справа - изначально данный столбец и соответствующее ему число. Поскольку в нашем алгоритме новый столбец приписывается в начало, то мы из состояния <tex> i </tex> (левый столбец) переходим в состояние <tex> j </tex> (правый). Для того, чтобы восстановить строку, нам необходимо от последней такой цифры по пути из <tex> j </tex> в <tex> i </tex> восстановить строку.<br />
{|<br />
|<br />
{| border="1"<br />
|6<br />
|→<br />
|10<br />
|→<br />
|4 <br />
|→<br />
|8<br />
|→ <br />
|3<br />
|→<br />
|7<br />
|→<br />
|1<br />
|→<br />
|5<br />
|→<br />
|9<br />
|→<br />
|0<br />
|→<br />
|2<br />
|-<br />
|а<br />
|<br />
|б<br />
|<br />
|р<br />
|<br />
|а<br />
|<br />
|к<br />
|<br />
|а<br />
|<br />
|д<br />
|<br />
|а<br />
|<br />
|б<br />
|<br />
|р<br />
|<br />
|а<br />
|}<br />
====Сложность оптимизированного алгоритма====<br />
Данный алгоритм работает за <tex>O(N\log{N})</tex> времени и требует <tex>O(N)</tex> памяти. Однако, если размер алфавита не очень большой, то для выяснения первого столбца матрицы можно использовать сортировку подсчетом, в этом случае алгоритм работает за <tex>O(N+M)</tex> действий и требует <tex>O(N+M)</tex> памяти, где <tex>M</tex> — размер алфавита.<br />
<br />
===Псевдокод оптимизированного алгоритма===<br />
Пусть <tex> N </tex> — количество символов во входной строке, <tex> M </tex> — количество символов в алфавите, <tex> k </tex> — номер исходной строки в матрице перестановок, <tex> s </tex> — входящая строка, <tex> count </tex> — массив для сортировки подсчетом, <tex> t </tex> — вектор обратного преобразования, <tex> x </tex> — номер данной нам строки в таблице.<br />
<br />
// Cчитаем частоты символов<br />
for i = 0 .. M <br />
count[i] = 0<br />
for i = 0 .. N <br />
count[s[i]]++<br />
// Упорядочиваем символы, чтобы получить первый столбец исходной матрицы<br />
// count[i] указывает на первую позицию символа i в первом столбце<br />
sum = 0<br />
for i = 0 .. M<br />
sum = sum + count[i]<br />
count[i] = sum - count[i]<br />
// Cоздаем вектор обратного преобразования<br />
for i = 0 .. N<br />
t[count[s[i]]] = i<br />
count[s[i]]++<br />
// И восстанавливаем исходный текст<br />
j = t[x]<br />
for i = 0 .. N<br />
print(s[j])<br />
j = t[j]<br />
<br />
====Доказательство корректности====<br />
<br />
Пусть текст <tex>T</tex> состоит из <tex>N + 1</tex> символов, занумерованных с нуля: <tex>T[0..N]</tex>. Буквы <tex>T[i]</tex> принадлежат некоторому алфавиту <tex>A</tex>. Лексикографический порядок (строгий) на строках из алфавита <tex>A</tex> будем обозначать <tex>\preceq (\prec)</tex>. Обозначим через <tex>S_{k}T</tex> циклический сдвиг текста <tex>T</tex> на <tex>k</tex> символов влево:<br />
:{|<br />
<tex> S_{k}T = T[(j + k) (mod\ N + 1)] </tex><br />
|}<br />
<br />
Существует перестановка <tex>p</tex> чисел <tex>\{0, ..., N\}</tex>, которая удовлетворяет условию: <br />
:{|<br />
<tex> S_{p(i)}T \preceq S_{p(i + 1)}T,\ i = 0, ..., N - 1\ \ \textbf{(1)}</tex><br />
|}<br />
<br />
Преобразование Барроуза-Уилера текста <tex>T</tex> есть текст <tex>B[0..N] = BW(T)</tex>, буквы которого заданы соотношением:<br />
:{|<br />
<tex>B[i] = S_{p(i)}T[N]</tex>, другими словами <tex>B[i] = S_{p(i) - 1}T[0] = T[(p(i) - 1) (mod\ N + 1)] \ \ \textbf{(2)}</tex><br />
|}<br />
<br />
Пусть <tex>\sigma</tex> {{---}} перестановка чисел <tex>\{0, ..., N\}</tex>, удовлетворяющая условию:<br />
:{|<br />
<tex>B_{\sigma(i)} \preceq B_{\sigma(i + 1)}</tex>, при <tex>i = 0, ..., N - 1\ \ \textbf{(3)}</tex>,<br />
|}<br />
и в случае равенства <tex>B_{\sigma(i)}</tex> и <tex>B_{\sigma(i + 1)}</tex> выполнено {{---}} <tex>\sigma(i) < \sigma(i + 1)</tex>. Перестановка однозначно определяется текстом <tex>B</tex> и ее можно посчитать за <tex>O(N)</tex>, используя сортировку подсчетом. Рассмотрим перестановку <tex>\sigma</tex> как отображение <tex>\sigma : \{0, ..., N\} \to \{0, ..., N\}</tex>. Пусть <tex>\sigma^{k}</tex> копмозиция <tex>k</tex> отображений <tex>\sigma^{k} = \sigma^{k - 1} \circ \sigma</tex>, где <tex>\sigma^{1} = \sigma, \sigma^{0} \equiv i</tex>.<br />
<br />
{{Теорема<br />
|statement=<br />
<br />
''При всех <tex>m = 1, ..., N + 1</tex> верны утверждения,<br />
:<tex>B_{\sigma(i)}...B_{\sigma^{m}(i)} \preceq B_{\sigma(i + 1)}...B_{\sigma^{m}(i + 1)}</tex>, при <tex>i = 0, ..., N - 1\ \ \textbf{(4)}</tex><br />
:<tex>B_iB_{\sigma(i)}...B_{\sigma^{m - 1}(i)} = S_{p(i) - 1}T[0..m - 1]</tex>, при <tex>i = 0, ..., N\ \ \textbf{(5)}</tex><br />
''<br />
<br />
|proof=<br />
<br />
Если лексикографически отсортировать буквы последнего столбца и поместить их в первый столбец, то получится таблица<br />
<br />
| class="wikitable" style="text-align:center"<br />
|-<br />
!Таблица<br />
|-<br />
|a||b||c<br />
|-<br />
|a||b||c<br />
|<br />
<br />
<br />
}}<br />
<br />
{{Теорема<br />
|statement=<br />
<br />
''Для восстановления исходного текста <tex>T</tex> из преобразования <tex>B</tex> достаточно знать число <tex>I</tex>, отвечающее условию <tex>p(I) = 0</tex>, другими словами <tex>S_{p(I)}T = T</tex>.''<br />
<br />
}}<br />
<br />
===Алгоритм за линейное время===<br />
<br />
Будем обозначать <tex>s^i</tex> <tex>i</tex>-ую циклическую перестановку <tex>$s$</tex>. Пусть <tex>s^0 = s_0 s_1 \ldots s_{n-1}</tex>, <tex>$BWT(s)$\;= L</tex> и <tex>L = L_0L_1\ldots L_{n-1}</tex>, <tex>I</tex> - номер строки <tex>s^0</tex> в таблице. Предподсчитаем следующие величины:<br />
* Для каждого <tex>L_i</tex> количество символов на подстроке <tex>L_0 \ldots L_{i-1}</tex>, равных <tex>L_i</tex><br />
* Для каждого уникального <tex>L_i</tex> количество символов в <tex>L</tex>, лексикографически меньших, чем <tex>L_i</tex><br />
<br />
Пример для <tex>$BWT(s) =$</tex> "BCABAAA":<br />
<br />
{|border ="1"<br />
!colspan="3" | Таблица первого предподсчёта<br />
|-<br />
! Позиция || Символ || Результат<br />
|-align="center"<br />
! 0 || B || 0<br />
|-<br />
! 1 || C || 0<br />
|-<br />
! 2 || A || 0<br />
|-<br />
! 3 || B || 1<br />
|-<br />
! 4 || A || 1<br />
|-<br />
! 5 || A || 2<br />
|-<br />
! 6 || A || 3<br />
|}<br />
<br />
<br />
{|border ="1"<br />
!colspan="2" | Таблица второго предподсчёта<br />
|-<br />
! Символ || Количество <br /> меньших<br />
|-align="center"<br />
! A || 0<br />
|-<br />
! B || 4<br />
|-<br />
! C || 6<br />
|}<br />
<br />
Для удобства пронумеруем известные нам данные:<br />
# <tex>L</tex>, последний столбец таблицы перестановок<br />
# <tex>I</tex>, номер строки <tex>$s$</tex> в таблице перестановок<br />
# Частота, с которой символ <tex>L_{i}</tex> встречается в подстроке <tex>L_0\ldots L_{i-1}</tex><br />
# Для каждого уникального символа количество лексикографически меньших символов в <tex>L</tex><br />
<br />
Символ <tex>s_{n-1}</tex> находится в строке <tex>L</tex> под номером <tex>I</tex>, так как в таблице строка <tex>s^0</tex> имела номер <tex>I</tex>. Найдём символ <tex>s_{n-2}</tex>.<br />
<br />
Символ <tex>s_{n-2}</tex> имеет в строке <tex>L</tex> тот же номер, что строка <tex>s^{n-1}</tex> имела в таблице перестановок: строка <tex>s^{n-1}</tex> начинается с символа <tex>s_{n-1}</tex>, <tex>s_{n-2}</tex> находится на 1 левее его и из-за циклического сдвига оказывается в последнем столбце. Нам известен символ <tex>s_{n-1}</tex>. Посчитаем, на каком месте в таблице будет стоять строка, начинающаяся с этого символа.<br />
<br />
Из 4 известно количество символов, меньших <tex>s_{n-1}</tex>. Все строки, начинающиеся с этих символов, стоят в таблице раньше <tex>s^{n-1}</tex>. Кроме того, в таблице есть строки, начинающиеся с того же символа, что и <tex>s^{n-1}</tex>. Из 3 известно, сколько их: если символ, равный <tex>s_{n-1}</tex>, встречался в <tex>L</tex> раньше, чем <tex>s_{n-1}</tex>, то в таблице строка, начинающаяся с этого символа, тоже стоит раньше строки, начинающейся с <tex>s_{n-1}</tex>, так как префикс строки, оканчивающейся на этот символ, меньше префикса строки, оканчивающейся на <tex>s_{n-1}</tex>.<br />
<br />
Тогда сумма этих двух величин является номером символа <tex>s_{n-2}</tex> в строке <tex>L</tex>. Зная <tex>s_{n-1}</tex> и <tex>s_{n-2}</tex>, аналогично найдём <tex>s_{n-3}\ldots s_0</tex>.<br />
<br />
Предподсчёт занимает <tex>O(n)</tex> времени, восстановление каждого из <tex>n</tex> символов занимает <tex>O(1)</tex> времени. Суммарное время работы алгоритма <tex>O(n)</tex>.<br />
<br />
Пример работы для <tex>$BWT(s) = ($</tex>"BCABAAA", 2<tex>)</tex> (нумерация с 0):<br />
* <tex>s^0 = .......</tex><br />
* <tex>s_6=L_2 = A</tex>. Тогда <tex>s^0=......</tex>A<br />
* Суммируем значения из двух таблиц: <tex>0+0=0</tex>, <tex>s_5=L_0=B</tex>, <tex>s^0=.....</tex>BA<br />
* Суммируем: <tex>0+4=4</tex>, <tex>s_4=L_4=A</tex>, <tex>s^0=....</tex>ABA<br />
* Суммируем: <tex>1+0=1</tex>, <tex>s_3=L_1=C</tex>, <tex>s^0=...</tex>CABA<br />
* Суммируем: <tex>0+6=6</tex>, <tex>s_2=L_6=A</tex>, <tex>s^0=..</tex>ACABA<br />
* Суммируем: <tex>3+0=3</tex>, <tex>s_2=L_3=B</tex>, <tex>s^0=.</tex>BACABA<br />
* Суммируем: <tex>1+4=5</tex>, <tex>s_2=L_5=A</tex>, <tex>s^0=</tex>ABACABA<br />
<br />
== Дополнительно ==<br />
<br />
* bzip2 использует преобразование Барроуза {{---}} Уилера для превращения последовательностей многократно чередующихся символов в строки одинаковых символов, затем применяет преобразование MTF (англ. move-to-front), и в конце кодирование Хаффмана.<br />
<br />
== Ссылки ==<br />
*[http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%91%D0%B0%D1%80%D1%80%D0%BE%D1%83%D0%B7%D0%B0_%E2%80%94_%D0%A3%D0%B8%D0%BB%D0%B5%D1%80%D0%B0 Преобразование Барроуза {{---}} Уилера (Википедия)]<br />
<br />
*[http://www.cs.karelia.ru/~aborod/inf/2010/schedule.php.ru Преобразование Барроуза {{---}} Уилера (cs.karelia.ru)]<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Алгоритмы сжатия ]]</div>Evarandhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%91%D0%B0%D1%80%D1%80%D0%BE%D1%83%D0%B7%D0%B0-%D0%A3%D0%B8%D0%BB%D0%B5%D1%80%D0%B0&diff=50143Преобразование Барроуза-Уилера2015-12-06T13:51:36Z<p>Evarand: Доказательство корректности наивного алгоритма</p>
<hr />
<div>== Определение ==<br />
<br />
'''Преобразование Барроуза {{---}} Уилера''' (англ. ''Burrows-Wheeler transform'') {{---}} алгоритм, используемый для предварительной обработки данных перед сжатием, разработанный для улучшения эффективности последующего кодирования. Преобразование Барроуза {{---}} Уилера меняет порядок символов во входной строке таким образом, что повторяющиеся подстроки образуют на выходе идущие подряд последовательности одинаковых символов.<br />
<br />
== Описание алгоритма ==<br />
<br />
Преобразование выполняется в три этапа. <br />
* Составляется таблица всех циклических сдвигов входной строки.<br />
* Производится лексикографическая (в алфавитном порядке) сортировка строк таблицы.<br />
* В качестве выходной строки выбирается последний столбец таблицы преобразования и номер строки, совпадающей с исходной.<br />
<br />
== Пример работы алгоритма ==<br />
<br />
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA". <br />
<br />
{| border="1"<br />
!colspan="4"|Трансформация<br />
|-<br />
! Вход || Все<br />Перестановки || Сортировка<br />Строк || Выход<br />
|-<br />
|<br />
<font color="red">ABACABA</font><br />
|<br />
<font color="red">ABACABA</font><br />
BACABAA<br />
ACABAAB<br />
CABAABA<br />
ABAABAC<br />
BAABACA<br />
AABACAB<br />
|<br />
AABACAB<br />
ABAABAC<br />
<font color="red">ABACABA</font><br />
ACABAAB<br />
BAABACA<br />
BACABAA<br />
CABAABA <br />
|<br />
BCABAAA, 3<br />
|}<br />
<br />
Результат можно записать так: <tex>$BWT(s) = $(</tex>"BCABAAA", 3<tex>)</tex>, где 3 {{---}} номер исходной строки в отсортированной матрице. Он нужен для обратного преобразования. <br />
<br />
<br />
Следует заметить, что иногда в исходной строке приводится так называемый символ конца строки ''$'', который в преобразовании будет считаться последним (максимальным) символом, тогда сохранение номера исходной строки не требуется.<br />
<br />
<br />
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA$".<br />
<br />
{| border="1"<br />
!colspan="4"|Трансформация<br />
|-<br />
! Вход || Все<br />Перестановки || Сортировка<br />Строк || Выход<br />
|-<br />
|<br />
<font color="red">ABACABA$</font><br />
|<br />
<font color="red">ABACABA$</font><br />
BACABA$A<br />
ACABA$AB<br />
CABA$ABA<br />
ABA$ABAC<br />
BA$ABACA<br />
A$ABACAB<br />
$ABACABA<br />
<br />
|<br />
<font color="red">ABACABA$</font><br />
ABA$ABAC<br />
ACABA$AB<br />
A$ABACAB<br />
BACABA$A<br />
BA$ABACA<br />
CABA$ABA <br />
$ABACABA<br />
|<br />
$CBBAAAA<br />
|} <br />
<br />
<br />
<br />
При аналогичном вышеприведённом преобразовании та строчка в матрице, которая будет заканчиваться на символ конца строки, и будет исходной: ("ABACABA$"). Тогда результат можно записать так: <tex>$BWT(s) =$</tex> "$CBBAAAA".<br />
<br />
== Обратное преобразование ==<br />
<br />
===Наивный алгоритм===<br />
<br />
Пусть нам дано: <tex>$BWT(s) =$(</tex>"BCABAAA", 3<tex>)</tex>. Тогда выпишем в столбик нашу преобразованную последовательность символов "BCABAAA". Запишем её как последний столбик предыдущей матрицы (при прямом преобразовании Барроуза {{---}} Уилера), при этом все предыдущие столбцы оставляем пустыми. Далее построчно отсортируем матрицу, затем в предыдущий столбец запишем "BCABAAA". Опять построчно отсортируем матрицу. Продолжая таким образом, можно восстановить полный список всех циклических перестановок строки, которую нам надо найти. Выстроив полный отсортированный список перестановок, выберем строку с номером, который нам был изначально дан. В итоге мы получим искомую строку.<br />
Алгоритм обратного преобразования описан в таблице ниже:<br />
<br />
{| border="1"<br />
!colspan="8"| Обратное преобразование<br />
|-<br />
!colspan="8"| Вход<br />
|-<br />
|align="center" colspan="8"|<br />
BCABAAA<br />
|-<br />
! Добавление 1 || Сортировка 1 || Добавление 2 || Сортировка 2 || Добавление 3 || Сортировка 3 || Добавление 4 <br />
|-align="right"<br />
|<br />
B<br />
C<br />
A<br />
B<br />
A<br />
A<br />
A<br />
|<br />
A<br />
A<br />
A<br />
A<br />
B<br />
B<br />
C<br />
|<br />
BA<br />
CA<br />
AA<br />
BA<br />
AB<br />
AB<br />
AC<br />
|<br />
AA<br />
AB<br />
AB<br />
AC<br />
BA<br />
BA<br />
CA<br />
|<br />
BAA<br />
CAB<br />
AAB<br />
BAC<br />
ABA<br />
ABA<br />
ACA<br />
|<br />
AAB<br />
ABA<br />
ABA<br />
ACA<br />
BAA<br />
BAC<br />
CAB<br />
|<br />
BAAB<br />
CABA<br />
AABA<br />
BACA<br />
ABAA<br />
ABAC<br />
ACAB<br />
|-<br />
! Сортировка 4 || Добавление 5 || Сортировка 5 || Добавление 6 || Сортировка 6 || Добавление 7 || Сортировка 7<br />
<br />
|-align="right"<br />
|<br />
AABA<br />
ABAA<br />
ABAC<br />
ACAB<br />
BAAB<br />
BACA<br />
CABA<br />
|<br />
BAABA<br />
CABAA<br />
AABAC<br />
BACAB<br />
ABAAB<br />
ABACA<br />
ACABA<br />
|<br />
AABAC<br />
ABAAB<br />
ABACA<br />
ACABA<br />
BAABA<br />
BACAB<br />
CABAA<br />
|<br />
BAABAC<br />
CABAAB<br />
AABACA<br />
BACABA<br />
ABAABA<br />
ABACAB<br />
ACABAA<br />
|<br />
AABACA<br />
ABAABA<br />
ABACAB<br />
ACABAA<br />
BAABAC<br />
BACABA<br />
CABAAB<br />
|<br />
BAABACA<br />
CABAABA<br />
AABACAB<br />
BACABAA<br />
ABAABAC<br />
ABACABA<br />
ACABAAB<br />
|<br />
AABACAB<br />
ABAABAC<br />
<font color="red">ABACABA</font><br />
ACABAAB<br />
BAABACA<br />
BACABAA<br />
CABAABA<br />
|-<br />
<br />
!colspan="8"| Результат<br />
|-<br />
|align="center" colspan="8"|<br />
<font color="red">ABACABA</font><br />
|}<br />
<br />
Следует также заметить, что если нам было бы дано <tex>$BWT(s) = $</tex> "$CBBAAAA", то мы также получили бы нашу исходную строку, только с символом конца строки ''$'' на конце: ''ABACABA$''.<br />
<br />
Временная сложность данного алгоритма <tex>O(N^3\log{N}) </tex>, пространственная <tex>O(N^2)</tex>.<br />
<br />
===Доказательство корректности===<br />
<br />
Пусть дана строка <tex>$s$</tex>, к которой было применено преобразование BWT. Докажем, что при использовании наивного алгоритма на каждом шаге получающийся набор строк соответствует суффиксам циклических перестановок исходной строки, методом математической индукции.<br />
* База. Циклически сдвинем все строки исходной таблицы на 1 влево. Тогда в столбце <tex>n</tex> будут находиться символы, добавленные на первом шаге алгоритма, а в столбце <tex>n - 1</tex> символы, изначально стоявшие в таблице до первого шага алгоритма. Таким образом, полученные на первом шаге алгоритма строки являются суффиксами циклических перестановок строки <tex>$s$</tex>.<br />
* Предположение. Пусть на <tex>k</tex> шаге алгоритма все полученные строки являются суффиксами циклических перестановок строки <tex>$s$</tex>.<br />
* Переход. Рассмотрим <tex>k+1</tex>-ый шаг алгоритма. Все строки отсортированы, поэтому самый левый столбец совпадет с 1 столбцом исходной таблицы. Циклически сдвинем все строки исходной таблицы на <tex>n - k</tex> символов вправо. Теперь по предположению первые <tex>k</tex> символов справа в каждой строке совпадают у исходной таблицы и у таблицы, полученной в результате работы алгоритма. <tex>k</tex>-ые справа столбцы также совпадают. Добавленный на <tex>k+1</tex>-ом шаге столбец также совпадает с <tex>k+1</tex>-ым справа столбцом сдвинутой исходной таблицы, так как совпадает с последним столбцом исходной таблицы, которая была сдвинута на <tex>n-k</tex>.<br />
<br />
{|border ="1"<br />
!colspan="3" | <tex>$k+1$</tex> шаг алгоритма при <tex>$k=3$</tex><br />
|-<br />
! Исходная <br /> таблица || Сдвинутая <br /> таблица || Результат <br /> работы <br /> алгоритма<br />
|-align="center"<br />
|<br />
<font color="red">A</font><font color="green">ABA</font>CA<font color="blue">B</font><br />
<font color="red">A</font><font color="green">BAA</font>BA<font color="blue">C</font><br />
<font color="red">A</font><font color="green">BAC</font>AB<font color="blue">A</font><br />
<font color="red">A</font><font color="green">CAB</font>AA<font color="blue">B</font><br />
<font color="red">B</font><font color="green">AAB</font>AC<font color="blue">A</font><br />
<font color="red">B</font><font color="green">ACA</font>BA<font color="blue">A</font><br />
<font color="red">C</font><font color="green">ABA</font>AB<font color="blue">A</font><br />
|<br />
CA<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font><br />
BA<font color="blue">C</font><font color="red">A</font><font color="green">BAA</font><br />
AB<font color="blue">A</font><font color="red">A</font><font color="green">BAC</font><br />
AA<font color="blue">B</font><font color="red">A</font><font color="green">CAB</font><br />
AC<font color="blue">A</font><font color="red">B</font><font color="green">AAB</font><br />
BA<font color="blue">A</font><font color="red">B</font><font color="green">ACA</font><br />
AB<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font><br />
|<br />
<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font><br />
<font color="blue">C</font><font color="red">A</font><font color="green">BAA</font><br />
<font color="blue">A</font><font color="red">A</font><font color="green">BAC</font><br />
<font color="blue">B</font><font color="red">A</font><font color="green">CAB</font><br />
<font color="blue">A</font><font color="red">B</font><font color="green">AAB</font><br />
<font color="blue">A</font><font color="red">B</font><font color="green">ACA</font><br />
<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font><br />
|-<br />
|}<br />
<br />
Таким образом, поскольку на каждом шаге алгоритма получившиеся строки являлись суффиксами циклических перестановок <tex> $s$ </tex>, после последнего шага получившиеся строки будут совпадать с циклическими перестановками <tex> $s$ </tex>.<br />
<br />
===Оптимизация===<br />
<br />
Однако, данный алгоритм можно оптимизировать. Заметим, что при каждом проявлении неизвестного столбца выполнялись одни и те же действия. Мы приписывали новый столбец и сортировали имеющиеся данные. На каждом шагу мы к строке, которая находилась на <tex> i </tex>-ом месте приписываем в начало <tex> i </tex> -ый элемент столбца входных данных. Пусть изначально мы знаем каким по порядку является приписанный нами в начало символ (то есть каким по порядку в столбце). И конечно же мы знаем исходя из предыдущего шага какое место занимала наша строка без этого первого символа (<tex> i </tex> -ое). Тогда несложно заметить, что при выполнении такой операции строка с номером <tex> i </tex> всегда будет перемещаться на позицию с номером <tex> j </tex>.<br />
<br />
{| border="1"<br />
|0||а||&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;||р||9<br />
|-<br />
|1||а||||д||7<br />
|-<br />
|2||а|| ||a||0<br />
|-<br />
|3||а|| ||к||8<br />
|-<br />
|4||а|| ||р||10<br />
|-<br />
|5||б|| ||a||1<br />
|-<br />
|6||б|| ||a||2<br />
|-<br />
|7||д|| ||a||3<br />
|-<br />
|8||к|| ||a||4<br />
|-<br />
|9||р|| ||б||5<br />
|-<br />
|10||р|| ||б||6<br />
|}<br />
<br />
Здесь слева отсортированный данный столбец, чтобы мы знали, какое место в лексикографическом порядке занимает приписываемый нами символ среди всех элементов данного нам изначально столбца. Справа - изначально данный столбец и соответствующее ему число. Поскольку в нашем алгоритме новый столбец приписывается в начало, то мы из состояния <tex> i </tex> (левый столбец) переходим в состояние <tex> j </tex> (правый). Для того, чтобы восстановить строку, нам необходимо от последней такой цифры по пути из <tex> j </tex> в <tex> i </tex> восстановить строку.<br />
{|<br />
|<br />
{| border="1"<br />
|6<br />
|→<br />
|10<br />
|→<br />
|4 <br />
|→<br />
|8<br />
|→ <br />
|3<br />
|→<br />
|7<br />
|→<br />
|1<br />
|→<br />
|5<br />
|→<br />
|9<br />
|→<br />
|0<br />
|→<br />
|2<br />
|-<br />
|а<br />
|<br />
|б<br />
|<br />
|р<br />
|<br />
|а<br />
|<br />
|к<br />
|<br />
|а<br />
|<br />
|д<br />
|<br />
|а<br />
|<br />
|б<br />
|<br />
|р<br />
|<br />
|а<br />
|}<br />
===Сложность оптимизированного алгоритма===<br />
Данный алгоритм работает за <tex>O(N\log{N})</tex> времени и требует <tex>O(N)</tex> памяти. Однако, если размер алфавита не очень большой, то для выяснения первого столбца матрицы можно использовать сортировку подсчетом, в этом случае алгоритм работает за <tex>O(N+M)</tex> действий и требует <tex>O(N+M)</tex> памяти, где <tex>M</tex> — размер алфавита.<br />
<br />
===Псевдокод оптимизированного алгоритма===<br />
Пусть <tex> N </tex> — количество символов во входной строке, <tex> M </tex> — количество символов в алфавите, <tex> k </tex> — номер исходной строки в матрице перестановок, <tex> s </tex> — входящая строка, <tex> count </tex> — массив для сортировки подсчетом, <tex> t </tex> — вектор обратного преобразования, <tex> x </tex> — номер данной нам строки в таблице.<br />
<br />
// Cчитаем частоты символов<br />
for i = 0 .. M <br />
count[i] = 0<br />
for i = 0 .. N <br />
count[s[i]]++<br />
// Упорядочиваем символы, чтобы получить первый столбец исходной матрицы<br />
// count[i] указывает на первую позицию символа i в первом столбце<br />
sum = 0<br />
for i = 0 .. M<br />
sum = sum + count[i]<br />
count[i] = sum - count[i]<br />
// Cоздаем вектор обратного преобразования<br />
for i = 0 .. N<br />
t[count[s[i]]] = i<br />
count[s[i]]++<br />
// И восстанавливаем исходный текст<br />
j = t[x]<br />
for i = 0 .. N<br />
print(s[j])<br />
j = t[j]<br />
<br />
===Доказательство корректности===<br />
<br />
Пусть текст <tex>T</tex> состоит из <tex>N + 1</tex> символов, занумерованных с нуля: <tex>T[0..N]</tex>. Буквы <tex>T[i]</tex> принадлежат некоторому алфавиту <tex>A</tex>. Лексикографический порядок (строгий) на строках из алфавита <tex>A</tex> будем обозначать <tex>\preceq (\prec)</tex>. Обозначим через <tex>S_{k}T</tex> циклический сдвиг текста <tex>T</tex> на <tex>k</tex> символов влево:<br />
:{|<br />
<tex> S_{k}T = T[(j + k) (mod\ N + 1)] </tex><br />
|}<br />
<br />
Существует перестановка <tex>p</tex> чисел <tex>\{0, ..., N\}</tex>, которая удовлетворяет условию: <br />
:{|<br />
<tex> S_{p(i)}T \preceq S_{p(i + 1)}T,\ i = 0, ..., N - 1\ \ \textbf{(1)}</tex><br />
|}<br />
<br />
Преобразование Барроуза-Уилера текста <tex>T</tex> есть текст <tex>B[0..N] = BW(T)</tex>, буквы которого заданы соотношением:<br />
:{|<br />
<tex>B[i] = S_{p(i)}T[N]</tex>, другими словами <tex>B[i] = S_{p(i) - 1}T[0] = T[(p(i) - 1) (mod\ N + 1)] \ \ \textbf{(2)}</tex><br />
|}<br />
<br />
Пусть <tex>\sigma</tex> {{---}} перестановка чисел <tex>\{0, ..., N\}</tex>, удовлетворяющая условию:<br />
:{|<br />
<tex>B_{\sigma(i)} \preceq B_{\sigma(i + 1)}</tex>, при <tex>i = 0, ..., N - 1\ \ \textbf{(3)}</tex>,<br />
|}<br />
и в случае равенства <tex>B_{\sigma(i)}</tex> и <tex>B_{\sigma(i + 1)}</tex> выполнено {{---}} <tex>\sigma(i) < \sigma(i + 1)</tex>. Перестановка однозначно определяется текстом <tex>B</tex> и ее можно посчитать за <tex>O(N)</tex>, используя сортировку подсчетом. Рассмотрим перестановку <tex>\sigma</tex> как отображение <tex>\sigma : \{0, ..., N\} \to \{0, ..., N\}</tex>. Пусть <tex>\sigma^{k}</tex> копмозиция <tex>k</tex> отображений <tex>\sigma^{k} = \sigma^{k - 1} \circ \sigma</tex>, где <tex>\sigma^{1} = \sigma, \sigma^{0} \equiv i</tex>.<br />
<br />
{{Теорема<br />
|statement=<br />
<br />
''При всех <tex>m = 1, ..., N + 1</tex> верны утверждения,<br />
:<tex>B_{\sigma(i)}...B_{\sigma^{m}(i)} \preceq B_{\sigma(i + 1)}...B_{\sigma^{m}(i + 1)}</tex>, при <tex>i = 0, ..., N - 1\ \ \textbf{(4)}</tex><br />
:<tex>B_iB_{\sigma(i)}...B_{\sigma^{m - 1}(i)} = S_{p(i) - 1}T[0..m - 1]</tex>, при <tex>i = 0, ..., N\ \ \textbf{(5)}</tex><br />
''<br />
<br />
|proof=<br />
<br />
Если лексикографически отсортировать буквы последнего столбца и поместить их в первый столбец, то получится таблица<br />
<br />
| class="wikitable" style="text-align:center"<br />
|-<br />
!Таблица<br />
|-<br />
|a||b||c<br />
|-<br />
|a||b||c<br />
|<br />
<br />
<br />
}}<br />
<br />
{{Теорема<br />
|statement=<br />
<br />
''Для восстановления исходного текста <tex>T</tex> из преобразования <tex>B</tex> достаточно знать число <tex>I</tex>, отвечающее условию <tex>p(I) = 0</tex>, другими словами <tex>S_{p(I)}T = T</tex>.''<br />
<br />
}}<br />
<br />
== Дополнительно ==<br />
<br />
* bzip2 использует преобразование Барроуза {{---}} Уилера для превращения последовательностей многократно чередующихся символов в строки одинаковых символов, затем применяет преобразование MTF (англ. move-to-front), и в конце кодирование Хаффмана.<br />
<br />
== Ссылки ==<br />
*[http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%91%D0%B0%D1%80%D1%80%D0%BE%D1%83%D0%B7%D0%B0_%E2%80%94_%D0%A3%D0%B8%D0%BB%D0%B5%D1%80%D0%B0 Преобразование Барроуза {{---}} Уилера (Википедия)]<br />
<br />
*[http://www.cs.karelia.ru/~aborod/inf/2010/schedule.php.ru Преобразование Барроуза {{---}} Уилера (cs.karelia.ru)]<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Алгоритмы сжатия ]]</div>Evarand