Изменения

|definition='''Элементарная транспозиция''' (англ. ''Adjacent transposition'') {{---}} перестановка местами двух соседних элементов.}} '''Коды Грея для перестановок''' (англ. ''Gray code for permutation'') {{---}} упорядочение перестановок, при котором соседние перестановки отличаются только элементарной транспозицией.<br>== Построение кода Грея для перестановок ==

'''Элементарная транспозиция''' Будем строить код Грея для длины <tex>n = k</tex>. Предположим, что нам известен [[Коды Грея | код Грея]] для перестановок длиной <tex>k - 1</tex>. Возьмем первую перестановку из известного нам кода. Она имеет следующий вид: <tex>\{a_1, a_2, a_3, \dots, a_{k---}} транспозиция двух соседних элементов. Далее будем называть элементарную транспозицию просто транспозицией.1}\}</tex>

* <tex>\{| border="1" | $n=2:$ | $n=3:$ |- | $\underline{1k, 2\a_1}$ | $, a_2, a_3, \dots, a_{k-1, 2, 3}\}$ |-</tex> | $* <tex>\{2a_1, 1\underline{k, a_2}$ | $, a_3, \dots, a_{k-1, 3, 2}\}$</tex> |- | $* <tex>\{3a_1, 1a_2, 2\underline{k, a_3}$ |, \dots, a_{k-1}\}</tex> | $* <tex>\{3a_1, a_2, 2a_3, \underline{k, \dots}, a_{k-1}\}$</tex> |- | $* <tex>\{2a_1, a_2, a_3, 3\dots, \underline{k, a_{k-1}}\}$ |-</tex> | $* <tex>\{2a_1, a_2, a_3, \dots, a_{k-1}, 3k\}$ |}</tex>

== Построение Получим <tex>k</tex> различных перестановок, отличающихся одной элементарной транспозицией. Возьмем следующую перестановку из кода Грея для перестановок ==длины <tex>k - 1</tex> и припишем в конце число <tex>k</tex>. Эта перестановка отличается на одну элементарную транспозицию (последние элементы совпадают, а префиксы длины <tex>k - 1</tex> отличаются на элементарную транспозицию). Пусть она имеет следующий вид:

Чтобы построить код Грея для перестановки длиной $n$<tex>\{b_1, будем использовать код Грея для перестановки длиной $n b_2,b_3, \dots, b_{k- 1$.Для $n = 1$ код Грея выглядит так:}\}</tex>

Будем строить код Грея для перестановок длины $n = * <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, что нам известен код Грея для перестановок длиной $n = b_{k - 1$. Возьмем первую перестановку из известного нам кода. Пусть она выглядит так:}\}</tex>

$\{a_{1}, a_{2}, a_{3}, ..Продолжаем аналогично.Для каждой перестановки дописываем <tex>k</tex> в один конец (поочерёдно), a_{k-1}\}$ и с помощью элементарных транспозиций двигаем в другой конец,где $a_{i}$ при $i = 1, 2, 3, ..., k$ {{---}} элементы перестановкиэтом добавляя каждую промежуточную перестановку в список.

