Участник:ZeRoGerc — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
(Доказательство корректности)
(Орфографическая ошибка)
 
(не показаны 33 промежуточные версии 1 участника)
Строка 1: Строка 1:
'''Алгоритм Джонсона-Троттера'''(англ. ''Johnson-Trotter algorithm'') - алгоритм генерации всех перестановок из <tex>n</tex> элементов. Причём любая перестановка отличаются от предыдущей транспозицией двух соседних элементов.
+
'''Алгоритм Джонсона-Троттера'''(англ. ''Johnson-Trotter algorithm'') - алгоритм генерации всех перестановок из <tex>n</tex> элементов. Причём каждая перестановка отличаются от предыдущей транспозицией двух соседних элементов.
  
 
== Идея ==
 
== Идея ==
Сопоставим каждому элементу перестановки <tex>p[i]</tex> направление <tex>d[i]</tex>. Будем указывать направление при помощи стрелок '''←''' ("влево") или '''→'''("вправо"). Назовём элемент подвижным, если по направлению стелки стоит элемент меньше его. Например для <tex> p = \{1, 3, 2, 4, 5\},\;d = \{</tex>←, →, ←, →, ←<tex>\}</tex>, подвижными являются элементы 3 и 5. На каждой итерации алгоритма будем искать наибольший подвижный элемент и менять местами с элементом, который стоит по направлению стрелки. После чего поменяем направление стрелок на противоположное у всех элементов больших текущего. Изначально <tex> p = \{1, ... ,n\},\;d = \{</tex>←, ... ,←<tex>\}</tex>
+
Сопоставим каждому элементу перестановки <tex>p[i]</tex> направление <tex>d[i]</tex>. Будем указывать направление при помощи стрелок '''←''' ("влево") или '''→'''("вправо"). Назовём элемент подвижным, если по направлению стрелки стоит элемент меньше его. Например, для <tex> p = \{1, 3, 2, 4, 5\},\;d = \{</tex>←, →, ←, →, ←<tex>\}</tex>, подвижными являются элементы 3 и 5. На каждой итерации алгоритма будем искать наибольший подвижный элемент и менять местами с элементом, который стоит по направлению стрелки. После чего поменяем направление стрелок на противоположное у всех элементов больших текущего. Изначально <tex> p = \{1, ... ,n\},\;d = \{</tex>←, ... ,←<tex>\}</tex>.
  
 
== Пример работы алгоритма для n = 3 ==
 
== Пример работы алгоритма для n = 3 ==
Строка 14: Строка 14:
 
== Псевдокод ==
 
== Псевдокод ==
 
<code>
 
<code>
  //Элементы нумеруются начиная с 1  
+
  <font color=darkgreen> //Элементы нумеруются начиная с 1 </font color=darkgreen>
 
  p = {1, ... , n}
 
  p = {1, ... , n}
 
  d = {←, ... , ←}
 
  d = {←, ... , ←}
  while (true){
+
  '''while''' (true){
   print(); // печатаем текущую перестановку
+
   print(); <font color=darkgreen>// печатаем текущую перестановку</font color=darkgreen>
   id = -1; // индекс наибольшего подвижного элемента
+
   id = -1; <font color=darkgreen>// индекс наибольшего подвижного элемента </font color=darkgreen>
   for i (1 .. n){
+
   '''for''' i = (1 .. n){
       if (p[i] - подвижный && (id = -1 || p[i] > p[id]))
+
       '''if''' (p[i] - подвижный) '''and''' ((id = -1) '''or''' (p[i] > p[id]))
         id = i;
+
         id = i
 
   }
 
   }
   if (id = -1) break; // не нашли подвижного элемента
+
   '''if''' (id = -1) '''break''' <font color=darkgreen>// не нашли подвижного элемента</font color=darkgreen>
   swap(id); //меняем элемент p[id], d[id] c элементом по направлению стелки  
+
  '''for''' i = (1 .. n){
 +
    '''if''' (p[i] > p[id])
 +
      reverse(d[i]) <font color=darkgreen>// меняем направление стрелки</font color=darkgreen> 
 +
  }
 +
   swap(id) <font color=darkgreen>//меняем элемент p[id], d[id] c элементом по направлению стелки</font color=darkgreen>
 
  }
 
  }
 
</code>
 
</code>
  
 
== Доказательство корректности ==
 
== Доказательство корректности ==
Очевидно что требование о том что каждая генерируемая перестановка отличается от предыдущей транспозицией двух соседних элементов выполнено исходя из самого алгоритма. Осталось доказать что таким образом мы сгенерируем все перестановки. Будем использовать обозначениe <tex>(a,</tex> ←<tex>)</tex> - элемент с заданным направлением(компонента).
+
Очевидно, что требование о том, что каждая генерируемая перестановка отличается от предыдущей транспозицией двух соседних элементов выполнено исходя из самого алгоритма. Осталось доказать, что таким образом мы сгенерируем все перестановки.  
 +
 
 +
Будем использовать обозначения:
 +
*<tex>(a,</tex> ←<tex>)</tex> <tex> - </tex> элемент с заданным направлением(компонента).
 +
*<tex>P[i]</tex> <tex> - </tex> перестановка с номером <tex>i</tex>.
 +
