1632
правки
Изменения
м
'''Будем строить код Грея для длины <tex>n = k</tex>. Предположим, что нам известен [[Коды Грея | код Грея]] для перестановок''' длиной <tex>k - 1</tex>. Возьмем первую перестановку из известного нам кода. Она имеет следующий вид: <tex>\{a_1, a_2, a_3, \dots, a_{k---1}\} это такое упорядочение перестановок, что соседние перестановки отличаются только элементарной транспозицией.</tex>
'''Элементарная транспозиция''' {{---}} транспозиция двух соседних элементов Сначала запишем число <tex>k</tex> в начало этой перестановки, после чего будем двигать его вправо элементарными транспозициями (обмен местами двух соседних подчёркнуты пары переставляемых элементов). Далее будем называть элементарную транспозицию просто транспозицией.
== '''Построения кода Грея для перестановок''' ==* <tex>\{\underline{k, a_1}, a_2, a_3, \dots, a_{k-1}\}</tex>* <tex>\{a_1, \underline{k, a_2}, a_3, \dots, a_{k-1}\}</tex>* <tex>\{a_1, a_2, \underline{k, a_3}, \dots, a_{k-1}\}</tex>* <tex>\{a_1, a_2, a_3, \underline{k, \dots}, a_{k-1}\}</tex>* <tex>\{a_1, a_2, a_3, \dots, \underline{k, a_{k-1}}\}</tex>* <tex>\{a_1, a_2, a_3, \dots, a_{k-1}, k\}</tex>
Чтобы построить код Грея для перестановки длиной $n$Получим <tex>k</tex> различных перестановок, будем использовать код отличающихся одной элементарной транспозицией. Возьмем следующую перестановку из кода Грея для перестановки длиной $n перестановок длины <tex>k - 1$</tex> и припишем в конце число <tex>k</tex>.Для $n = Эта перестановка отличается на одну элементарную транспозицию (последние элементы совпадают, а префиксы длины <tex>k - 1$ код Грея выглядит так</tex> отличаются на элементарную транспозицию). Пусть она имеет следующий вид:
{ $1$ } {{---}} $n!$ различных перестановок, отличных друг от друга Элемент <tex>k</tex> записываем в одной транспозиции (очевидно). конец и начинаем "двигать" его влево:
Будем строить код Грея для перестановок длины $n = Продолжаем аналогично. Для каждой перестановки дописываем <tex>k$. Предположим</tex> в один конец (поочерёдно), и с помощью элементарных транспозиций двигаем в другой конец, что нам известен код Грея для перестановок длиной $n = k - 1$. Возьмем первую при этом добавляя каждую промежуточную перестановку из известного нам кодав список. Пусть она выглядит так:
Элемент $a_{k}$ запишем в начало этой перестановки:== Псевдокод получения кода Грея ==
{$a_{1}=== Доказательство корректности ===Очевидно, a_{k}что требование о том, a_{2}, a_{3}что каждая генерируемая перестановка отличается от предыдущей транспозицией двух соседних элементов выполнено исходя из самого алгоритма. Осталось доказать, что таким образом мы сгенерируем все перестановки..., a_{k - 1}$} (2)
$..........................$
{$a_{1}, a_{2}, a_{3}, ..., a_{k}, a_{k - 1}$}
Получим $k$ различных перестановок, отличающихся в одной транспозиции===Асимптотика===Поговорим об асиптотике. Возьмем следующую строку из кода Грея для перестановок длиной $Снова разобьём наши перестановки на блоки по <tex>n = k - 1$, которая будет выглядеть так (т</tex> элементов.кНемного модифицируем алгоритм. мы получилиЗаметим, что в каждом блоке нам нужно искать максимальный элемент стоящий на первом месте в перестановке только один раз. В остальных случаях этим элементом будет "двигаться" вправо см<tex>n</tex>. Следовательно, менять направление стрелок нужно тоже только один раз(1в остальных случаях менять направления не нужно, так как <tex>n</tex> - подвижный элемент, а менять направление стрелок нужно только у бóльших элементов). Следовательно, блок выполняется за <tex>O(n) + O(n) + O(2n), то и во второй перестановке первый элемент "поменяется" со вторым= O(n)</tex>. Всего блоков <tex> -\:(n - 1)!</tex>. Общая асимптотика <tex>O(n) \cdot (n - 1)! = O(n!)</tex>.
Элемент $a_{k}$ записываем Последовательность перестановок, полученная с помощью данного алгоритма имеет интересную интерпретацию. Так, если рассмотреть [[Основные_определения_теории_графов | граф]], вершины которого соответствуют всем перестановкам и в конец котором две вершины, соответствующие перестановкам <tex>f</tex> и начинаем "двигать" влево<tex>g</tex>, меняя его с правостоящим:соединены ребром, если <tex>g</tex> образуется из <tex>f</tex> однократной транспозицией соседних элементов, то полученная последовательность является гамильтоновым путем в этом графе.
{$a_{2}, a_{1}, a_{3}, == Источники информации ==* Романовский И.В.., a_{k Дискретный Анализ - Санкт- 1}, a_{k}$} (4) {$a_{2}, a_{1}, a_{3}Петербург, 2003.- стр.., a_{k}, a_{k 39-41 - ISBN 5-94157-330- 1}$}8 $* Федоряева Т.И.........................$ {$a_{2}, a_{1}, a_{3}, a_{k}Комбинаторные алгоритмы - Новосибирск, 2011.- стр.., a_{k 36-46 - ISBN 978-5-4437-0019- 1}$}9{$a_{2}, a_{1}, a_{k}, a_{3}* Ананий Левитин, Алгоритмы.Введение в разработку и анализ - Москва.Санкт-Петербург.Киев, a_{k 2006. - 1}$} {$a_{2}, a_{k}, a_{1}, a_{3}, стр..., a_{k 226 - 229 - ISBN 5-8459-0987- 1}$}2 {$a_{k}, a_{2}, a_{1}, a_{3}, ..., a_{k - 1}$}[[Категория: Дискретная математика и алгоритмы]]
Опять получили $k$ различных перестановок, отличающихся в одной транспозиции. Далее берем третью строку из кода Грея для перестановок длиной $n = k - 1$, записываем в ее начало элемент $a_{k}$ и двигаем его вправо, как для первой перестановки и т.д. Для каждой перестановки длиной $n = k - 1$ (всего их $(k - 1)!$) мы получили $k$ новых перестановок. Итого $k\cdot(k - 1)! = k!$ перестановок. Все они различны, т.к. для любых двух перестановок из нового кода Грея элемент $a_{k}$ стоит на разных позициях,а если $a_{k}$ стоит на одной и той же позиции, то эти перестановки образованы от разных перестановок длиной $n = k - 1$ (см. (3), (4)). Так же все соседние перестановки отличаются ровно в одной транспозиции (образованные от одной перестановки различны благодаря построению, от разных перестановок {{---}} имеют $a_{k}$ на одной и той же позиции, но отличаются в одной транспозиции, т.к. является перестановками в коде Грея для перестановок длиной $n = k - 1$, см (3), (4)). Таким образом мы получили $k!$ различных перестановок длиной $k$, отличающихся в одной транспозиции. Алгоритм для построения кодов Грея для перестановок длиной $n$ получен. == '''Сведение задачи построение кода Грея для перестановок к графам''' == Последовательность перестановок, полученная с помощью данного алгоритма имеет интересную интерпретацию. Так, если рассмотреть граф, вершины которого соответствуют всем перестановкам и в котором две вершины, соответствующие перестановкам <tex>f</tex> и <tex>g</tex>, соединены ребром, если <tex>g</tex> образуется из <tex>f</tex> однократной транспозицией соседних элементов, то полученная последовательность является гамильтоновым путем в этом графе. == См. также ==* [[Коды ГреяКатегория: Комбинаторика ]]* [[Комбинаторные объекты]]* [[Гамильтонов путь]]== Литература ==Романовский, И.В. Дискретный Анализ - Санкт-Петербург 2003 стр. 39-41<\wikitex>
rollbackEdits.php mass rollback
{{Определение| width="150" aligndefinition ="right" cellpadding="5" border="1" style="border-collapse: collapse;"|'''Элементарная транспозиция''' (англ. ''Adjacent transposition'') {{-| <span style="font-size:smaller;">код Грея для перестановки при n = 2</span> 2 1 1 2|-}} перестановка местами двух соседних элементов.| <span style="font-size:smaller;">код Грея для перестановки при n = 3</span>}} 3 2 1 2 3 1 2 1 3 1 2 3 1 3 2 3 1 2|-| <span style="font-size:smaller;">код '''Коды Грея для перестановки при n = 4</span> 4 3 2 1 3 4 2 1 3 2 4 1 3 2 1 4 2 3 1 4 2 3 4 1 2 4 3 1 4 2 3 1 4 2 1 3 2 4 1 3 2 1 4 3 2 1 3 4 1 2 3 4 1 2 4 3 1 4 2 3 4 1 2 3 4 1 3 2 1 4 3 2 1 3 4 2 1 3 2 4 3 1 2 4 3 1 4 2 3 4 1 2 4 3 1 2|}<wikitex>== перестановок'''(англ. 'Определение'Gray code for permutation'' ) {{---}} упорядочение перестановок, при котором соседние перестановки отличаются только элементарной транспозицией.== Построение кода Грея для перестановок ==
<tex>\{b_1, b_2,b_3, \dots, b_{k-1}\}</tex>
* <tex>\{b_1, b_2, b_3, \dots, \underline{b_{k-1}, k}\}</tex>
* <tex>\{b_1, b_2, b_3, \underline{\dots, k}, b_{k-1}\}</tex>
* <tex>\{b_1, b_2, \underline{b_3, k}, \dots, b_{k-1}\}</tex>
* <tex>\{b_1, \underline{b_2, k}, b_3, \dots, b_{k-1}\}</tex>
* <tex>\{\underline{b_2, k}, b_1, b_3, \dots, b_{k-1}\}</tex>
* <tex>\{k, b_1, b_2, b_3, \dots, b_{k-1}\}</tex>
Таким образом получаем для каждой перестановки длиной <tex>k - 1</tex> (всего <tex>(k - 1)!</tex> штук) по <tex>k</tex> новых перестановок, в сумме <tex>k\cdot(k - 1)! = k!</tex> перестановок. Все они различны, так как для любых двух перестановок из нового кода Грея элемент <tex>k</tex> стоит на разных позициях,а если <tex>k</tex> стоит на одной и той же позиции, то эти перестановки образованы от разных перестановок длиной <tex>k - 1</tex>. Так же все соседние перестановки отличаются ровно в одной элементарной транспозиции. Итого, мы получили список из <tex>k!</tex> различных перестановок длиной <tex>k</tex>, причём соседние отличаются в одной элементарной транспозиции.
== Примеры кодов Грея для перестановок =='''Перестановки для n = 2'''{$a_{| style="background-color:#CCC;margin:0.5px"!style="background-color:#EEE"| Номер!style="background-color:#EEE"| Перестановка|-|style="background-color:#FFF;padding:2px 30px"| <tex>1}, a_</tex>|style="background-color:#FFF;padding:2px 30px"| <tex>\{2}, a_{31\}, ..., a_{k</tex>|-|style="background-color:#FFF;padding:2px 30px"| <tex>2</tex>|style="background-1}$} ,где $a_color:#FFF;padding:2px 30px"| <tex>\{i}$ при $i = 1, 2, 3, ..., k$ {{---\}</tex>|} элементы перестановки.
'''Перестановки для n = 3''' (подчёркнуты пары переставляемых элементов)
{| style="background-color:#CCC;margin:0.5px"
!style="background-color:#EEE"| Номер
!style="background-color:#EEE"| Перестановка
!style="background-color:#EEE"| Пояснение
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>1</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\underline{3, 2}, 1\} </tex>
|style="background-color:#FFF;padding:2px 30px"| берем первую перестановку и добавляем в начало тройку
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>2</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{2, \underline{3, 1}\} </tex>
|style="background-color:#FFF;padding:2px 30px"| двигаем до последней позиции
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>3</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\underline{2, 1}, 3\}</tex>
|style="background-color:#FFF;padding:2px 30px"|
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>4</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{1, \underline{2, 3}\}</tex>
|style="background-color:#FFF;padding:2px 30px"| берем следующую перестановку и записываем тройку в конец
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>5</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{\underline{1, 3}, 2\} </tex>
|style="background-color:#FFF;padding:2px 30px"| двигаем в начало
|-
|style="background-color:#FFF;padding:2px 30px"| <tex>6</tex>
|style="background-color:#FFF;padding:2px 30px"| <tex>\{3, 1, 2\} </tex>
|style="background-color:#FFF;padding:2px 30px"|
|}
Получаем код Грея рекурсивно, в базовом случае <tex>n = 1</tex> возвращаем список из одной перестановки <tex>\{1\}</tex>.
'''list<list<int>>''' gray_code(n): '''if''' n == 1 '''return''' [{1}] <font color=darkgreen> //возращаем список из одной перестановки</font color=darkgreen> '''else''' '''list<list<int>>''' result = [] <font color=darkgreen> //пустой список</font color=darkgreen> '''list<list<int>>''' perms = gray_code(n - 1) <font color=darkgreen> //perms {$a_{k---}, a_} перестановки из n - 1 элемента</font color=darkgreen> '''bool''' backward = ''false'' <font color=darkgreen> //переменная которая говорит с какой стороны заполнять перестановку</font color=darkgreen> '''for''' perm '''in''' perms <font color=darkgreen> //perm {{1---}}текущая перестановка</font color=darkgreen> '''if''' backward '''list<int>''' current = concat(perm, a_{2n}, a_)<font color=darkgreen> //дописываем {3n}в конец perm</font color=darkgreen> result.append(current)<font color=darkgreen> //добавляем в ответ перестановку current</font color=darkgreen> '''for''' i = n '''downto''' 2 swap(current[i - 1], current[i])<font color=darkgreen> //переставляем n</font color=darkgreen> result...append(current) <font color=darkgreen> //добавляем в ответ перестановку current</font color=darkgreen> '''else''' '''list<int>''' current = concat({n}, a_perm) <font color=darkgreen> //дописываем {k n} в начало perm</font color=darkgreen> result.append(current) <font color=darkgreen> //добавляем в ответ перестановку current</font color=darkgreen> '''for''' i = 1 '''to''' n - 1}$} swap(current[i], current[i + 1]) <font color=darkgreen> //переставляем n</font color=darkgreen> result.append(current) <font color=darkgreen> //добавляем в ответ перестановку current</font color=darkgreen> backward = '''not''' backward <font color=darkgreen> //меняем состояние backward</font color=darkgreen> '''return''' result <font color=darkgreen> //возвращаем ответ в виде списка</font color=darkgreen>
== Реализация в нерекурсивном виде. Алгоритм Джонсона-Троттера ==
=== Идея ===Сопоставим каждому элементу перестановки <tex>p[i]</tex> направление <tex>d[i]</tex>. Будем указывать направление при помощи стрелок '''←''' ("двигатьвлево") или '''→'''("вправо" этот ). Назовём элемент подвижным, если по направлению стрелки стоит элемент $a_меньше его. Например, для <tex> p = \{k1, 3, 2, 4, 5\}$ влево, меняя его \;d = \{\leftarrow, \to, \leftarrow, \to, \leftarrow\}</tex>, подвижными являются элементы <tex>3</tex> и <tex>5</tex>. На каждой итерации алгоритма будем искать наибольший подвижный элемент и менять местами с соседним:элементом, который стоит по направлению стрелки. После чего поменяем направление стрелок на противоположное у всех элементов больших текущего. Изначально <tex> p = \{1, \dots ,n\},\;d = \{\leftarrow, \dots ,\leftarrow\}</tex>.
=== Пример работы алгоритма для n = 3 ===
*<tex> p = \{1, 2, \textbf{3}\}\;\;\;d = \{\leftarrow, \leftarrow, \leftarrow\}</tex>
*<tex> p = \{1, \textbf{3}, 2\}\;\;\;d = \{\leftarrow, \leftarrow, \leftarrow\}</tex>
*<tex> p = \{3, 1, \textbf{2}\}\;\;\;d = \{\leftarrow, \leftarrow, \leftarrow\}</tex>
*<tex> p = \{\textbf{3}, 2, 1\}\;\;\;d = \{\to, \leftarrow, \leftarrow\}</tex>
*<tex> p = \{2, \textbf{3}, 1\}\;\;\;d = \{\leftarrow, \to, \leftarrow\}</tex>
*<tex> p = \{2, 1, 3\}\;\;\;d = \{\leftarrow, \leftarrow, \to\}</tex>
=== Псевдокод ===<code> <font color=darkgreen>//Элементы нумеруются начиная с 1 </font color=darkgreen> '''list<list<int>>''' gray_code(n): '''list<int>''' perm = {$a_{k}1, a_{1}... , a_{2n}, a_ '''list<char>''' dir = {3}←, ..., a_{k ←} '''list<list<int>>''' result '''while''' ''true'' result.append(perm); <font color=darkgreen> //добавляем в ответ текущую перестановку</font color=darkgreen> '''int''' id = -1; <font color=darkgreen> //индекс наибольшего подвижного элемента </font color=darkgreen> '''for''' i = 1 '''to''' n '''if''' (perm[i] - подвижный) '''and''' ((id == - 1}$} ) '''or''' (perm[i] > perm[id])) id = i '''if''' (id == -1)'''break''' <font color=darkgreen> //не нашли подвижного элемента</font color=darkgreen> '''for''' i = 1 '''to''' n '''if''' (perm[i] > perm[id]) reverse(dir[i]) <font color=darkgreen> //меняем направление стрелки</font color=darkgreen> swap(id) <font color=darkgreen> //меняем элемент perm[id], dir[id] c элементом по направлению стелки</font color=darkgreen> '''return''' result </code>
Будем использовать обозначения:*<tex>\overset{\text {$a_\to$}}{1a}, a_</tex> {2{---}}, a_элемент с заданным направлением(компонента).*<tex>P[i]</tex> {k{---}}, a_перестановка с номером <tex>i</tex>.*<tex>P[i]\backslash\{3a\}, ..., a_\;</tex> {{k - 1--}$}перестановка с номером <tex>i</tex> без элемента <tex>a</tex>.
{{Утверждение|id=approval1|statement=Число <tex>n</tex> в перестановке не является подвижным элементом тогда и только тогда, когда первая компонента перестановки есть <tex>\overset{\text {$\leftarrow$a_}}{1n}, a_</tex> или последняя компонента есть <tex>\overset{\text {2$\to$}, a_{3}, a_{kn}, .</tex>.., a_{k - 1}$}
{$a_{Лемма|id=lemma1 |statement=Если в перестановке <tex>P[i]</tex> есть подвижный элемент <tex>a \neq n</tex>, то также определены перестановки <tex>P[i + 1}] ... P[i + n]</tex>. Причём, a_<tex>P[i + 1]\backslash\{n\} = P[i + 2]\backslash\{n\}= ... = P[i + n]\backslash\{n\}</tex>.|proof=Заметим, что если в перестановке есть подвижный элемент <tex>a \neq n</tex>, a_то после транспозиции его с соседним элементом(по направлению стрелки), нам нужно будет заменить направление стрелок у всех элементов больше <tex>a</tex>. Так как <tex>n</tex> больше любого элемента из перестановки, то направление стрелки у него тоже изменится. По нашему утверждению, либо в новой перестановке окажется компонента <tex>\overset{\text {3$\to$}}{n}</tex> на первой позиции, либо компонента <tex>\overset{\text {$\leftarrow$}}{n}</tex> на последней позиции.В обоих случаях <tex>n</tex> окажется подвижным элементом в следующих <tex>n</tex> перестановках..Так как в следующих <tex>n</tex> перестановках подвижным элементом будет только <tex>n</tex>, a_то <tex>P[i + 1]\backslash\{n\} = P[i + 2]\backslash\{k - 1n\}, a_= ... = P[i + n]\backslash\{kn\}</tex>.}$} (3)
Теперь докажем основную лемму.
{{Лемма
|id=lemma2
|statement=Алгоритм Джонсона-Троттера строит все перестановки из <tex>n</tex> элементов, причём каждая перестановка отличаются от предыдущей транспозицией двух соседних элементов.
|proof=Доказывать будем по индукции. Для <tex>n = 1\; - </tex> очевидно. Предположим, что для <tex>n - 1</tex> алгоритм строит перестановки корректно. Докажем, что алгоритм будет корректно строить перестановки и для <tex>n</tex> элементов. Разобьём все <tex>n!</tex> перестановок на блоки по <tex>n</tex> (подряд). В силу вышедоказанной леммы в каждом блоке <tex>P[i]\backslash\{n\} = P[i + 1]\backslash\{n\} = ... = P[i + n]\backslash\{n\}</tex>, если <tex>i\; - </tex> начало группы. Значит, в каждой группе какая-то перестановка из <tex>n - 1</tex> элемента дополняется до перестановки из <tex>n</tex> всеми возможными способами. Теперь докажем, что на переход между блоками элемент <tex>n</tex> никак не влияет. Заметим, что при переходе между блоками <tex>n</tex> является неподвижным элементом. В силу нашего утверждения <tex>n</tex> стоит либо на первой, либо на последней позиции. Так как <tex>n</tex> больше любого элемента, то никакой подвижный элемент не может указывать на <tex>n</tex>. В силу этих фактов <tex>n</tex> никак не повлияет на переход между блоками.
Из этого можно сделать вывод, что при переходе между блоками перестановки строятся так же, как и перестановки из <tex>n - 1</tex> элемента, а каждая такая перестановка дополняется до перестановки из <tex>n</tex> элементов всеми возможными способами.
Корректность алгоритма доказана.
}}
===Сравнение с рекурсивным алгоритмом===
Главным приемуществом алгоритма Джонсона-Троттера является то, что нам не нужно хранить все предыдущие перестановки (из <tex>n - 1</tex> элемента), а только текущую. Следовательно, этот алгоритм потребляет только <tex>O(n)</tex> памяти. Также, из-за нерекурсивности этот алгоритм работает быстрее.
===Интересный факт===Существует более общая формулировке задачи {$a_{2---}, a_{1}для двух соседних перестановок должно выполняться, a_{3}что позиции одинаковых чисел в них отличаются не более, чем на единицу.Для этой формулировки верно, что для любой перестановки <tex>u</tex> число различных перестановок <tex>v</tex>, которые могут стоять после <tex>u</tex>, равно <tex>n + 1</tex> числу Фибоначчи.Этот факт был открыт студентом нашего университета., a_{k - 1}$}
== Сведение задачи построения кода Грея для перестановок к графам ==
== См. также ==
* [[Комбинаторные объекты]]
* [[NP-полнота_задач_о_гамильтоновом_цикле_и_пути_в_графах | Гамильтонов путь]]
