Преобразование Барроуза-Уилера — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
(Доказательство корректности наивного алгоритма)
м (rollbackEdits.php mass rollback)
 
(не показано 10 промежуточных версий 4 участников)
Строка 1: Строка 1:
== Определение ==
 
  
 
'''Преобразование Барроуза {{---}} Уилера''' (англ. ''Burrows-Wheeler transform'') {{---}} алгоритм, используемый для предварительной обработки данных перед сжатием, разработанный для улучшения эффективности последующего кодирования. Преобразование Барроуза {{---}} Уилера меняет порядок символов во входной строке таким образом, что повторяющиеся подстроки образуют на выходе идущие подряд последовательности одинаковых символов.
 
'''Преобразование Барроуза {{---}} Уилера''' (англ. ''Burrows-Wheeler transform'') {{---}} алгоритм, используемый для предварительной обработки данных перед сжатием, разработанный для улучшения эффективности последующего кодирования. Преобразование Барроуза {{---}} Уилера меняет порядок символов во входной строке таким образом, что повторяющиеся подстроки образуют на выходе идущие подряд последовательности одинаковых символов.
Строка 5: Строка 4:
 
== Описание алгоритма ==
 
== Описание алгоритма ==
  
Преобразование выполняется в три этапа.
+
Преобразование выполняется в три этапа:
* Составляется таблица всех циклических сдвигов входной строки.
+
# Составляется таблица всех циклических сдвигов входной строки.
* Производится лексикографическая (в алфавитном порядке) сортировка строк таблицы.
+
# Производится лексикографическая (в алфавитном порядке) сортировка строк таблицы.
* В качестве выходной строки выбирается последний столбец таблицы преобразования и номер строки, совпадающей с исходной.
+
# В качестве выходной строки выбирается последний столбец таблицы преобразования и номер строки, совпадающей с исходной.
  
 
== Пример работы алгоритма ==
 
== Пример работы алгоритма ==
  
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA".  
+
Пусть нам дана исходная строка <tex>s =</tex> "ABACABA".  
  
{| border="1"
+
{| class="wikitable"
 
!colspan="4"|Трансформация
 
!colspan="4"|Трансформация
 
|-
 
|-
! Вход || Все<br />Перестановки || Сортировка<br />Строк || Выход
+
! Вход || Все<br />циклические <br /> сдвиги || Сортировка<br />строк || Выход
 
|-
 
|-
 
|
 
|
<font color="red">ABACABA</font>
+
<font color="red">ABACABA</font>
|
+
|style="text-align:center;"|
<font color="red">ABACABA</font>
+
<font color="red">ABACABA</font> <br/>
BACABAA
+
BACABAA<br/>
ACABAAB
+
ACABAAB<br/>
CABAABA
+
CABAABA<br/>
ABAABAC
+
ABAABAC<br/>
BAABACA
+
BAABACA<br/>
AABACAB
+
AABACAB<br/>
 +
|style="text-align:center;"|
 +
AABACAB<br/>
 +
ABAABAC<br/>
 +
<font color="red">ABACABA</font><br/>
 +
ACABAAB<br/>
 +
BAABACA<br/>
 +
BACABAA<br/>
 +
CABAABA <br/>
 
|
 
|
AABACAB
+
BCABAAA, 3
ABAABAC
 
<font color="red">ABACABA</font>
 
ACABAAB
 
BAABACA
 
BACABAA
 
CABAABA
 
|
 
BCABAAA, 3
 
 
|}
 
|}
  
Результат можно записать так: <tex>$BWT(s) = $(</tex>"BCABAAA", 3<tex>)</tex>, где 3 {{---}} номер исходной строки в отсортированной матрице. Он нужен для обратного преобразования.  
+
Результат можно записать так: <tex>BWT(s) = (</tex>"BCABAAA", <tex>3)</tex>, где <tex>3</tex> {{---}} номер исходной строки в отсортированной матрице. Он нужен для обратного преобразования.  
  
  
Следует заметить, что иногда в исходной строке приводится так называемый символ конца строки ''$'', который в преобразовании будет считаться последним (максимальным) символом, тогда сохранение номера исходной строки не требуется.
+
Следует заметить, что иногда в исходной строке приводится так называемый символ конца строки <tex>\$</tex>, который в преобразовании будет считаться последним (максимальным) символом, тогда сохранение номера исходной строки не требуется.
  
  
Пусть нам дана исходная строка <tex>$s =$</tex> "ABACABA$".
+
Пусть нам дана исходная строка <tex>s =</tex> "ABACABA$".
  
{| border="1"
+
{| class="wikitable"
 
!colspan="4"|Трансформация
 
!colspan="4"|Трансформация
 
|-
 
|-
! Вход || Все<br />Перестановки || Сортировка<br />Строк || Выход
+
! Вход || Все<br /> циклические <br/> сдвиги || Сортировка<br />строк || Выход
 
|-
 
|-
 
|
 
|
<font color="red">ABACABA$</font>
+
<font color="red">ABACABA$</font>
|
+
|style="text-align:center;"|
<font color="red">ABACABA$</font>
+
<span class="tex2jax_ignore"><font color="red">ABACABA$</font><br/>
BACABA$A
+
BACABA$A<br/>
ACABA$AB
+
ACABA$AB<br/>
CABA$ABA
+
CABA$ABA<br/>
ABA$ABAC
+
ABA$ABAC<br/>
BA$ABACA
+
BA$ABACA<br/>
A$ABACAB
+
A$ABACAB<br/>
$ABACABA
+
$ABACABA</span>
 
+
|style="text-align:center;"|
 +
<span class="tex2jax_ignore"><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</span>
 
|
 
|
<font color="red">ABACABA$</font>
+
$CBBAAAA
ABA$ABAC
 
ACABA$AB
 
A$ABACAB
 
BACABA$A
 
BA$ABACA
 
CABA$ABA
 
$ABACABA
 
|
 
$CBBAAAA
 
 
|}  
 
|}  
  
  
  
