Изменения

{{Определение|definition ='''Элементарная транспозиция''' (англ. ''Adjacent transposition'') {{---}} перестановка местами двух соседних элементов.}} '''Коды Грея для перестановок'''(англ. ''Gray code for permutation'') {{---}} упорядочение перестановок, при котором соседние перестановки отличаются только элементарной транспозицией.== Построение кода Грея для перестановок == Будем строить код Грея для длины <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> Получим <tex>k</tex> различных перестановок, отличающихся одной элементарной транспозицией. Возьмем следующую перестановку из кода Грея для перестановок длины <tex>k - 1</tex> и припишем в конце число <tex>k</tex>. Эта перестановка отличается на одну элементарную транспозицию (последние элементы совпадают, а префиксы длины <tex>k - 1</tex> отличаются на элементарную транспозицию). Пусть она имеет следующий вид: <tex>\{b_1, b_2,b_3, \dots, b_{k-1}\}</tex> Элемент <tex>k</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</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>, причём соседние отличаются в одной элементарной транспозиции.

|style="background-color:#FFF;padding:2px 30px"| <tex>\{2, 1, 2\} </tex>

|style="background-color:#FFF;padding:2px 30px"| <tex>\{1, 2, 1\} </tex>

'''Перестановки для n = 3'''(подчёркнуты пары переставляемых элементов)

|style="background-color:#FFF;padding:2px 30px"| <tex>\{1\underline{3, 2}, 31\} </tex>|style="background-color:#FFF;padding:2px 30px"| берем первую перестановку и добавляем в начало тройку

|style="background-color:#FFF;padding:2px 30px"| <tex>\{12, \underline{3, 21}\} </tex>|style="background-color:#FFF;padding:2px 30px"| двигаем до последней позиции

|style="background-color:#FFF;padding:2px 30px"| <tex>\{3\underline{2, 1}, 23\}</tex>|style="background-color:#FFF;padding:2px 30px"|

|style="background-color:#FFF;padding:2px 30px"| <tex>\{31, \underline{2, 13}\}</tex>|style="background-color:#FFF;padding:2px 30px"| берем следующую перестановку и записываем тройку в конец

|style="background-color:#FFF;padding:2px 30px"| <tex>\{2\underline{1, 3}, 12\} </tex>|style="background-color:#FFF;padding:2px 30px"| двигаем в начало

|style="background-color:#FFF;padding:2px 30px"| <tex>\{23, 1, 32\} </tex>|style="background-color:#FFF;padding:2px 30px"|

== Построение Псевдокод получения кода Грея для перестановок ==

Будем строить Получаем код Грея для длины рекурсивно, в базовом случае <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>

Получим '''list<texlist<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 {{---}} перестановки из n - 1 элемента</font color=darkgreen> '''bool''' backward = ''false'' <font color=darkgreen> //переменная которая говорит с какой стороны заполнять перестановку</font color=darkgreen>k '''for''' perm '''in''' perms <font color=darkgreen> //perm {{---}} текущая перестановка</texfont color=darkgreen> '''if''' backward '''list<int> различных перестановок''' current = concat(perm, отличающихся одной элементарной транспозицией{n})<font color=darkgreen> //дописываем {n} в конец perm</font color=darkgreen> result. Возьмем следующую append(current)<font color=darkgreen> //добавляем в ответ перестановку из кода Грея для перестановок длины current<tex/font color=darkgreen>k '''for''' i = n '''downto''' 2 swap(current[i - 1], current[i])<font color=darkgreen> //переставляем n</texfont color=darkgreen> result.append(current) <font color=darkgreen> и припишем //добавляем в конце число ответ перестановку current</font color=darkgreen> '''else''' '''list<int>''' current = concat({n}, perm) <texfont color=darkgreen>k //дописываем {n} в начало perm</texfont color=darkgreen> result. Эта перестановка отличается на одну элементарную транспозицию append(последние элементы совпадают, а префиксы длины current) <font color=darkgreen> //добавляем в ответ перестановку current<tex/font color=darkgreen>k '''for''' i = 1 '''to''' n - 1 swap(current[i], current[i + 1]) <font color=darkgreen> //переставляем n</texfont 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>\{b_1, b_2,b_3, \dots, b_{k== Реализация в нерекурсивном виде. Алгоритм Джонсона-1}\}</tex>Троттера ==

Элемент === Идея ===Сопоставим каждому элементу перестановки <tex>kp[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 = \{b_11, b_22, b_3\textbf{3}\}\;\;\;d = \{\leftarrow, \dotsleftarrow, \underline{b_{k-1}, k}leftarrow\}</tex>* <tex>p = \{b_11, b_2, b_3\textbf{3}, 2\}\;\;\;d = \underline{\dotsleftarrow, k}\leftarrow, b_{k-1}\leftarrow\}</tex>* <tex>p = \{b_13, b_21, \underlinetextbf{b_3, k2}\}\;\;\;d = \{\leftarrow, \dotsleftarrow, b_{k-1}\leftarrow\}</tex>* <tex>p = \{b_1, \underlinetextbf{b_23}, 2, k1\}\;\;\;d = \{\to, b_3\leftarrow, \dots, b_{k-1}leftarrow\}</tex>* <tex>p = \{2, \underlinetextbf{b_23}, k1\}\;\;\;d = \{\leftarrow, b_1, b_3\to, \dots, b_{k-1}leftarrow\}</tex>* <tex>p = \{k2, b_11, b_23\}\;\;\;d = \{\leftarrow, b_3\leftarrow, \dots, b_{k-1}to\}</tex>

Продолжаем аналогично. Для каждой перестановки дописываем === Псевдокод ===<code> <texfont color=darkgreen>k//Элементы нумеруются начиная с 1 </texfont color=darkgreen> '''list<list<int>> в один конец ''' gray_code(поочерёдноn): '''list<int>''' perm = {1, ... , n} '''list<char>''' dir = {←, ... , и с помощью элементарных транспозиций двигаем ←} '''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>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>, причём соседние отличаются в одной элементарной транспозиции.

