Коды Грея для перестановок

Коды Грея для перестановок(англ. Gray code for permutation) — упорядочение перестановок, при котором соседние перестановки отличаются только элементарной транспозицией.

Элементарная транспозиция(англ. Adjacent transposition) — перестановка местами двух соседних элементов.

Содержание

1 Построение кода Грея для перестановок
2 Пример применения алгоритма
3 Псевдокод получения кода Грея
4 Примеры кодов Грея для перестановок
5 Реализация в нерекурсивном виде. Алгоритм Джонсона-Троттера
6 Сведение задачи построения кода Грея для перестановок к графам
7 См. также
8 Источники информации

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

Будем строить код Грея для длины [math]n = k[/math]. Предположим, что нам известен код Грея для перестановок длиной [math]k - 1[/math]. Возьмем первую перестановку из известного нам кода. Она имеет следующий вид:

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

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

Элемент [math]k[/math] записываем в конец и начинаем "двигать" его влево:

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

Таким образом получаем для каждой перестановки длиной [math]k - 1[/math] (всего [math](k - 1)![/math] штук) по [math]k[/math] новых перестановок, в сумме [math]k\cdot(k - 1)! = k![/math] перестановок. Все они различны, так как для любых двух перестановок из нового кода Грея элемент [math]k[/math] стоит на разных позициях,а если [math]k[/math] стоит на одной и той же позиции, то эти перестановки образованы от разных перестановок длиной [math]k - 1[/math]. Так же все соседние перестановки отличаются ровно в одной элементарной транспозиции. Итого, мы получили список из [math]k![/math] различных перестановок длиной [math]k[/math], причём соседние отличаются в одной элементарной транспозиции.

Пример применения алгоритма

Рассмотрим код Грея для длины [math]n = 2[/math]:

[math]\{2, 1\}[/math]
[math]\{1, 2\}[/math]

Тогда следуя алгоритму полученный код будет выглядеть так (подчёркнуты пары переставляемых элементов):

[math]\{\underline{3, 2}, 1\}[/math] — берем первую перестановку и добавляем в начало тройку
[math]\{2, \underline{3, 1}\}[/math] — двигаем до последней позиции
[math]\{\underline{2, 1}, 3\}[/math]
[math]\{1, \underline{2, 3}\}[/math] — берем следующую перестановку и записываем тройку в конец
[math]\{\underline{1, 3}, 2\}[/math] — двигаем в начало
[math]\{3, 1, 2\}[/math]

Код Грея получен.

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

Получаем код Грея рекурсивно, в базовом случае [math]n = 1[/math] возвращаем список из одной перестановки [math]\{1\}[/math].

 list< list<int> > gray_code(n):
   if n == 1
     return [{1}]                                  //возращаем список из одной перестановки
   else
     list< list<int> > result = []                //пустой список
     list< list<int> > perms = gray_code(n - 1)   //perms — перестановки из n - 1 элемента
     bool backward = false                        //переменная которая говорит с какой стороны заполнять перестановку
     (for perm in perms)                          //perm — текущая перестановка
       if backward
         list<int> current = concat(perm, {n})    //дописываем {n} в конец perm
         result.append(current)                   //добавляем в ответ перестановку current
         (for i = n downto 2)
           swap(current[i - 1], current[i])       //переставляем n
           result.append(current)                 //добавляем в ответ перестановку current
       else
         list<int> current = concat({n}, perm)    //дописываем {n} в начало perm
         result.append(current)                   //добавляем в ответ перестановку current
         (for i = 1 to n - 1)
           swap(current[i], current[i + 1])       //переставляем n
           result.append(current)                 //добавляем в ответ перестановку current
       backward = not backward                    //меняем состояние backward
     return result                               //возвращаем ответ в виде списка

Примеры кодов Грея для перестановок

Перестановки для n = 2

Номер	Перестановка
[math]1[/math]	[math]\{1, 2\} [/math]
[math]2[/math]	[math]\{2, 1\} [/math]

Перестановки для n = 3

Номер	Перестановка
[math]1[/math]	[math]\{1, 2, 3\} [/math]
[math]2[/math]	[math]\{1, 3, 2\} [/math]
[math]3[/math]	[math]\{3, 1, 2\}[/math]
[math]4[/math]	[math]\{3, 2, 1\}[/math]
[math]5[/math]	[math]\{2, 3, 1\} [/math]
[math]6[/math]	[math]\{2, 1, 3\} [/math]

Реализация в нерекурсивном виде. Алгоритм Джонсона-Троттера

Идея

Сопоставим каждому элементу перестановки [math]p[i][/math] направление [math]d[i][/math]. Будем указывать направление при помощи стрелок ← ("влево") или →("вправо"). Назовём элемент подвижным, если по направлению стелки стоит элемент меньше его. Например, для ←, →, ←, →, ←[math]\}[/math], подвижными являются элементы 3 и 5. На каждой итерации алгоритма будем искать наибольший подвижный элемент и менять местами с элементом, который стоит по направлению стрелки. После чего поменяем направление стрелок на противоположное у всех элементов больших текущего. Изначально ←, ... ,←[math]\}[/math].

Пример работы алгоритма для n = 3