При аналогичном вышеприведённом преобразовании та строчка в матрице, которая будет заканчиваться на символ конца строки, и будет исходной: ("ABACABA$"). Тогда результат можно записать так: <tex>$BWT(s) =$</tex> "$CBBAAAA".
+
При аналогичном вышеприведённом преобразовании та строчка в матрице, которая будет заканчиваться на символ конца строки, и будет исходной: ("ABACABA$"). Тогда результат можно записать так: <tex>BWT(s) =</tex> "$CBBAAAA".
  
 
== Обратное преобразование ==
 
== Обратное преобразование ==
Строка 87: Строка 85:
 
===Наивный алгоритм===
 
===Наивный алгоритм===
  
Пусть нам дано: <tex>$BWT(s) =$(</tex>"BCABAAA", 3<tex>)</tex>. Тогда выпишем в столбик нашу преобразованную последовательность символов "BCABAAA". Запишем её как последний столбик предыдущей матрицы (при прямом преобразовании Барроуза {{---}} Уилера), при этом все предыдущие столбцы оставляем пустыми. Далее построчно отсортируем матрицу, затем в предыдущий столбец запишем "BCABAAA". Опять построчно отсортируем матрицу. Продолжая таким образом, можно восстановить полный список всех циклических перестановок строки, которую нам надо найти. Выстроив полный отсортированный список перестановок, выберем строку с номером, который нам был изначально дан. В итоге мы получим искомую строку.
+
Пусть нам дано: <tex>BWT(s) =(</tex>"BCABAAA", <tex>3)</tex>. Тогда выпишем в столбик нашу преобразованную последовательность символов "BCABAAA". Запишем её как последний столбик предыдущей матрицы (при прямом преобразовании Барроуза {{---}} Уилера), при этом все предыдущие столбцы оставляем пустыми. Далее построчно [[Сортировки | отсортируем]] матрицу, затем в предыдущий столбец запишем "BCABAAA". Опять построчно отсортируем матрицу. Продолжая таким образом, можно восстановить полный список всех циклических сдвигов строки, которую нам надо найти. Выстроив полный отсортированный список сдвигов, выберем строку с номером, который нам был изначально дан. В итоге мы получим искомую строку.
 
Алгоритм обратного преобразования описан в таблице ниже:
 
Алгоритм обратного преобразования описан в таблице ниже:
  
{| border="1"
+
{| class="wikitable"
 
!colspan="8"| Обратное преобразование
 
!colspan="8"| Обратное преобразование
 
|-
 
|-
Строка 96: Строка 94:
 
|-
 
|-
 
|align="center" colspan="8"|
 
|align="center" colspan="8"|
BCABAAA
+
BCABAAA
 
|-
 
|-
 
! Добавление 1 || Сортировка 1 || Добавление 2 || Сортировка 2 || Добавление 3 || Сортировка 3 || Добавление 4  
 
! Добавление 1 || Сортировка 1 || Добавление 2 || Сортировка 2 || Добавление 3 || Сортировка 3 || Добавление 4  
Строка 221: Строка 219:
 
|-
 
|-
 
|align="center" colspan="8"|
 
|align="center" colspan="8"|
<font color="red">ABACABA</font>
+
<font color="red">ABACABA</font>
 
|}
 
|}
  
Следует также заметить, что если нам было бы дано <tex>$BWT(s) = $</tex> "$CBBAAAA", то мы также получили бы нашу исходную строку, только с символом конца строки ''$'' на конце: ''ABACABA$''.
+
Следует также заметить, что если нам было бы дано <tex>BWT(s) = </tex> "$CBBAAAA", то мы также получили бы нашу исходную строку, только с символом конца строки <tex>\$</tex> на конце: ABACABA$.
  
 
Временная сложность данного алгоритма <tex>O(N^3\log{N}) </tex>, пространственная <tex>O(N^2)</tex>.
 
Временная сложность данного алгоритма <tex>O(N^3\log{N}) </tex>, пространственная <tex>O(N^2)</tex>.
  
===Доказательство корректности===
+
====Доказательство корректности====
  
Пусть дана строка <tex>$s$</tex>, к которой было применено преобразование BWT. Докажем, что при использовании наивного алгоритма на каждом шаге получающийся набор строк соответствует суффиксам циклических перестановок исходной строки, методом математической индукции.
+
Пусть дана строка <tex>s</tex>, к которой было применено преобразование BWT. Докажем, что при использовании наивного алгоритма на каждом шаге получающийся набор строк соответствует суффиксам циклических сдвигов исходной строки, методом математической индукции.
* База. Циклически сдвинем все строки исходной таблицы на 1 влево. Тогда в столбце <tex>n</tex> будут находиться символы, добавленные на первом шаге алгоритма, а в столбце <tex>n - 1</tex> символы, изначально стоявшие в таблице до первого шага алгоритма. Таким образом, полученные на первом шаге алгоритма строки являются суффиксами циклических перестановок строки <tex>$s$</tex>.
+
* '''База'''. Циклически сдвинем все строки исходной таблицы на <tex>1</tex> влево. Тогда в столбце <tex>n</tex> будут находиться символы, добавленные на первом шаге алгоритма, а в столбце <tex>n - 1</tex> символы, изначально стоявшие в таблице до первого шага алгоритма. Таким образом, полученные на первом шаге алгоритма строки являются суффиксами циклических сдвигов строки <tex>s</tex>.
* Предположение. Пусть на <tex>k</tex> шаге алгоритма все полученные строки являются суффиксами циклических перестановок строки <tex>$s$</tex>.
+
* '''Предположение'''. Пусть на <tex>k</tex> шаге алгоритма все полученные строки являются суффиксами циклических сдвигов строки <tex>s</tex>.
* Переход. Рассмотрим <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>.
+
* '''Переход'''. Рассмотрим <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>.
  
