Коды Грея для перестановок — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
Строка 67: Строка 67:
 
== Псевдокод получения следующего кода Грея ==
 
== Псевдокод получения следующего кода Грея ==
  
Пусть нам известен код Грея для длины $n - 1$, записанный в массив из строк $s[i]$, где $i$ - номер перестановки (номерация начинается с единицы, элементы разделены пробелами). При этом переменная $t = true$, $j = 1$, а $k$ является новым элементом:
+
Пусть нам известен код Грея для длины $n - 1$, записанный в массив из строк $perm[i](j)$, где $i$ - номер перестановки, а $j$ номера элементов перестановок(номерация начинается с единицы). При этом переменная $t = true$, $j = 1$:
  
 
   procedure grey_code(t: boolean; j: integer);
 
   procedure grey_code(t: boolean; j: integer);
 
     var
 
     var
      str: string;
+
       i, c: integer;
       i: integer;
 
 
       begin   
 
       begin   
 
       if j <= (n - 1)! then {условие выхода из рекурсии}
 
       if j <= (n - 1)! then {условие выхода из рекурсии}
Строка 78: Строка 77:
 
           if t = true then
 
           if t = true then
 
             begin
 
             begin
               str := k + ' ' + s[j]; {записываем элемент n в начало строки}
+
               for l := n - 1 downto 1 do  {записываем элемент n в начало строки}
               writeln(str);
+
              perm[j](l + 1) := perm[j](l);
 +
              perm[j](1) := n;
 +
              for l := 1 to n do
 +
               writeln(perm[j](1), ' '); {выводим перестановку}
 
               for i := 0 to n - 2 do
 
               for i := 0 to n - 2 do
 
                 begin
 
                 begin
                   c := str[2 * i + 1];  {меняем элементы местами и выводим каждую новую перестановку}
+
                   c := perm[j](i);  {меняем элементы местами и выводим каждую новую перестановку}
                   str[2 * i + 1] := str[2 * i + 3];
+
                   perm[j](i) := perm[j](i + 1);
                   str[2 * i + 3] := c;
+
                   perm[j](i + 1) := c;
                   writeln(str);
+
                  for l := 1 to n do
 +
                   writeln(perm[j](1), ' '); {выводим перестановку}
 
                 end;
 
                 end;
 
               grey_code(not t, j + 1);  {повторяем процедуру}
 
               grey_code(not t, j + 1);  {повторяем процедуру}
Строка 91: Строка 94:
 
           else
 
           else
 
             begin
 
             begin
               str := s[j] + ' ' + k; {записываем элемент n в конец строки}
+
               perm[j](n) := n; {записываем элемент n в конец строки}
               writeln(str);
+
              for l := 1 to n do
 +
               writeln(perm[j](1), ' '); {выводим перестановку}
 
               for i := n - 2 downto 0 do
 
               for i := n - 2 downto 0 do
 
                 begin   
 
                 begin   
                   c := str[2 * i + 1];  {меняем элементы местами и выводим каждую новую перестановку}
+
                   c := perm[j](i);  {меняем элементы местами и выводим каждую новую перестановку}
                   str[2 * i + 1] := str[2 * i + 3];
+
                   perm[j](i) := perm[j](i + 1);
                   str[2 * i + 3] := c;
+
                   perm[j](i + 1) := c;
                   writeln(str);
+
                  for l := 1 to n do
 +
                   writeln(perm[j](1), ' '); {выводим перестановку}
 
                 end;
 
                 end;
 
               grey_code(not t, j + 1); {повторяем процедуру}
 
               grey_code(not t, j + 1); {повторяем процедуру}

Версия 04:21, 28 декабря 2011

<wikitex>

Определения

Определение:
Коды Грея для перестановок — упорядочение перестановок, при котором соседние перестановки отличаются только элементарной транспозицией.
Элементарная транспозиция — транспозиция двух соседних элементов.


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

