Изменения

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

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

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

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

Элемент $a_<tex>\{b_1, b_2,b_3, \dots, b_{k-1}\}$ запишем в начало этой перестановки:</tex>

{'''aЭлемент <subtex>k</subtex>''', a₁, a₂, a₃, ..., a_{k - 1}}записываем в конец и начинаем "двигать" его влево:

Будем "двигать" этот элемент $a_* <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>

{aПродолжаем аналогично. Для каждой перестановки дописываем <subtex>k</sub>, a<sub>1</subtex>в один конец (поочерёдно), a₂и с помощью элементарных транспозиций двигаем в другой конец, a₃, ..при этом добавляя каждую промежуточную перестановку в список., a_{k - 1}} (1)

{'''aТаким образом получаем для каждой перестановки длиной <subtex>k - 1</subtex>'''(всего <tex>(k - 1)!</tex> штук) по <tex>k</tex> новых перестановок, '''aв сумме <subtex>k\cdot(k - 1)! = k!</subtex>'''перестановок. Все они различны, aтак как для любых двух перестановок из нового кода Грея элемент <subtex>2k</subtex>стоит на разных позициях, aа если <subtex>3k</subtex>стоит на одной и той же позиции, то эти перестановки образованы от разных перестановок длиной <tex>k - 1</tex>.Так же все соседние перестановки отличаются ровно в одной элементарной транспозиции..Итого, aмы получили список из <subtex>k!</tex> различных перестановок длиной <tex>k - 1</subtex>} (2), причём соседние отличаются в одной элементарной транспозиции.