{|border ="1"
+
{| class="wikitable"
!colspan="3" | <tex>$k+1$</tex> шаг алгоритма при <tex>$k=3$</tex>
+
!colspan="3" | <tex>k+1</tex> шаг алгоритма при <tex>k=3</tex>
 
|-
 
|-
 
! Исходная <br /> таблица || Сдвинутая <br /> таблица || Результат <br /> работы <br /> алгоритма
 
! Исходная <br /> таблица || Сдвинутая <br /> таблица || Результат <br /> работы <br /> алгоритма
|-align="center"
+
|-
|
+
|style="text-align:center;"|
<font color="red">A</font><font color="green">ABA</font>CA<font color="blue">B</font>
+
<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>
+
<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>
+
<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>
+
<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>
+
<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>
+
<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>
+
<font color="red">C</font><font color="green">ABA</font>AB<font color="blue">A</font>
|
+
|style="text-align:center;"|
CA<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font>
+
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>
+
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>
+
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>
+
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>
+
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>
+
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>
+
AB<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font>
|
+
|style="text-align:right;"|
<font color="blue">B</font><font color="red">A</font><font color="green">ABA</font>
+
<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>
+
<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>
+
<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>
+
<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>
+
<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>
+
<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>
+
<font color="blue">A</font><font color="red">C</font><font color="green">ABA</font> <br/>
 
|-
 
|-
 
|}
 
|}
  
Таким образом, поскольку на каждом шаге алгоритма получившиеся строки являлись суффиксами циклических перестановок <tex> $s$ </tex>, после последнего шага получившиеся строки будут совпадать с циклическими перестановками <tex> $s$ </tex>.
+
Таким образом, поскольку на каждом шаге алгоритма получившиеся строки являлись суффиксами циклических сдвигов <tex> s </tex>, после последнего шага получившиеся строки будут совпадать с циклическими сдвигами <tex> s </tex>.
  
===Оптимизация===
+
===Оптимизированный наивный алгоритм===
  