Рассмотрим код Грея для длины {{Утверждение|id=approval1|statement=Число <tex>n</tex>в перестановке не является подвижным элементом тогда и только тогда, когда первая компонента перестановки есть <tex>\overset{\text {$\leftarrow$}}{n = 2}</tex> или последняя компонента есть <tex>\overset{\text {$\to$}}{n}</tex>:.}}

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

Код Грея полученТеперь докажем основную лемму.{{Лемма|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</tex> элементов. Немного модифицируем алгоритм. Заметим, что в каждом блоке нам нужно искать максимальный элемент только один раз. В остальных случаях этим элементом будет <tex>n</tex>. Следовательно, менять направление стрелок нужно тоже только один раз(в остальных случаях менять направления не нужно, так как <tex>n</tex> - подвижный элемент, а менять направление стрелок нужно только у бóльших элементов). Следовательно, блок выполняется за <tex>O(n) + O(n) + O(n) = O(n)</tex>. Всего блоков <tex> -\:(n - 1)!</tex>. Общая асимптотика <tex>O(n) \cdot (n - 1)! = O(n!)</tex>.

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

gray_code(n): '''if''' n == 1: '''return''' [{1}] <font color=darkgreen>// возращаем список из одной перестановки</font color=darkgreen> '''else''': result = [] <font color=darkgreen>// пустой список</font color=darkgreen> perms = gray_code(n - 1) <font color=darkgreen>// perms {{---}} перестановки из n - 1 элемента</font color=darkgreen> backward Интересный факт= false <font color=darkgreen>// переменная которая говорит с какой стороны заполнять перестановку</font color=darkgreen> '''for''' perm in perms: <font color=darkgreen>// perm Существует более общая формулировке задачи {{---}} текущая перестановка</font color=darkgreen> '''if''' backward: current = concat(permдля двух соседних перестановок должно выполняться, {n})<font color=darkgreen>// дописываем {n} что позиции одинаковых чисел в конец perm</font color=darkgreen> resultних отличаются не более, чем на единицу.append(current)<font color=darkgreen>// добавляем в ответ перестановку current</font color=darkgreen> '''for''' (i = n; i > 1; i--): swap(current[i - 1]Для этой формулировки верно, current[i])что для любой перестановки <font color=darkgreentex>//переставляем nu</font color=darkgreentex> result.append(current) число различных перестановок <font color=darkgreentex>//добавляем в ответ перестановку currentv</font color=darkgreentex> '''else''': current = concat({n}, perm) которые могут стоять после <font color=darkgreentex>// дописываем {n} в начало permu</font color=darkgreentex> result.append(current) <font color=darkgreen>//добавляем в ответ перестановку current, равно </font color=darkgreentex> '''for''' (i = 1; i < n; i++): swap(current[i], current[i + 1]) <font color=darkgreen>//переставляем n</font color=darkgreentex>числу Фибоначчи. resultЭтот факт был открыт студентом нашего университета.append(current) <font color=darkgreen>//добавляем в ответ перестановку current</font color=darkgreen> backward = !backward <font color=darkgreen>//меняем состояние backward</font color=darkgreen> '''return''' result <font color=darkgreen>//возвращаем ответ в виде списка</font color=darkgreen>

* Романовский И.В. Дискретный Анализ - "Санкт-Петербург", 2003. - стр. 39-41 - ISBN 5-94157-330-8* Федоряева Т.И. Комбинаторные алгоритмы - Новосибирск, 2011. - стр. 36-46 - ISBN 978-5-4437-0019-9* Ананий Левитин, Алгоритмы. Введение в разработку и анализ - Москва. Санкт-Петербург. Киев, 2006. - стр. 226 - 229 - ISBN 5-8459-0987-2