{a₁, == Примеры кодов Грея для перестановок =='''a_{Перестановки для n = 2}''', '''a_k''', a₃, {| style="background-color:#CCC;margin:0..., a_{k 5px"!style="background-color:#EEE"| Номер!style="background- 1}}color:#EEE"| Перестановка|-{a|style="background-color:#FFF;padding:2px 30px"| <subtex>1</subtex>, a|style="background-color:#FFF;padding:2px 30px"| <subtex>\{2</sub>, '''a<sub>31\} </subtex>''', '''a|-|style="background-color:#FFF;padding:2px 30px"| <subtex>k2</subtex>''', ..., a|style="background-color:#FFF;padding:2px 30px"| <subtex>k - \{1, 2\} </subtex>|} $..........................$

'''Перестановки для n = 3''' (подчёркнуты пары переставляемых элементов){a| 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"| <subtex>1</subtex>|style="background-color:#FFF;padding:2px 30px"| <tex>\{\underline{3, 2}, a1\} <sub/tex>|style="background-color:#FFF;padding:2px 30px"| берем первую перестановку и добавляем в начало тройку|-|style="background-color:#FFF;padding:2px 30px"| <tex>2</subtex>|style="background-color:#FFF;padding:2px 30px"| <tex>\{2, \underline{3, a1}\} </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"| <subtex>\{\underline{2, 1}, 3\}</tex>|style="background-color:#FFF;padding:2px 30px"| |-|style="background-color:#FFF;padding:2px 30px"| <tex>4</subtex>|style="background-color:#FFF;padding:2px 30px"| <tex>\{1, ...\underline{2, '''a3}\}</tex>|style="background-color:#FFF;padding:2px 30px"| берем следующую перестановку и записываем тройку в конец |-|style="background-color:#FFF;padding:2px 30px"| <subtex>k5</subtex>'''|style="background-color:#FFF;padding:2px 30px"| <tex>\{\underline{1, 3}, a2\} </tex>|style="background-color:#FFF;padding:2px 30px"| двигаем в начало|-|style="background-color:#FFF;padding:2px 30px"| <subtex>k 6</tex>|style="background- color:#FFF;padding:2px 30px"| <tex>\{3, 1, 2\} </subtex>|style="background-color:#FFF;padding:2px 30px"| |}

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

'''list<list<int>>''' gray_code(n): '''if''' n == 1 '''return''' [{1}] <font color=darkgreen> //возращаем список из одной перестановки</font color=darkgreen> '''aelse''' '''list<list<int>>''' result = [] <subfont color=darkgreen>2 //пустой список</subfont color=darkgreen> ''', list<list<int>>'''aperms = gray_code(n - 1) <subfont color=darkgreen> //perms {{---}} перестановки из n - 1элемента</font color=darkgreen> '''bool''' backward = ''false'' <font color=darkgreen> //переменная которая говорит с какой стороны заполнять перестановку</font color=darkgreen> '''for''' perm '''in''' perms <font color=darkgreen> //perm {{---}} текущая перестановка</subfont color=darkgreen> '''if''' backward '''list<int>''' current = concat(perm, a{n})<subfont color=darkgreen>3 //дописываем {n} в конец perm</subfont 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}, perm) <font color=darkgreen> //дописываем {n} в начало perm</font color=darkgreen> result.., aappend(current) <font color=darkgreen> //добавляем в ответ перестановку current<sub/font color=darkgreen>k '''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</subfont color=darkgreen> backward = '''not''' backward <font color=darkgreen> //меняем состояние backward</font color=darkgreen> '''return''' result <font color=darkgreen> //возвращаем ответ в виде списка</font color=darkgreen>}

Элемент $a_{k}$ записываем == Реализация в конец и начинаем "двигать" влево, меняя его с правостоящим:нерекурсивном виде. Алгоритм Джонсона-Троттера ==

{a=== Идея ===Сопоставим каждому элементу перестановки <tex>p[i]</tex> направление <subtex>2d[i]</subtex>. Будем указывать направление при помощи стрелок '''←''' ("влево") или '''→'''("вправо"). Назовём элемент подвижным, если по направлению стрелки стоит элемент меньше его. Например, aдля <subtex>p = \{1, 3, 2, 4, 5\},\;d = \{\leftarrow, \to, \leftarrow, \to, \leftarrow\}</subtex>, aподвижными являются элементы <subtex>3</subtex>, ..., aи <subtex>k - 15</subtex>. На каждой итерации алгоритма будем искать наибольший подвижный элемент и менять местами с элементом, aкоторый стоит по направлению стрелки. После чего поменяем направление стрелок на противоположное у всех элементов больших текущего. Изначально <subtex>kp = \{1, \dots ,n\},\;d = \{\leftarrow, \dots ,\leftarrow\}</subtex>} (4).

{a=== Пример работы алгоритма для n = 3 ===*<subtex>p = \{1, 2, \textbf{3}\}\;\;\;d = \{\leftarrow, \leftarrow, \leftarrow\}</subtex>, a*<subtex>p = \{1, \textbf{3}, 2\}\;\;\;d = \{\leftarrow, \leftarrow, \leftarrow\}</subtex>, a*<subtex>p = \{3, 1, \textbf{2}\}\;\;\;d = \{\leftarrow, \leftarrow, \leftarrow\}</subtex>*<tex> p = \{\textbf{3}, 2, 1\}\;\;\;d = \{\to, ...\leftarrow, '''a\leftarrow\}</tex>*<subtex>kp = \{2, \textbf{3}, 1\}\;\;\;d = \{\leftarrow, \to, \leftarrow\}</subtex>''', '''a*<subtex>k - p = \{2, 1, 3\}\;\;\;d = \{\leftarrow, \leftarrow, \to\}</subtex>'''}

=== Псевдокод ===<code> <font color=darkgreen>//Элементы нумеруются начиная с 1 </font 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>

{a₂=== Доказательство корректности ===Очевидно, a₁что требование о том, a₃, '''a_k'''что каждая генерируемая перестановка отличается от предыдущей транспозицией двух соседних элементов выполнено исходя из самого алгоритма. Осталось доказать, что таким образом мы сгенерируем все перестановки..., a_{k - 1}}

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

{a{Утверждение|id=approval1|statement=Число <subtex>2n</subtex>в перестановке не является подвижным элементом тогда и только тогда, '''aкогда первая компонента перестановки есть <subtex>k\overset{\text {$\leftarrow$}}{n}</subtex>''', '''a₁''', aили последняя компонента есть <subtex>3\overset{\text {$\to$}}{n}</subtex>, ..., a_{k - 1}}}

Для каждой {{Лемма|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 \} = k - 1$ (всего их $(k - 1)!$) мы получили $k$ новых перестановок. Итого $kP[i + 2]\backslash\{n\cdot(k - 1)! } = k!$ перестановок. Все они различны, т.к. для любых двух перестановок из нового кода Грея элемент $a_= P[i + n]\backslash\{kn\}$ стоит на разных позициях</tex>.|proof=Заметим,а что если $a_{k}$ стоит на одной и той же позициив перестановке есть подвижный элемент <tex>a \neq n</tex>, то эти перестановки образованы от разных перестановок длиной $n = k - 1$ (см. после транспозиции его с соседним элементом(3по направлению стрелки), (4))нам нужно будет заменить направление стрелок у всех элементов больше <tex>a</tex>. Так же все соседние как <tex>n</tex> больше любого элемента из перестановки отличаются ровно , то направление стрелки у него тоже изменится. По нашему утверждению, либо в одной транспозиции (образованные от одной перестановки различны благодаря построениюновой перестановке окажется компонента <tex>\overset{\text {$\to$}}{n}</tex> на первой позиции, от разных перестановок либо компонента <tex>\overset{\text {---$\leftarrow$}} имеют $a_{kn}$ </tex> на одной и той же последней позиции, но отличаются . В обоих случаях <tex>n</tex> окажется подвижным элементом в одной транспозиции, тследующих <tex>n</tex> перестановках.к. является перестановками Так как в коде Грея для перестановок длиной $следующих <tex>n</tex> перестановках подвижным элементом будет только <tex>n</tex>, то <tex>P[i + 1]\backslash\{n \} = k - 1$, см (3), (4))P[i + 2]\backslash\{n\} = .. Таким образом мы получили $k!$ различных перестановок длиной $k$, отличающихся в одной транспозиции. Алгоритм для построения кодов Грея для перестановок длиной $= 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) = 2$O(n)</tex>. Всего блоков <tex> -\:(n - 1)!</tex>. Общая асимптотика <tex>O(n) \cdot (n - 1)! = O(n!)</tex>.

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

{1, 2} Тогда следуя алгоритму полученный код будет выглядеть так(жирным выделены элементы, которые поменялись): {3, 2, 1} берем первую перестановку и добавляем в начало тройку {'''2''', '''3''', 1} двигаем до последней позиции {2, '''1''', '''3'''} {'''1''', '''2''', 3} берем следующую перестановку и записываем тройку в конец {1, '''3''', '''2'''} двигаем в начало {'''3''', '''1''', 2} Код Грея получен. == Псевдокод получения следующего кода Грея =Интересный факт=== Пусть нам известен код Грея для длины $nСуществует более общая формулировке задачи {{-1$, записанный в массив pred_perest[i](j), где $i$ - номер перестановки, $j$ - номер элемента этой перестановки (номерация начинается с единицы).  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 - 1 do {Для этой формулировки верно, что для каждой любой перестановки делаем n - 1 транспозиций} begin swap(pred_perest[i](j)<tex>u</tex> число различных перестановок <tex>v</tex>, pred_perest[i](j + 1)); {меняем j и j + 1 элементы местами} t := false; writeln(pred_perest[i]); end; end else begin vstavka(pred_perest[i]которые могут стоять после <tex>u</tex>, t); {вставляем в начало, если t = false} writeln(pred_perest[i]); for j := равно <tex>n - 1 downto 1 do begin swap(pred_perest[i](j), pred_perest[i](j + 1)); {меняем j и j + 1 элементы местами}</tex> числу Фибоначчи. t := true; writeln(pred_perest[i]); end; end;Этот факт был открыт студентом нашего университета.

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

* [[NP-полнота_задач_о_гамильтоновом_цикле_и_пути_в_графах | Гамильтонов путь]] == Литература Источники информации ==* Романовский, И.В. Дискретный Анализ - Санкт-Петербург , 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[[Категория: Дискретная математика и алгоритмы]] [[Категория: Комбинаторика ]]