Элемент $a_{Таким образом получаем для каждой перестановки длиной <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'''{| style="background-color:#CCC;margin:0.5px"!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>\{a_{k}2, a_{1\}, a_{</tex>|-|style="background-color:#FFF;padding:2px 30px"| <tex>2}, a_</tex>|style="background-color:#FFF;padding:2px 30px"| <tex>\{3}1, ..., a_{k - 12\}\</tex>|}$

Будем '''Перестановки для n = 3''' (подчёркнуты пары переставляемых элементов){| style="background-color:#CCC;margin:0.5px"!style="background-color:#EEE"двигать| Номер!style=" этот элемент $a_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>\{k\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>\{a_{1\}, a_{k}, a_{2}, a_{3}, .</tex>.., a_{k - 1}\}$ (2)

$\ '''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_{---}} перестановки из n - 1элемента</font color=darkgreen> '''bool''' backward = ''false'' <font color=darkgreen> //переменная которая говорит с какой стороны заполнять перестановку</font color=darkgreen> '''for''' perm '''in''' perms <font color=darkgreen> //perm {{---}}текущая перестановка</font color=darkgreen> '''if''' backward '''list<int>''' current = concat(perm, a_{n})<font color=darkgreen> //дописываем {n} в конец perm</font color=darkgreen> result.append(current)<font color=darkgreen> //добавляем в ответ перестановку current</font color=darkgreen> '''for''' i = n '''downto''' 2} swap(current[i - 1], a_current[i])<font color=darkgreen> //переставляем n</font color=darkgreen> result.append(current) <font color=darkgreen> //добавляем в ответ перестановку current</font color=darkgreen> '''else''' '''list<int>''' current = concat({kn}, a_perm) <font color=darkgreen> //дописываем {3n}, ..в начало perm</font color=darkgreen> result.append(current) <font color=darkgreen> //добавляем в ответ перестановку current</font color=darkgreen> '''for''' i = 1 '''to''' n - 1 swap(current[i], a_{k - 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>

$\{a_{1}, a_{2}, a_{3}, a_{k}, == Реализация в нерекурсивном виде..., a_{k Алгоритм Джонсона- 1}\}$Троттера ==