Однако, данный алгоритм можно оптимизировать. Заметим, что при каждом проявлении неизвестного столбца выполнялись одни и те же действия. Мы приписывали новый столбец и сортировали имеющиеся данные. На каждом шагу мы к строке, которая находилась на <tex> i </tex>-ом месте приписываем в начало <tex> i </tex> -ый элемент столбца входных данных. Пусть изначально мы знаем каким по порядку является приписанный нами в начало символ (то есть каким по порядку в столбце). И конечно же мы знаем исходя из предыдущего шага какое место занимала наша строка без этого первого символа (<tex> i </tex> -ое). Тогда несложно заметить, что при выполнении такой операции строка с номером <tex> i </tex> всегда будет перемещаться на позицию с номером <tex> j </tex>.
+
Наивный алгоритм можно оптимизировать. Заметим, что при каждом проявлении неизвестного столбца выполнялись одни и те же действия. К предыдущему приписывался новый столбец и имеющиеся данные сортировались. На каждом шаге к строке, которая находилась на <tex> i </tex>-ом месте, приписывался в начало <tex> i </tex> -ый элемент столбца входных данных. Пусть изначально известно, каким по порядку является приписанный в начало символ (то есть каким по порядку в столбце). Из предыдущего шага известно, какое место занимала строка без этого первого символа (<tex> i </tex> -ое). Тогда несложно заметить, что при выполнении такой операции строка с номером <tex> i </tex> всегда будет перемещаться на позицию с номером <tex> j </tex>.
  
  {| border="1"
+
  {| class="wikitable"
 
   |0||а||&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;||р||9
 
   |0||а||&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;||р||9
 
   |-
 
   |-
Строка 300: Строка 298:
 
{|
 
{|
 
  |
 
  |
  {| border="1"
+
  {| class="wikitable"
 
  |6
 
  |6
 
  |→
 
  |→
Строка 345: Строка 343:
 
  |а
 
  |а
 
|}
 
|}
===Сложность оптимизированного алгоритма===
+
====Сложность оптимизированного алгоритма====
 
Данный алгоритм работает за <tex>O(N\log{N})</tex> времени и требует <tex>O(N)</tex> памяти. Однако, если размер алфавита не очень большой, то для выяснения первого столбца матрицы можно использовать сортировку подсчетом, в этом случае алгоритм работает за <tex>O(N+M)</tex> действий и требует <tex>O(N+M)</tex> памяти, где <tex>M</tex> — размер алфавита.
 
Данный алгоритм работает за <tex>O(N\log{N})</tex> времени и требует <tex>O(N)</tex> памяти. Однако, если размер алфавита не очень большой, то для выяснения первого столбца матрицы можно использовать сортировку подсчетом, в этом случае алгоритм работает за <tex>O(N+M)</tex> действий и требует <tex>O(N+M)</tex> памяти, где <tex>M</tex> — размер алфавита.
  
===Псевдокод оптимизированного алгоритма===
+
====Псевдокод оптимизированного алгоритма====
Пусть <tex> N </tex> — количество символов во входной строке, <tex> M </tex> — количество символов в алфавите, <tex> k </tex> — номер исходной строки в матрице перестановок, <tex> s </tex> — входящая строка, <tex> count </tex>  — массив для сортировки подсчетом, <tex> t </tex> — вектор обратного преобразования, <tex> x </tex> — номер данной нам строки в таблице.
+
Пусть <tex> N </tex> — количество символов во входной строке, <tex> M </tex> — количество символов в алфавите, <tex> k </tex> — номер исходной строки в матрице сдвигов, <tex> s </tex> — входящая строка, <tex> count </tex>  — массив для сортировки подсчетом, <tex> t </tex> — вектор обратного преобразования, <tex> x </tex> — номер данной нам строки в таблице.
  
// Cчитаем частоты символов
+
  '''function''' reverseBWT(N : Int, M : Int, k : Int, s : String): Int[]
for i = 0 .. M  
+
    <font color="green">// Cчитаем частоты символов</font>
  count[i] = 0
+
    '''for''' i = 0 .. M  
for i = 0 .. N  
+
      count[i] = 0
  count[s[i]]++
+
    '''for''' i = 0 .. N  
// Упорядочиваем символы, чтобы получить первый столбец исходной матрицы
+
      count[s[i]]++
// count[i] указывает на первую позицию символа i в первом столбце
+
    <font color="green">// Упорядочиваем символы, чтобы получить первый столбец исходной матрицы</font>
sum = 0
+
    <font color="green">// count[i] указывает на первую позицию символа i в первом столбце</font>
for i = 0 .. M
+
    sum = 0
  sum = sum + count[i]
+
    '''for''' i = 0 .. M
  count[i] = sum - count[i]
+
      sum = sum + count[i]
// Cоздаем вектор обратного преобразования
+
      count[i] = sum - count[i]
for i = 0 .. N
+
    <font color="green">// Cоздаем вектор обратного преобразования</font>
  t[count[s[i]]] = i
+
    '''for''' i = 0 .. N
  count[s[i]]++
+
    t[count[s[i]]] = i
// И восстанавливаем исходный текст
+
    count[s[i]]++
j = t[x]
+
    <font color="green">// И восстанавливаем исходный текст</font>
for i = 0 .. N
+
    j = t[x]
  print(s[j])
+
    '''for''' i = 0 .. N
  j = t[j]
+
      answer[i] = s[j]
 +
      j = t[j]
 +
    '''return''' answer
  
===Доказательство корректности===
+
====Доказательство корректности====
  
 
Пусть текст <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> символов влево:
 
Пусть текст <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> символов влево:
 
:{|
 
:{|
<tex> S_{k}T = T[(j + k) (mod\ N + 1)] </tex>
+
<tex> S_{k}T = T[(j + k) (\bmod\ N + 1)] </tex>
 
|}
 
|}
  
Строка 386: Строка 386:
 
Преобразование Барроуза-Уилера текста <tex>T</tex> есть текст <tex>B[0..N] = BW(T)</tex>, буквы которого заданы соотношением:
 
Преобразование Барроуза-Уилера текста <tex>T</tex> есть текст <tex>B[0..N] = BW(T)</tex>, буквы которого заданы соотношением:
 
:{|
 
:{|
<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>
+
<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>
 
|}
 
|}
  
Строка 426: Строка 426:
 
}}
 
}}
  
== Дополнительно ==
+
===Алгоритм за линейное время===
 +
 
 +
Будем обозначать <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> в таблице. Предподсчитаем следующие величины:
 +
* Для каждого <tex>L_i</tex> количество символов на подстроке <tex>l_0, \ldots , l_{i-1}</tex>, равных <tex>L_i</tex>
 +
* Для каждого уникального <tex>L_i</tex> количество символов в <tex>L</tex>, лексикографически меньших, чем <tex>L_i</tex>
 +
 
 +
Пример для <tex>BWT(s) =</tex> "BCABAAA":
 +
 
 +
{| class="wikitable"
 +
!colspan="3" | Таблица первого предподсчёта
 +
|-
 +
! Позиция || Символ || Результат
 +
|-align="center"
 +
! 0 || B || 0
 +
|-
 +
! 1 || C || 0
 +
|-
 +
! 2 || A || 0
 +
|-
 +
! 3 || B || 1
 +
|-
 +
! 4 || A || 1
 +
|-
 +
! 5 || A || 2
 +
|-
 +
! 6 || A || 3
 +
|}
 +
 
 +
{| class="wikitable"
 +
!colspan="2" | Таблица второго предподсчёта
 +
|-
 +
! Символ || Количество  <br /> меньших
 +
|-align="center"
 +
! A || 0
 +
|-
 +
! B || 4
 +
|-
 +
! C || 6
 +
|}
 +
 
 +
Для удобства пронумеруем известные нам данные:
 +
# <tex>L</tex>, последний столбец таблицы сдвигов
 +
# <tex>I</tex>, номер строки <tex>s</tex> в таблице сдвигов
 +
# Частота, с которой символ <tex>L_{i}</tex> встречается в подстроке <tex>l_0, \ldots , l_{i-1}</tex>
 +
# Для каждого уникального символа количество лексикографически меньших символов в <tex>L</tex>
 +
 
 +