←, ←, ←[math]\}[/math]
←, ←, ←[math]\}[/math]
←, ←, ←[math]\}[/math]
→, ←, ←[math]\}[/math]
←, →, ←[math]\}[/math]
←, ←, →[math]\}[/math]

Псевдокод


//Элементы нумеруются начиная с 1  
list< list<int> > gray_code(n):
  list<int> perm = {1, \dots , n}
  list<char> dir = {←, \dots , ←}
  list< list<int> > result
  while (true)
    result.append(perm);  //добавляем в ответ текущую перестановку
    int id = -1;  //индекс наибольшего подвижного элемента 
    for (i = 1 to n)
       if (perm[i] - подвижный) and ((id == -1) or (perm[i] > perm[id]))
         id = i
    if (id == -1) break  //не нашли подвижного элемента
    for (i = 1 to n){
      if (perm[i] > perm[id]) 
        reverse(dir[i])  //меняем направление стрелки  
    swap(id)  //меняем элемент perm[id], dir[id] c элементом по направлению стелки
 return result

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

Очевидно, что требование о том, что каждая генерируемая перестановка отличается от предыдущей транспозицией двух соседних элементов выполнено исходя из самого алгоритма. Осталось доказать, что таким образом мы сгенерируем все перестановки.

Будем использовать обозначения:

[math](a,[/math] ←[math])[/math] [math] - [/math] элемент с заданным направлением(компонента).
[math]P[i][/math] [math] - [/math] перестановка с номером [math]i[/math].
[math]P[i]\backslash\{a\}\;[/math] [math] - [/math] перестановка с номером [math]i[/math] без элемента [math]a[/math].

Утверждение:

Число в перестановке не является подвижным элементом тогда и только тогда, когда первая компонента перестановки есть ← или последняя компонента есть →.

Лемма:

Если в перестановке есть подвижный элемент , то также определены перестановки . Причём, .

Доказательство:

Заметим, что если в перестановке есть подвижный элемент , то после транспозиции его с соседним элемнтом(по направлению стрелки), нам нужно будет заменить направление стрелок у всех элементов больше . Так как больше любого элемента из перестановки, то направление стрелки у него тоже изменится. По нашему утверждению, либо в новой перестановке окажется компонента → на первой позиции, либо компонента ← на последней позиции. В обоих случаях окажется подвижным элементом в следующих перестановках. Так как в следующих перестановках подвижным элементом будет только , то .

Теперь докажем основную лемму.

Лемма:

Алгоритм Джонсона-Троттера строит все перестановки из элементов, причём каждая перестановка отличаются от предыдущей транспозицией двух соседних элементов.

Доказательство:

Доказывать будем по индукции. Для [math]n = 1\; - [/math] очевидно. Предположим, что для [math]n - 1[/math] алгоритм строит перестановки корректно. Докажем, что алгоритм будет корректно строить перестановки и для [math]n[/math] элементов. Разобьём все [math]n![/math] перестановок на блоки по [math]n[/math] (подряд). В силу вышедоказанной леммы в каждом блоке , если [math]i\; - [/math] начало группы. Значит, в каждой группе какая-то перестановка из [math]n - 1[/math] элемента дополняется до перестановки из [math]n[/math] всеми возможными способами. Теперь докажем, что на переход между блоками элемент [math]n[/math] никак не влияет. Заметим, что при переходе между блоками [math]n[/math] является неподвижным элементом. В силу нашего утверждения [math]n[/math] стоит либо на первой, либо на последней позиции. Так как [math]n[/math] больше любого элемента, то никакой подвижный элемент не может указывать на [math]n[/math]. В силу этих фактов [math]n[/math] никак не повлияет на переход между блоками. Из этого можно сделать вывод, что при переходе между блоками перестановки строятся так же, как и перестановки из [math]n - 1[/math] элемента, а каждая такая перестановка дополняется до перестановки из [math]n[/math] элементов всеми возможными способами.

Корректность алгоритма доказана.

Асимптотика

Поговорим об асиптотике. Снова разобьём наши перестановки на блоки по [math]n[/math] элементов. Немного модифицируем алгоритм. Заметим, что в каждом блоке нам нужно искать максимальный элемент только один раз. В остальных случаях этим элементом будет [math]n[/math]. Следовательно, менять направление стрелок нужно тоже только один раз(в остальных случаях менять направления не нужно, так как [math]n[/math] - подвижный элемент, а менять направление стрелок нужно только у бóльших элементов). Следовательно, блок выполняется за [math]O(n) + O(n) + O(n) = O(n)[/math]. Всего блоков [math] -\:(n - 1)![/math]. Общая асимптотика [math]O(n) * (n - 1)! = O(n!)[/math].

Сравнение с рекурсивным алгоритмом

Главным приемуществом алгоритма Джонсона-Троттера является то, что нам не нужно хранить все предыдущие перестановки (из [math]n - 1[/math] элемента), а только текущую. Следовательно, этот алгоритм потребляет только [math]O(n)[/math] памяти. Также, из-за нерекурсивности этот алгоритм работает быстрее. Это можно строго доказать, но доказательство довольно громозодкое и приводить его мы здесь не будем.

Сведение задачи построения кода Грея для перестановок к графам

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

См. также

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

Романовский И.В. Дискретный Анализ - Санкт-Петербург, 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