$=== Идея ===Сопоставим каждому элементу перестановки <tex>p[i]</tex> направление <tex>d[i]</tex>.Будем указывать направление при помощи стрелок '''←''' ("влево") или '''→'''("вправо").Назовём элемент подвижным, если по направлению стрелки стоит элемент меньше его.Например, для <tex> p = \{1, 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 = \{a_\leftarrow, \leftarrow, \leftarrow\}</tex>*<tex> p = \{1, \textbf{3}, 2\}\;\;\;d = \{\leftarrow, \leftarrow, \leftarrow\}</tex>*<tex> p = \{3, 1, a_\textbf{2}\}\;\;\;d = \{\leftarrow, a_\leftarrow, \leftarrow\}</tex>*<tex> p = \{\textbf{3}, ...2, a_1\}\;\;\;d = \{k\to, \leftarrow, \leftarrow\}</tex>*<tex> p = \{2, a_\textbf{k - 3}, 1\}\;\;\;d = \{\leftarrow, \to, \leftarrow\}</tex>*<tex> p = \{2, 1, 3\}\;\;\;d = \{\leftarrow, \leftarrow, \to\}$</tex>

$\{a_=== Псевдокод ===<code> <font color=darkgreen>//Элементы нумеруются начиная с 1 </font color=darkgreen> '''list<list<int>>''' gray_code(n): '''list<int>''' perm = {1}, a_{2... , n}, 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}, a_{k}\}$ ) '''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(3id)<font color=darkgreen> //меняем элемент perm[id], dir[id] c элементом по направлению стелки</font color=darkgreen> '''return''' result </code>

Получим $k$ различных перестановок=== Доказательство корректности ===Очевидно, что требование о том, отличающихся в одной транспозиции. Возьмем следующую строку что каждая генерируемая перестановка отличается от предыдущей транспозицией двух соседних элементов выполнено исходя из кода Грея для перестановок длиной $n = k - 1$, которая будет выглядеть так (т.ксамого алгоритма. мы получилиОсталось доказать, что элемент стоящий на первом месте в перестановке будет "двигаться" вправо смтаким образом мы сгенерируем все перестановки. (1), (2), то и во второй перестановке первый элемент "поменяется" со вторым):

$Будем использовать обозначения:*<tex>\overset{a_\text {2$\to$}}, a_{1a}, a_</tex> {{3---}}, элемент с заданным направлением(компонента).*<tex>P[i]</tex> {{---}} перестановка с номером <tex>i</tex>.., a_*<tex>P[i]\backslash\{a\}\;</tex> {{k - 1--}\}$перестановка с номером <tex>i</tex> без элемента <tex>a</tex>.

Элемент {{Утверждение|id=approval1|statement=Число <tex>n</tex> в перестановке не является подвижным элементом тогда и только тогда, когда первая компонента перестановки есть <tex>\overset{\text {$a_\leftarrow$}}{kn}</tex> или последняя компонента есть <tex>\overset{\text {$ записываем в конец и начинаем "двигать" влево, меняя его с правостоящим:\to$}}{n}</tex>.}}

$..........{{Лемма|id=lemma1 |statement=Если в перестановке <tex>P[i]</tex> есть подвижный элемент <tex>a \neq n</tex>, то также определены перестановки <tex>P[i + 1] ...P[i + n]</tex>.Причём, <tex>P[i + 1]\backslash\{n\} = P[i + 2]\backslash\{n\} = ...= P[i + n]\backslash\{n\}</tex>.|proof=Заметим, что если в перестановке есть подвижный элемент <tex>a \neq n</tex>, то после транспозиции его с соседним элементом(по направлению стрелки), нам нужно будет заменить направление стрелок у всех элементов больше <tex>a</tex>.Так как <tex>n</tex> больше любого элемента из перестановки, то направление стрелки у него тоже изменится.По нашему утверждению, либо в новой перестановке окажется компонента <tex>\overset{\text {$\to$}}{n}</tex> на первой позиции, либо компонента <tex>\overset{\text {$\leftarrow$}}{n}</tex> на последней позиции.В обоих случаях <tex>n</tex> окажется подвижным элементом в следующих <tex>n</tex> перестановках.Так как в следующих <tex>n</tex> перестановках подвижным элементом будет только <tex>n</tex>, то <tex>P[i + 1]\backslash\{n\} = P[i + 2]\backslash\{n\} = ...= P[i + n]\backslash\{n\}</tex>.$}}

$\Теперь докажем основную лемму.{a_{2}Лемма|id=lemma2|statement=Алгоритм Джонсона-Троттера строит все перестановки из <tex>n</tex> элементов, причём каждая перестановка отличаются от предыдущей транспозицией двух соседних элементов.|proof=Доказывать будем по индукции. Для <tex>n = 1\; - </tex> очевидно. Предположим, что для <tex>n - 1</tex> алгоритм строит перестановки корректно. Докажем, a_что алгоритм будет корректно строить перестановки и для <tex>n</tex> элементов. Разобьём все <tex>n!</tex> перестановок на блоки по <tex>n</tex> (подряд). В силу вышедоказанной леммы в каждом блоке <tex>P[i]\backslash\{n\} = P[i + 1]\backslash\{n\}, a_= ... = P[i + n]\backslash\{3n\}</tex>, если <tex>i\; - </tex> начало группы. Значит, в каждой группе какая-то перестановка из <tex>n - 1</tex> элемента дополняется до перестановки из <tex>n</tex> всеми возможными способами. Теперь докажем, что на переход между блоками элемент <tex>n</tex> никак не влияет. Заметим, a_{k}что при переходе между блоками <tex>n</tex> является неподвижным элементом. В силу нашего утверждения <tex>n</tex> стоит либо на первой, либо на последней позиции.Так как <tex>n</tex> больше любого элемента, то никакой подвижный элемент не может указывать на <tex>n</tex>.В силу этих фактов <tex>n</tex> никак не повлияет на переход между блоками.Из этого можно сделать вывод, a_{k что при переходе между блоками перестановки строятся так же, как и перестановки из <tex>n - 1</tex> элемента, а каждая такая перестановка дополняется до перестановки из <tex>n</tex> элементов всеми возможными способами.Корректность алгоритма доказана. }\}$

$\{a_{2}===Асимптотика===Поговорим об асиптотике. Снова разобьём наши перестановки на блоки по <tex>n</tex> элементов. Немного модифицируем алгоритм. Заметим, a_{1}что в каждом блоке нам нужно искать максимальный элемент только один раз. В остальных случаях этим элементом будет <tex>n</tex>. Следовательно, a_{k}менять направление стрелок нужно тоже только один раз(в остальных случаях менять направления не нужно, a_{3}так как <tex>n</tex> - подвижный элемент, а менять направление стрелок нужно только у бóльших элементов).Следовательно, блок выполняется за <tex>O(n) + O(n) + O(n) = O(n)</tex>.Всего блоков <tex> -\:(n - 1)!</tex>., a_{k Общая асимптотика <tex>O(n) \cdot (n - 1}\}$)! = O(n!)</tex>.

$\{a_{2}===Сравнение с рекурсивным алгоритмом===Главным приемуществом алгоритма Джонсона-Троттера является то, a_{k}, a_{что нам не нужно хранить все предыдущие перестановки (из <tex>n - 1}</tex> элемента), a_{3}а только текущую. Следовательно, этот алгоритм потребляет только <tex>O(n)</tex> памяти...Также, a_{k из- 1}\}$за нерекурсивности этот алгоритм работает быстрее.

$\===Интересный факт===Существует более общая формулировке задачи {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}$ стоит на одной и той же позиции, то эти любой перестановки образованы от разных <tex>u</tex> число различных перестановок длиной $n = k - 1$ (см. (3), (4)). Так же все соседние перестановки отличаются ровно в одной транспозиции (образованные от одной перестановки различны благодаря построению, от разных перестановок {{---}} имеют $a_{k}$ на одной и той же позиции<tex>v</tex>, но отличаются в одной транспозициикоторые могут стоять после <tex>u</tex>, т.к. является перестановками в коде Грея для перестановок длиной $равно <tex>n = k - + 1$, см (3), (4))</tex> числу Фибоначчи. Таким образом мы получили $k!$ различных перестановок длиной $k$, отличающихся в одной транспозиции. Алгоритм для построения кодов Грея для перестановок длиной $n$ полученЭтот факт был открыт студентом нашего университета.

Последовательность перестановок, полученная с помощью данного алгоритма имеет интересную интерпретацию. Так, если рассмотреть [[Основные_определения_теории_графов | граф]], вершины которого соответствуют всем перестановкам и в котором две вершины, соответствующие перестановкам $<tex>f$ </tex> и $<tex>g$</tex>, соединены ребром, если $<tex>g$ </tex> образуется из $<tex>f$ </tex> однократной транспозицией соседних элементов, то полученная последовательность является гамильтоновым путем в этом графе.

== Псевдокод получения следующего кода Грея Источники информации == Пусть нам известен код Грея для длины $n* Романовский И.В. Дискретный Анализ -1$, записанный в массив pred_perest[i](j), где $i$ Санкт- номер перестановкиПетербург, $j$ 2003. - номер элемента этой перестановки (номерация начинается с единицы)стр.39-41 - ISBN 5-94157-330-8  t := false; {булевская переменная отвечающая за порядок перебора true: от начала к концу false: от конца к началу} for i := 1 to (n * Федоряева Т.И. Комбинаторные алгоритмы - 1)! do {перебираем все прошлые перестановки} if t = true then begin vstavka(pred_perest[i]Новосибирск, t); {вставляем в конец, если t = true} writeln(pred_perest[i]); for j := 1 to n 2011. - стр. 36-46 - ISBN 978-5-4437- 1 do {для каждой перестановки делаем n 0019- 1 транспозиций} begin9 swap(pred_perest[i](j)* Ананий Левитин, pred_perest[i](j + 1)); {меняем j Алгоритмы. Введение в разработку и j + 1 элементы местами} t := false; writeln(pred_perest[i]); end; end else begin vstavka(pred_perest[i]анализ - Москва. Санкт-Петербург. Киев, t); {вставляем в начало, если t = false} writeln(pred_perest[i]); for j := n 2006. - стр. 226 - 229 - ISBN 5-8459-0987- 1 downto 1 do begin2 swap(pred_perest[i](j), pred_perest[iКатегория: Дискретная математика и алгоритмы](j + 1)); {меняем j и j + 1 элементы местами} t := true; writeln(pred_perest[i]); end; end;

== См. также ==* [[Коды ГреяКатегория: Комбинаторика ]]* [[Комбинаторные объекты]]* [[Гамильтонов путь]]== Литература ==Романовский, И.В. Дискретный Анализ - Санкт-Петербург 2003 стр. 39-41