Символ <tex>s_{n-1}</tex> находится в строке <tex>L</tex> под номером <tex>I</tex>, так как в таблице строка <tex>s^0</tex> имела номер <tex>I</tex>. Найдём символ <tex>s_{n-2}</tex>.
 +
 
 +
Символ <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>. Посчитаем, на каком месте в таблице будет стоять строка, начинающаяся с этого символа.
 +
 
 +
Из 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>.
 +
 
 +
Тогда сумма этих двух величин является номером символа <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>.
 +
 
 +
Предподсчёт занимает <tex>O(n)</tex> времени, восстановление каждого из <tex>n</tex> символов занимает <tex>O(1)</tex> времени. Суммарное время работы алгоритма <tex>O(n)</tex>.
 +
 
 +
Пример работы для <tex>BWT(s) = (</tex>"BCABAAA", 2<tex>)</tex> (нумерация с 0):
 +
* <tex>s^0 = .......</tex>
 +
* <tex>s_6=L_2 = A</tex>. Тогда <tex>s^0=......</tex>A
 +
* Суммируем значения из двух таблиц: <tex>0+0=0</tex>, <tex>s_5=L_0=B</tex>, <tex>s^0=.....</tex>BA
 +
* Суммируем: <tex>0+4=4</tex>, <tex>s_4=L_4=A</tex>, <tex>s^0=....</tex>ABA
 +
* Суммируем: <tex>1+0=1</tex>, <tex>s_3=L_1=C</tex>, <tex>s^0=...</tex>CABA
 +
* Суммируем: <tex>0+6=6</tex>, <tex>s_2=L_6=A</tex>, <tex>s^0=..</tex>ACABA
 +
* Суммируем: <tex>3+0=3</tex>, <tex>s_2=L_3=B</tex>, <tex>s^0=.</tex>BACABA
 +
* Суммируем: <tex>1+4=5</tex>, <tex>s_2=L_5=A</tex>, <tex>s^0=</tex> ABACABA
 +
 
 +
== Замечания ==
 +
 
 +