$n = 2$ $\{1, 2\}$ $\{2, 1\}$
$n = 3$ $\{1, 2, 3\}$ $\{1, 3, 2\}$ $\{3, 1, 2\}$ $\{3, 2, 1\}$ $\{2, 3, 1\}$ $\{2, 1, 3\}$

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

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

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

  • $\{\underline{k, a_1}, a_2, a_3, \dots, a_{k-1}\}$
  • $\{a_1, \underline{k, a_2}, a_3, \dots, a_{k-1}\}$
  • $\{a_1, a_2, \underline{k, a_3}, \dots, a_{k-1}\}$
  • $\{a_1, a_2, a_3, \underline{k, \dots}, a_{k-1}\}$
  • $\{a_1, a_2, a_3, \dots, \underline{k, a_{k-1}}\}$
  • $\{a_1, a_2, a_3, \dots, a_{k-1}, k\}$

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

$\{a_2, a_1, a_3, \dots, a_{k-1}\}$

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

  • $\{a_2, a_1, a_3, \dots, \underline{a_{k-1}, k}\}$
  • $\{a_2, a_1, a_3, \underline{\dots, k}, a_{k-1}\}$
  • $\{a_2, a_1, \underline{a_3, k}, \dots, a_{k-1}\}$
  • $\{a_2, \underline{a_1, k}, a_3, \dots, a_{k-1}\}$
  • $\{\underline{a_2, k}, a_1, a_3, \dots, a_{k-1}\}$
  • $\{k, a_2, a_1, a_3, \dots, a_{k-1}\}$

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

Для каждой перестановки длиной $n = k - 1$ (всего их $(k - 1)!$) мы получили $k$ новых перестановок. Итого $k\cdot(k - 1)! = k!$ перестановок. Все они различны, т.к. для любых двух перестановок из нового кода Грея элемент $k$ стоит на разных позициях,а если $k$ стоит на одной и той же позиции, то эти перестановки образованы от разных перестановок длиной $n = k - 1$. Так же все соседние перестановки отличаются ровно в одной элементарной транспозиции (образованные от одной перестановки различны благодаря построению, от разных перестановок — имеют $k$ на одной и той же позиции, но отличаются в одной элементарной транспозиции, т.к. является перестановками в коде Грея для перестановок длиной $n = k - 1$). Таким образом мы получили $k!$ различных перестановок длиной $k$, отличающихся в одной элементарной транспозиции. Алгоритм для построения кодов Грея для перестановок длиной $n$ получен.

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

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

  • $\{2, 1\}$
  • $\{1, 2\}$

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

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

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

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

Пусть нам известен код Грея для длины $n - 1$, записанный в массив из строк $perm[i](j)$, где $i$ - номер перестановки, а $j$ номера элементов перестановок(номерация начинается с единицы). При этом переменная $t = true$, $j = 1$:

 procedure grey_code(t: boolean; j: integer);
   var
     i, c: integer;
     begin  
     if j <= (n - 1)! then {условие выхода из рекурсии}
       begin
         if t = true then
           begin
             for l := n - 1 downto 1 do  {записываем элемент n в начало строки}
             perm[j](l + 1) := perm[j](l);
             perm[j](1) := n;
             for l := 1 to n do
             writeln(perm[j](1), ' ');  {выводим перестановку}
             for i := 0 to n - 2 do
               begin
                 c := perm[j](i);  {меняем элементы местами и выводим каждую новую перестановку}
                 perm[j](i) := perm[j](i + 1);
                 perm[j](i + 1) := c;
                 for l := 1 to n do
                 writeln(perm[j](1), ' ');  {выводим перестановку}
               end;
             grey_code(not t, j + 1);  {повторяем процедуру}
           end
         else
           begin
             perm[j](n) := n; {записываем элемент n в конец строки}
             for l := 1 to n do
             writeln(perm[j](1), ' ');  {выводим перестановку}
             for i := n - 2 downto 0 do
               begin  
                 c := perm[j](i);  {меняем элементы местами и выводим каждую новую перестановку}
                 perm[j](i) := perm[j](i + 1);
                 perm[j](i + 1) := c;
                 for l := 1 to n do
                 writeln(perm[j](1), ' ');  {выводим перестановку}
               end;
             grey_code(not t, j + 1); {повторяем процедуру}
           end;
       end;
     end;


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

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

См. также

Литература

Романовский, И.В. Дискретный Анализ - Санкт-Петербург 2003 стр. 39-41