*<tex>P[i]\backslash\{a\}\;</tex> <tex> - </tex> перестановка с номером <tex>i</tex> без элемента <tex>a</tex>.
 +
 
 
{{Утверждение
 
{{Утверждение
|id=id1
+
|id=approval1
|statement=Число <tex>n</tex> в перестановке не является подвижным элементом тогда и толко тогда когда первая компонента перестановки есть <tex>(n,</tex> ←<tex>)</tex> или последняя компонента есть <tex>(n,</tex> →<tex>)</tex>
+
|statement=Число <tex>n</tex> в перестановке не является подвижным элементом тогда и только тогда, когда первая компонента перестановки есть <tex>(n,</tex> ←<tex>)</tex> или последняя компонента есть <tex>(n,</tex> →<tex>)</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>(n,</tex> →<tex>)</tex> на первой позиции, либо компонента <tex>(n,</tex> ←<tex>)</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>.
 +
}}
 +
 
 +
Теперь докажем основную лемму.
 +
{{Лемма
 +
|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) * (n - 1)! = O(n!)</tex>.
 +
 +
==Сравнение с рекурсивным алгоритмом==
 +
Главным приемуществом алгоритма Джонсона-Троттера является то, что нам не нужно хранить все предыдущие перестановки (из <tex>n - 1</tex> элемента), а только текущую. Следовательно, этот алгоритм потребляет только <tex>O(n)</tex> памяти. Также, из-за нерекурсивности этот алгоритм работает быстрее. Это можно строго доказать, но доказательство довольно громозодкое и приводить его мы здесь не будем.
 +
 +
==Коды грея==

Текущая версия на 22:53, 16 декабря 2019

Алгоритм Джонсона-Троттера(англ. Johnson-Trotter algorithm) - алгоритм генерации всех перестановок из [math]n[/math] элементов. Причём каждая перестановка отличаются от предыдущей транспозицией двух соседних элементов.

Идея

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

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

  • [math] p = \{1, 2, \textbf{3}\}\;\;\;d = \{[/math]←, ←, ←[math]\}[/math]
  • [math] p = \{1, \textbf{3}, 2\}\;\;\;d = \{[/math]←, ←, ←[math]\}[/math]
  • [math] p = \{3, 1, \textbf{2}\}\;\;\;d = \{[/math]←, ←, ←[math]\}[/math]
  • [math] p = \{\textbf{3}, 2, 1\}\;\;\;d = \{[/math]→, ←, ←[math]\}[/math]
  • [math] p = \{2, \textbf{3}, 1\}\;\;\;d = \{[/math]←, →, ←[math]\}[/math]
  • [math] p = \{2, 1, 3\}\;\;\;d = \{[/math]←, ←, →[math]\}[/math]

Псевдокод

 //Элементы нумеруются начиная с 1  
p = {1, ... , n}
d = {←, ... , ←}
while (true){
  print(); // печатаем текущую перестановку
  id = -1; // индекс наибольшего подвижного элемента 
  for i = (1 .. n){
     if (p[i] - подвижный) and ((id = -1) or (p[i] > p[id]))
       id = i
  }
  if (id = -1) break // не нашли подвижного элемента
  for i = (1 .. n){
    if (p[i] > p[id]) 
      reverse(d[i]) // меняем направление стрелки  
  }
  swap(id) //меняем элемент p[id], d[id] c элементом по направлению стелки
}

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

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

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

  • [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[/math] в перестановке не является подвижным элементом тогда и только тогда, когда первая компонента перестановки есть [math](n,[/math][math])[/math] или последняя компонента есть [math](n,[/math][math])[/math].


Лемма:
Если в перестановке [math]P[i][/math] есть подвижный элемент [math]a \neq n[/math], то также определены перестановки [math]P[i + 1] ... P[i + n][/math]. Причём, [math]P[i + 1]\backslash\{n\} = P[i + 2]\backslash\{n\} = ... = P[i + n]\backslash\{n\}[/math].
Доказательство:
[math]\triangleright[/math]
Заметим, что если в перестановке есть подвижный элемент [math]a \neq n[/math], то после транспозиции его с соседним элемнтом(по направлению стрелки), нам нужно будет заменить направление стрелок у всех элементов больше [math]a[/math]. Так как [math]n[/math] больше любого элемента из перестановки, то направление стрелки у него тоже изменится. По нашему утверждению, либо в новой перестановке окажется компонента [math](n,[/math][math])[/math] на первой позиции, либо компонента [math](n,[/math][math])[/math] на последней позиции. В обоих случаях [math]n[/math] окажется подвижным элементом в следующих [math]n[/math] перестановках. Так как в следующих [math]n[/math] перестановках подвижным элементом будет только [math]n[/math], то [math]P[i + 1]\backslash\{n\} = P[i + 2]\backslash\{n\} = ... = P[i + n]\backslash\{n\}[/math].
[math]\triangleleft[/math]

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

Лемма:
Алгоритм Джонсона-Троттера строит все перестановки из [math]n[/math] элементов, причём каждая перестановка отличаются от предыдущей транспозицией двух соседних элементов.
Доказательство:
[math]\triangleright[/math]

Доказывать будем по индукции. Для [math]n = 1\; - [/math] очевидно. Предположим, что для [math]n - 1[/math] алгоритм строит перестановки корректно. Докажем, что алгоритм будет корректно строить перестановки и для [math]n[/math] элементов. Разобьём все [math]n![/math] перестановок на блоки по [math]n[/math] (подряд). В силу вышедоказанной леммы в каждом блоке [math]P[i]\backslash\{n\} = P[i + 1]\backslash\{n\} = ... = P[i + n]\backslash\{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]\triangleleft[/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] памяти. Также, из-за нерекурсивности этот алгоритм работает быстрее. Это можно строго доказать, но доказательство довольно громозодкое и приводить его мы здесь не будем.

Коды грея