* bzip2<ref>[https://ru.wikipedia.org/wiki/Bzip2 bzip2]</ref> использует преобразование Барроуза {{---}} Уилера для превращения последовательностей многократно чередующихся символов в строки одинаковых символов, затем применяет преобразование [[Преобразование_MTF | MTF]], и в конце кодирование Хаффмана.
 +
 
 +
== См. также ==
 +
* [[Алгоритм_Хаффмана | Алгоритм Хаффмана]]
 +
* [[Алгоритмы_LZ77_и_LZ78 | Алгоритмы LZ77 и LZ78]]
 +
* [[Арифметическое_кодирование | Арифметическое кодирование]]
  
* bzip2 использует преобразование Барроуза {{---}} Уилера для превращения последовательностей многократно чередующихся символов в строки одинаковых символов, затем применяет преобразование MTF (англ. move-to-front), и в конце кодирование Хаффмана.
+
== Примечания ==
 +
<references/>
  
== Ссылки ==
+
== Источники информации ==
*[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 Преобразование Барроуза {{---}} Уилера (Википедия)]
+
*[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 Википедия: Преобразование Барроуза {{---}} Уилера]
  
*[http://www.cs.karelia.ru/~aborod/inf/2010/schedule.php.ru Преобразование Барроуза {{---}} Уилера (cs.karelia.ru)]
+
*[http://www.cs.karelia.ru/~aborod/inf/2010/schedule.php.ru cs.karelia.ru: Преобразование Барроуза {{---}} Уилера]
  
 
[[Категория: Дискретная математика и алгоритмы]]
 
[[Категория: Дискретная математика и алгоритмы]]
  
 
[[Категория: Алгоритмы сжатия ]]
 
[[Категория: Алгоритмы сжатия ]]

Текущая версия на 19:14, 4 сентября 2022

Преобразование Барроуза — Уилера (англ. Burrows-Wheeler transform) — алгоритм, используемый для предварительной обработки данных перед сжатием, разработанный для улучшения эффективности последующего кодирования. Преобразование Барроуза — Уилера меняет порядок символов во входной строке таким образом, что повторяющиеся подстроки образуют на выходе идущие подряд последовательности одинаковых символов.

Описание алгоритма

Преобразование выполняется в три этапа:

  1. Составляется таблица всех циклических сдвигов входной строки.
  2. Производится лексикографическая (в алфавитном порядке) сортировка строк таблицы.
  3. В качестве выходной строки выбирается последний столбец таблицы преобразования и номер строки, совпадающей с исходной.

Пример работы алгоритма

Пусть нам дана исходная строка [math]s =[/math] "ABACABA".

Трансформация
Вход Все
циклические
сдвиги
Сортировка
строк
Выход

ABACABA

ABACABA
BACABAA
ACABAAB
CABAABA
ABAABAC
BAABACA
AABACAB

AABACAB
ABAABAC
ABACABA
ACABAAB
BAABACA
BACABAA
CABAABA

BCABAAA, 3

Результат можно записать так: [math]BWT(s) = ([/math]"BCABAAA", [math]3)[/math], где [math]3[/math] — номер исходной строки в отсортированной матрице. Он нужен для обратного преобразования.


Следует заметить, что иногда в исходной строке приводится так называемый символ конца строки [math]\$[/math], который в преобразовании будет считаться последним (максимальным) символом, тогда сохранение номера исходной строки не требуется.


Пусть нам дана исходная строка [math]s =[/math] "ABACABA$".

Трансформация
Вход Все
циклические
сдвиги
Сортировка
строк
Выход

ABACABA$

ABACABA$
BACABA$A
ACABA$AB
CABA$ABA
ABA$ABAC
BA$ABACA
A$ABACAB
$ABACABA

ABACABA$
ABA$ABAC
ACABA$AB
A$ABACAB
BACABA$A
BA$ABACA
CABA$ABA
$ABACABA

$CBBAAAA


При аналогичном вышеприведённом преобразовании та строчка в матрице, которая будет заканчиваться на символ конца строки, и будет исходной: ("ABACABA$"). Тогда результат можно записать так: [math]BWT(s) =[/math] "$CBBAAAA".

Обратное преобразование

Наивный алгоритм

Пусть нам дано: [math]BWT(s) =([/math]"BCABAAA", [math]3)[/math]. Тогда выпишем в столбик нашу преобразованную последовательность символов "BCABAAA". Запишем её как последний столбик предыдущей матрицы (при прямом преобразовании Барроуза — Уилера), при этом все предыдущие столбцы оставляем пустыми. Далее построчно отсортируем матрицу, затем в предыдущий столбец запишем "BCABAAA". Опять построчно отсортируем матрицу. Продолжая таким образом, можно восстановить полный список всех циклических сдвигов строки, которую нам надо найти. Выстроив полный отсортированный список сдвигов, выберем строку с номером, который нам был изначально дан. В итоге мы получим искомую строку. Алгоритм обратного преобразования описан в таблице ниже:

Обратное преобразование
Вход

BCABAAA

Добавление 1 Сортировка 1 Добавление 2 Сортировка 2 Добавление 3 Сортировка 3 Добавление 4
B
C
A
B
A
A
A
A
A
A
A
B
B
C
BA
CA
AA
BA
AB
AB
AC
AA
AB
AB
AC
BA
BA
CA
BAA
CAB
AAB
BAC
ABA
ABA
ACA
AAB
ABA
ABA
ACA
BAA
BAC
CAB
BAAB
CABA
AABA
BACA
ABAA
ABAC
ACAB
Сортировка 4 Добавление 5 Сортировка 5 Добавление 6 Сортировка 6 Добавление 7 Сортировка 7
AABA
ABAA
ABAC
ACAB
BAAB
BACA
CABA
BAABA
CABAA
AABAC
BACAB
ABAAB
ABACA
ACABA
AABAC
ABAAB
ABACA
ACABA
BAABA
BACAB
CABAA
BAABAC
CABAAB
AABACA
BACABA
ABAABA
ABACAB
ACABAA
AABACA
ABAABA
ABACAB
ACABAA
BAABAC
BACABA
CABAAB
BAABACA
CABAABA
AABACAB
BACABAA
ABAABAC
ABACABA
ACABAAB
AABACAB
ABAABAC
ABACABA
ACABAAB
BAABACA
BACABAA
CABAABA
Результат

ABACABA

Следует также заметить, что если нам было бы дано [math]BWT(s) = [/math] "$CBBAAAA", то мы также получили бы нашу исходную строку, только с символом конца строки [math]\$[/math] на конце: ABACABA$.

Временная сложность данного алгоритма [math]O(N^3\log{N}) [/math], пространственная [math]O(N^2)[/math].

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

Пусть дана строка [math]s[/math], к которой было применено преобразование BWT. Докажем, что при использовании наивного алгоритма на каждом шаге получающийся набор строк соответствует суффиксам циклических сдвигов исходной строки, методом математической индукции.

  • База. Циклически сдвинем все строки исходной таблицы на [math]1[/math] влево. Тогда в столбце [math]n[/math] будут находиться символы, добавленные на первом шаге алгоритма, а в столбце [math]n - 1[/math] символы, изначально стоявшие в таблице до первого шага алгоритма. Таким образом, полученные на первом шаге алгоритма строки являются суффиксами циклических сдвигов строки [math]s[/math].
  • Предположение. Пусть на [math]k[/math] шаге алгоритма все полученные строки являются суффиксами циклических сдвигов строки [math]s[/math].
  • Переход. Рассмотрим [math]k+1[/math]-ый шаг алгоритма. Все строки отсортированы, поэтому самый левый столбец совпадет с [math]1[/math] столбцом исходной таблицы. Циклически сдвинем все строки исходной таблицы на [math]n - k[/math] символов вправо. Теперь по предположению первые [math]k[/math] символов справа в каждой строке совпадают у исходной таблицы и у таблицы, полученной в результате работы алгоритма. [math]k[/math]-ые справа столбцы также совпадают. Добавленный на [math]k+1[/math]-ом шаге столбец также совпадает с [math]k+1[/math]-ым справа столбцом сдвинутой исходной таблицы, так как совпадает с последним столбцом исходной таблицы, которая была сдвинута на [math]n-k[/math].
[math]k+1[/math] шаг алгоритма при [math]k=3[/math]
Исходная
таблица
Сдвинутая
таблица
Результат
работы
алгоритма

AABACAB
ABAABAC
ABACABA
ACABAAB
BAABACA
BACABAA
CABAABA

CABAABA
BACABAA
ABAABAC
AABACAB
ACABAAB
BAABACA
ABACABA

BAABA
CABAA
AABAC
BACAB
ABAAB
ABACA
ACABA

Таким образом, поскольку на каждом шаге алгоритма получившиеся строки являлись суффиксами циклических сдвигов [math] s [/math], после последнего шага получившиеся строки будут совпадать с циклическими сдвигами [math] s [/math].

Оптимизированный наивный алгоритм

Наивный алгоритм можно оптимизировать. Заметим, что при каждом проявлении неизвестного столбца выполнялись одни и те же действия. К предыдущему приписывался новый столбец и имеющиеся данные сортировались. На каждом шаге к строке, которая находилась на [math] i [/math]-ом месте, приписывался в начало [math] i [/math] -ый элемент столбца входных данных. Пусть изначально известно, каким по порядку является приписанный в начало символ (то есть каким по порядку в столбце). Из предыдущего шага известно, какое место занимала строка без этого первого символа ([math] i [/math] -ое). Тогда несложно заметить, что при выполнении такой операции строка с номером [math] i [/math] всегда будет перемещаться на позицию с номером [math] j [/math].

0 а       р 9
1 а д 7
2 а a 0
3 а к 8
4 а р 10
5 б a 1
6 б a 2
7 д a 3
8 к a 4
9 р б 5
10 р б 6

Здесь слева отсортированный данный столбец, чтобы мы знали, какое место в лексикографическом порядке занимает приписываемый нами символ среди всех элементов данного нам изначально столбца. Справа - изначально данный столбец и соответствующее ему число. Поскольку в нашем алгоритме новый столбец приписывается в начало, то мы из состояния [math] i [/math] (левый столбец) переходим в состояние [math] j [/math] (правый). Для того, чтобы восстановить строку, нам необходимо от последней такой цифры по пути из [math] j [/math] в [math] i [/math] восстановить строку.

6 10 4 8 3 7 1 5 9 0 2
а б р а к а д а б р а

Сложность оптимизированного алгоритма

Данный алгоритм работает за [math]O(N\log{N})[/math] времени и требует [math]O(N)[/math] памяти. Однако, если размер алфавита не очень большой, то для выяснения первого столбца матрицы можно использовать сортировку подсчетом, в этом случае алгоритм работает за [math]O(N+M)[/math] действий и требует [math]O(N+M)[/math] памяти, где [math]M[/math] — размер алфавита.

Псевдокод оптимизированного алгоритма

Пусть [math] N [/math] — количество символов во входной строке, [math] M [/math] — количество символов в алфавите, [math] k [/math] — номер исходной строки в матрице сдвигов, [math] s [/math] — входящая строка, [math] count [/math] — массив для сортировки подсчетом, [math] t [/math] — вектор обратного преобразования, [math] x [/math] — номер данной нам строки в таблице.

 function reverseBWT(N : Int, M : Int, k : Int, s : String): Int[]
   // Cчитаем частоты символов
   for i = 0 .. M 
     count[i] = 0
   for i = 0 .. N 
     count[s[i]]++
   // Упорядочиваем символы, чтобы получить первый столбец исходной матрицы
   // count[i] указывает на первую позицию символа i в первом столбце
   sum = 0
   for i = 0 .. M
     sum = sum + count[i]
     count[i] = sum - count[i]
   // Cоздаем вектор обратного преобразования
   for i = 0 .. N
   t[count[s[i]]] = i
   count[s[i]]++
   // И восстанавливаем исходный текст
   j = t[x]
   for i = 0 .. N
     answer[i] = s[j]
     j = t[j]
   return answer

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

Пусть текст [math]T[/math] состоит из [math]N + 1[/math] символов, занумерованных с нуля: [math]T[0..N][/math]. Буквы [math]T[i][/math] принадлежат некоторому алфавиту [math]A[/math]. Лексикографический порядок (строгий) на строках из алфавита [math]A[/math] будем обозначать [math]\preceq (\prec)[/math]. Обозначим через [math]S_{k}T[/math] циклический сдвиг текста [math]T[/math] на [math]k[/math] символов влево:

[math] S_{k}T = T[(j + k) (\bmod\ N + 1)] [/math]

Существует перестановка [math]p[/math] чисел [math]\{0, ..., N\}[/math], которая удовлетворяет условию:

[math] S_{p(i)}T \preceq S_{p(i + 1)}T,\ i = 0, ..., N - 1\ \ \textbf{(1)}[/math]

Преобразование Барроуза-Уилера текста [math]T[/math] есть текст [math]B[0..N] = BW(T)[/math], буквы которого заданы соотношением:

[math]B[i] = S_{p(i)}T[N][/math], другими словами [math]B[i] = S_{p(i) - 1}T[0] = T[(p(i) - 1) (\bmod\ N + 1)] \ \ \textbf{(2)}[/math]

Пусть [math]\sigma[/math] — перестановка чисел [math]\{0, ..., N\}[/math], удовлетворяющая условию:

[math]B_{\sigma(i)} \preceq B_{\sigma(i + 1)}[/math], при [math]i = 0, ..., N - 1\ \ \textbf{(3)}[/math],

и в случае равенства [math]B_{\sigma(i)}[/math] и [math]B_{\sigma(i + 1)}[/math] выполнено — [math]\sigma(i) \lt \sigma(i + 1)[/math]. Перестановка однозначно определяется текстом [math]B[/math] и ее можно посчитать за [math]O(N)[/math], используя сортировку подсчетом. Рассмотрим перестановку [math]\sigma[/math] как отображение [math]\sigma : \{0, ..., N\} \to \{0, ..., N\}[/math]. Пусть [math]\sigma^{k}[/math] копмозиция [math]k[/math] отображений [math]\sigma^{k} = \sigma^{k - 1} \circ \sigma[/math], где [math]\sigma^{1} = \sigma, \sigma^{0} \equiv i[/math].

Теорема:
При всех [math]m = 1, ..., N + 1[/math] верны утверждения,
[math]B_{\sigma(i)}...B_{\sigma^{m}(i)} \preceq B_{\sigma(i + 1)}...B_{\sigma^{m}(i + 1)}[/math], при [math]i = 0, ..., N - 1\ \ \textbf{(4)}[/math]
[math]B_iB_{\sigma(i)}...B_{\sigma^{m - 1}(i)} = S_{p(i) - 1}T[0..m - 1][/math], при [math]i = 0, ..., N\ \ \textbf{(5)}[/math]
Доказательство:
[math]\triangleright[/math]
Если лексикографически отсортировать буквы последнего столбца и поместить их в первый столбец, то получится таблица
[math]\triangleleft[/math]
Теорема:
Для восстановления исходного текста [math]T[/math] из преобразования [math]B[/math] достаточно знать число [math]I[/math], отвечающее условию [math]p(I) = 0[/math], другими словами [math]S_{p(I)}T = T[/math].

Алгоритм за линейное время

Будем обозначать [math]s^i[/math] [math]i[/math]-ую циклический сдвиг [math]s[/math]. Пусть [math]s^0 = s_0 s_1 \ldots s_{n-1}[/math], [math]BWT(s) \;= L[/math] и [math]L = L_0L_1\ldots L_{n-1}[/math], [math]I[/math] -- номер строки [math]s^0[/math] в таблице. Предподсчитаем следующие величины:

  • Для каждого [math]L_i[/math] количество символов на подстроке [math]l_0, \ldots , l_{i-1}[/math], равных [math]L_i[/math]
  • Для каждого уникального [math]L_i[/math] количество символов в [math]L[/math], лексикографически меньших, чем [math]L_i[/math]

Пример для [math]BWT(s) =[/math] "BCABAAA":

Таблица первого предподсчёта
Позиция Символ Результат
0 B 0
1 C 0
2 A 0
3 B 1
4 A 1
5 A 2
6 A 3
Таблица второго предподсчёта
Символ Количество
меньших
A 0
B 4
C 6

Для удобства пронумеруем известные нам данные:

  1. [math]L[/math], последний столбец таблицы сдвигов
  2. [math]I[/math], номер строки [math]s[/math] в таблице сдвигов
  3. Частота, с которой символ [math]L_{i}[/math] встречается в подстроке [math]l_0, \ldots , l_{i-1}[/math]
  4. Для каждого уникального символа количество лексикографически меньших символов в [math]L[/math]

Символ [math]s_{n-1}[/math] находится в строке [math]L[/math] под номером [math]I[/math], так как в таблице строка [math]s^0[/math] имела номер [math]I[/math]. Найдём символ [math]s_{n-2}[/math].

Символ [math]s_{n-2}[/math] имеет в строке [math]L[/math] тот же номер, что строка [math]s^{n-1}[/math] имела в таблице сдвигов: строка [math]s^{n-1}[/math] начинается с символа [math]s_{n-1}[/math], [math]s_{n-2}[/math] находится на 1 левее его и из-за циклического сдвига оказывается в последнем столбце. Нам известен символ [math]s_{n-1}[/math]. Посчитаем, на каком месте в таблице будет стоять строка, начинающаяся с этого символа.

Из 4 известно количество символов, меньших [math]s_{n-1}[/math]. Все строки, начинающиеся с этих символов, стоят в таблице раньше [math]s^{n-1}[/math]. Кроме того, в таблице есть строки, начинающиеся с того же символа, что и [math]s^{n-1}[/math]. Из 3 известно, сколько их: если символ, равный [math]s_{n-1}[/math], встречался в [math]L[/math] раньше, чем [math]s_{n-1}[/math], то в таблице строка, начинающаяся с этого символа, тоже стоит раньше строки, начинающейся с [math]s_{n-1}[/math], так как префикс строки, оканчивающейся на этот символ, меньше префикса строки, оканчивающейся на [math]s_{n-1}[/math].

Тогда сумма этих двух величин является номером символа [math]s_{n-2}[/math] в строке [math]L[/math]. Зная [math]s_{n-1}[/math] и [math]s_{n-2}[/math], аналогично найдём [math]s_{n-3}\ldots s_0[/math].

Предподсчёт занимает [math]O(n)[/math] времени, восстановление каждого из [math]n[/math] символов занимает [math]O(1)[/math] времени. Суммарное время работы алгоритма [math]O(n)[/math].

Пример работы для [math]BWT(s) = ([/math]"BCABAAA", 2[math])[/math] (нумерация с 0):

  • [math]s^0 = .......[/math]
  • [math]s_6=L_2 = A[/math]. Тогда [math]s^0=......[/math]A
  • Суммируем значения из двух таблиц: [math]0+0=0[/math], [math]s_5=L_0=B[/math], [math]s^0=.....[/math]BA
  • Суммируем: [math]0+4=4[/math], [math]s_4=L_4=A[/math], [math]s^0=....[/math]ABA
  • Суммируем: [math]1+0=1[/math], [math]s_3=L_1=C[/math], [math]s^0=...[/math]CABA
  • Суммируем: [math]0+6=6[/math], [math]s_2=L_6=A[/math], [math]s^0=..[/math]ACABA
  • Суммируем: [math]3+0=3[/math], [math]s_2=L_3=B[/math], [math]s^0=.[/math]BACABA
  • Суммируем: [math]1+4=5[/math], [math]s_2=L_5=A[/math], [math]s^0=[/math] ABACABA

Замечания

  • bzip2[1] использует преобразование Барроуза — Уилера для превращения последовательностей многократно чередующихся символов в строки одинаковых символов, затем применяет преобразование MTF, и в конце кодирование Хаффмана.

См. также

Примечания

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