Викиконспекты - Вклад участника [ru]

Получение следующего объекта

2014-01-04T23:04:18Z

91.122.22.64: /* Специализация алгоритма для генерации следующего разбиения на подмножества */

== Алгоритм ==
{{Определение|definition= '''Получение следующего объекта''' {{---}} это нахождение объекта, следующего за данным в [[Лексикографический порядок|лексикографическом порядке]].
}}
Объект <tex>Q</tex> называется следующим за <tex>P</tex>, если <tex>P < Q</tex> и не найдется такого <tex>R</tex>, что <tex>P < R < Q</tex>.

Отсюда понятен алгоритм:
* Находим суффикс минимальной длины, который можно изменить без изменения префикса текущего объекта <tex>P</tex>
* К оставшейся части дописываем минимальный возможный элемент (чтобы было выполнено правило <tex>P < Q</tex>)
* Дописываем минимальный возможный хвост
По построению получаем, что <tex>Q</tex> {{---}} минимально возможный.

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 битового вектора] ==
* Находим минимальный суффикс, в котором есть 0, его можно увеличить, не меняя оставшейся части
* Вместо 0 записываем 1
* Дописываем минимально возможный хвост из нулей
'''function''' nextVector(a:array[1..n] of byte):array[1..n] of byte; // n - длина вектора
'''for''' i = n '''downto''' 1
'''if''' a[i] == 0
a[i] = 1
'''for''' j = i + 1 to n
a[j] = 0
'''break'''
return(a);

=== Пример работы ===
{| class="wikitable" border = 1
|0||1||style="background:#FFCC00"|0||1||1||исходный битовый вектор
|-
| || ||^|| || ||находим элемент 0 (самый правый)
|-
|0||1||style="background:#FFCC00"|1||1||1||меняем его на 1
|-
|0||1||1||style="background:#FFCC00"|0||style="background:#FFCC00"|0||меняем элементы правее на нули
|-
|'''0'''||'''1'''||'''1'''||'''0'''||'''0'''||следующий битовый вектор
|}

== Специализация алгоритма для генерации [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 следующей перестановки] ==
* Двигаясь справа налево, находим элемент, нарушающий убывающую последовательность (в обычном порядке, слева направо, см. пример)
* Меняем его с минимальным элементом, большим нашего, стоящим правее
* Перевернем правую часть

'''function''' nextPermutation(a:array[1..n] of integer):array[1..n] of integer; // n - длина перестановки
'''for''' i = n - 1 '''downto''' 1
'''if''' a[i] < a[i + 1]
'''for''' j = i + 1 '''to''' n
'''if''' (a[j] < a[min]) and (a[j] > a[i])
min==j
swap(a[i], a[j])
reverse(a[i + 1]..a[n])
'''break'''
return(a);

=== Пример работы ===
{| class="wikitable" border = 1
|1||3||style="background:#FFCC00"|2||5||style="background:#FFCC00"|4||исходная перестановка
|-
| || ||^|| || ||находим элемент, нарушающий убывающую последовательность
|-
| || || || ||^||минимальный элемент больше нашего
|-
|1||3||style="background:#FFCC00"|4||5||style="background:#FFCC00"|2||меняем их местами
|-
|1||3||4||style="background:#FFCC00"|2||style="background:#FFCC00"|5||разворачивам правую часть
|-
|'''1'''||'''3'''||'''4'''||'''2'''||'''5'''||следующая перестановка
|}

== Специализация алгоритма для генерации следующей [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 мультиперестановки] ==
* Двигаясь справа налево, находим элемент, нарушающий убывающую последовательность (в обычном порядке, слева направо, см. пример).
* Меняем его с минимальным элементом, большим нашего, стоящим правее.
* Переворачиваем правую часть.
'''function''' nextMultiperm(var b:array[1..N] of integer): array[1..N] of integer;
'''var''' i , j : '''integer''';
'''begin'''
i := N - 1;
'''while''' (i > 0) '''and''' (b[i] >= b[i + 1]) '''do'''
dec(i);
'''if''' i > 0 '''then'''
'''begin'''
j := i + 1;
'''while''' (j < N) '''and''' (b[j + 1] > b[i]) '''do'''
inc(j);
swap(b[i] , b[j]);
'''for''' j := i + 1 '''to''' (N + i) '''div''' 2 '''do'''
swap(b[j], b[N - j + i + 1]);
return(b[1..N]);
'''end'''
'''else'''
'''begin'''
return(null);
'''end;'''
'''end;'''

=== Пример работы ===
{| class="wikitable" border = 1
|1||2||3||1||style="background:#FFCC00"|2||style="background:#FFCC00"|3||Исходная перестановка.
|-
| || || || ||^|| ||Находим элемент, нарушающий убывающую последовательность.
|-
| || || || || ||^||Минимальный элемент больше нашего.
|-
|1||2||3||1||style="background:#FFCC00"|3||style="background:#FFCC00"|2||Меняем их местами.
|-
|'''1'''||'''2'''||'''3'''||'''1'''||'''3'''||'''2'''||Следующая мультиперестановка.
|}

== Специализация алгоритма для генерации [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 следующего сочетания] ==

* Добавим в конец массива с сочетанием N+1 – максимальный элемент.
* Пойдём справа налево. Будем искать номер элемента, который отличается от предыдущего на 2.
* Увеличим найденный элемент на 1, и допишем в конец минимально возможный хвост, если такого элемента нет – на вход было дано последнее сочетание.
'''function''' nextChoose(var a:array[1..k] of integer): array[1..k] of integer; // n,k - параметры сочетания.
'''var'''
i,j : '''integer;'''
b:array[1..k+1] of '''integer;'''
'''begin'''
'''for''' i := 1 '''to''' k '''do'''
b[i]:=a[i];
b[k + 1] := n + 1;
i := n;
'''while''' (i > 0) '''and''' ((b[i + 1] - b[i]) < 2) '''do'''
i := i - 1;
'''if''' i > 0 '''then'''
'''begin'''
b[i] := b[i] + 1;
'''for''' j := i + 1 '''to''' k '''do'''
b[j] := b[j - 1] + 1;
'''for''' i := 1 '''to''' k '''do'''
a[i] := b[i];
return(a[1..k]);
'''end'''
'''else'''
return(null);
'''end;'''

=== Пример работы ===
{| class="wikitable" border = 1
|1||2||5||6||style="background:#FFCC00"|'''7'''||Дописываем 7 в конец сочетания.
|-
|1||style="background:#FFCC00"|2||5||6||'''7'''||
|-
| ||^|| || || ||Находим элемент i, a[i + 1] - a[ i ] >= 2
|-
|1||style="background:#FFCC00"|3||5||6||'''7'''||Увеличиваем его на 1.
|-
|1||3||style="background:#FFCC00"|4||style="background:#FFCC00"|5||style="background:#FFCC00"|'''6'''||Дописываем минимальный хвост.
|-
|'''1'''||'''3'''||'''4'''||'''5'''||''' '''||Следующее сочетание.
|}

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 разбиения на слагаемые] ==
Рассматриваемый алгоритм находит следующее разбиение на слагаемые, при этом разбиение упорядоченно по возрастанию.
* Увеличим предпоследнее слагаемое на 1, уменьшим последнее слагаемое на 1.
** Если предпоследнее слагаемое стало больше последнего, то увеличиваем предпоследнее слагаемое на величину последнего.
** Если предпоследнее слагаемое меньше последнего, то разбиваем последнее слагаемое <tex>s</tex> на два слагаемых <tex>a</tex> и <tex>b</tex> таких, что <tex>a</tex> равно предпоследнему слагаемому, а <tex>b = s - a</tex>. Повторяем этот процесс, пока разбиение остается корректным, то есть предпоследнее слагаемое хотя бы в два раза меньше последнего.

<code>
// b – список, содержащий разбиение данного числа, length – его размер.
'''function''' nextPartition(var b: list<int>): list<int>;
'''var''' i : '''integer;'''
'''begin'''
b[b.size] := b[b.size] - 1;
b[b.size - 1] := b[b.size - 1] + 1;
'''if''' b[b.size - 1] > b[b.size] '''then'''
'''begin'''
b[b.size - 1] := b[b.size - 1] + b[b.size];
b.pop();
'''end'''
'''else'''
'''begin'''
'''while''' b[b.size - 1] * 2 <= b[b.size] '''do'''
'''begin'''
b.add(b[b.size] - b[b.size - 1]);
b[b.size - 1] := b[b.size - 2];
'''end;'''
'''end;'''
'''return''' b;
'''end;'''
</code>

=== Пример работы ===
{| class="wikitable" border = 1
|1||style="background:#FFCC00"|1||style="background:#FFCC00"|7|| || ||Прибавим 1 + 1, вычтем 7 - 1.
|-
|1||style="background:#FFCC00"|2||style="background:#FFCC00"|6|| || ||Проверяем: 2<6, значит разбиваем 6 пока оно не станет <4
|-
|1||2||style="background:#FFCC00"|2||style="background:#FFCC00"|4|| ||
|-
|1||2||2||style="background:#FFCC00"|2||style="background:#FFCC00"|2||
|-
|'''1'''||'''2'''||'''2'''||'''2'''||'''2'''||Следующее разбиение на слагаемые числа 9.
|}

{| class="wikitable" border = 1
|1||style="background:#FFCC00"|4||style="background:#FFCC00"|5||Прибавим 4 + 1, вычтем 5 - 1.
|-
|1||style="background:#FFCC00"|5||style="background:#FFCC00"|4||Проверяем: 5>4, значит прибавим к 5 + 4.
|-
|1||9||style="background:#FFCC00"|4||Удалим последний элемент.
|-
|'''1'''||'''9'''||||Следующее разбиение на слагаемые числа 10.
|}

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 разбиения на подмножества] ==

Рассмотрим множество первых n натуральных чисел:<tex>N_n = \{1, 2, ..., n\}</tex>

Упорядочим все разбиения на множества <tex>N_n</tex> лексикографически. Для этого, во-первых, в каждом разбиении упорядочим множества лексикографически. Будем говорить, что подмножество <tex> A \subset N_n </tex> лексикографически меньше подмножества <tex> B \subset N_n </tex> , если верно одно из следующих условий:

*существует <tex>i</tex> такое, что <tex>i \in A</tex> , <tex>i \notin B</tex>, для всех <tex>j < i: j \in A</tex> если и только если <tex>j \in B</tex> , и существует <tex>k > i</tex> такое что <tex>k \in B</tex>;
* <tex> A \subset B </tex> и <tex>i < j</tex> для всех <tex>i \in A</tex> и <tex>j \in B</tex> \ <tex> A </tex>.

Разбиения упорядочены лексикографически следующим образом. Разбиение <tex>N_n = A_1 \cup A_2 \cup . . . \cup A_k</tex> лексикографически меньше разбиения <tex>N_n = B_1 \cup B_2 \cup . . . \cup B_l</tex> если существует такое <tex>i</tex>, что <tex>A_1 = B_1, A_2 = B_2, . . . ,A_{i - 1} = B_{i - 1}, A_i < B_i</tex>.

'''Рассмотрим алгоритм нахождения лексикографически следующего разбиения на подмножества:'''
*Будем хранить подмножества в списке списков, например, разбиение <tex> \{1, 2, 3\}~ \{4, 5\}</tex> будет выглядеть так:

{| class="wikitable" border = 1
|1||2||3
|-
|4||5||
|}

* Двигаясь снизу вверх и справа налево, будем удалять элементы, записывая их в отдельный массив. Будем повторять эту операцию, пока не сможем выполнить одно из действий, описанных ниже:
** Заменить рассматриваемый элемент уже удаленным. Из всех подходящих элементов выбираем минимальный. '''Важное замечание''': мы не можем заменить 1ый элемент подмножества, мы можем только удалить его.
** Дополнить рассматриваемое подмножество уже удаленным элементом. Из всех подходящих элементов выбираем минимальный.
* Допишем лексикографически минимальный хвост подмножеств из оставшихся элементов.

<code>
'''function''' nextSetPartition(a:list<list<int>>):list<list<int>>;
// a - список, содержащий подмножества
// used - список, в котором мы храним удаленные элементы
used = list<int>();
fl = ''false''
'''for''' i = a.size '''downto''' 1
'''if''' (used.size <> 0) and (used[used.size] > a[i][a[i].size]) '''then''' //если можем добавить в конец подмножества элемент из used
a[i].add(used[used.size]); //добавляем
used.remove(used.size);
'''break'''
'''for''' j = a[i].size '''downto''' 1
'''if''' (used.size <> 0) and (j <> 1) and (used[used.size] > a[i][j]) '''then''' //если можем заменить элемент, другим элементом из списка used
a[i][j] = used[used.size]; //заменяем
fl = ''true''
'''break'''
'''if''' (fl) '''break'''
used.add(a[i][j]); // добавляем в used j элемент i-го подмножества
a[i].remove(j); // удаляем j элемент i-го подмножества
// далее выведем все получившиеся подмножества
sort(used)
'''for''' i = 1 '''to''' used.size
a.add(list<int>(used[i])); // добавляем лексикографически минимальных хвост
return(a);
</code>

=== Пример работы ===

'''Рассмотрим следующее разбиение:'''

{| class="wikitable" border = 1
|1||2||3
|-
|4||5||
|}

'''1 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||
|-
|4||style="background:#FFCC00"|5||||
|-
| ||^|| ||Удалили элемент 5.
|-
| || || ||used
|}

'''2 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||
|-
|style="background:#FFCC00"|4|| ||||
|-
|^|| || ||Удалили элемент 4. Так как он является первым в подмножестве, то мы не можем заменить его на другой.
|-
|5|| || ||used
|}

'''3 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||style="background:#FFCC00"|4||
|-
| || || ||^||Дополнили первое подмножество элементом 4
|-
|5|| || || ||used
|}

'''4 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||4||
|-
|style="background:#FFCC00"|5|| || || ||Дописали лексикографически минимальный хвост
|-
| || || || ||used
|}

== Ссылки ==
* [[Получение объекта по номеру]]
* [[Получение номера по объекту]]
* [http://rain.ifmo.ru/cat/view.php/vis/combinations/permutations-2000 Визуализатор перестановок]
* [http://cppalgo.blogspot.com/2011/02/episode-2.html Пример компактного кода для перестановок (С++)]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Комбинаторика]]

Получение следующего объекта

2014-01-04T23:00:40Z

91.122.22.64: /* Специализация алгоритма для генерации следующего разбиения на подмножества */

== Алгоритм ==
{{Определение|definition= '''Получение следующего объекта''' {{---}} это нахождение объекта, следующего за данным в [[Лексикографический порядок|лексикографическом порядке]].
}}
Объект <tex>Q</tex> называется следующим за <tex>P</tex>, если <tex>P < Q</tex> и не найдется такого <tex>R</tex>, что <tex>P < R < Q</tex>.

Отсюда понятен алгоритм:
* Находим суффикс минимальной длины, который можно изменить без изменения префикса текущего объекта <tex>P</tex>
* К оставшейся части дописываем минимальный возможный элемент (чтобы было выполнено правило <tex>P < Q</tex>)
* Дописываем минимальный возможный хвост
По построению получаем, что <tex>Q</tex> {{---}} минимально возможный.

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 битового вектора] ==
* Находим минимальный суффикс, в котором есть 0, его можно увеличить, не меняя оставшейся части
* Вместо 0 записываем 1
* Дописываем минимально возможный хвост из нулей
'''function''' nextVector(a:array[1..n] of byte):array[1..n] of byte; // n - длина вектора
'''for''' i = n '''downto''' 1
'''if''' a[i] == 0
a[i] = 1
'''for''' j = i + 1 to n
a[j] = 0
'''break'''
return(a);

=== Пример работы ===
{| class="wikitable" border = 1
|0||1||style="background:#FFCC00"|0||1||1||исходный битовый вектор
|-
| || ||^|| || ||находим элемент 0 (самый правый)
|-
|0||1||style="background:#FFCC00"|1||1||1||меняем его на 1
|-
|0||1||1||style="background:#FFCC00"|0||style="background:#FFCC00"|0||меняем элементы правее на нули
|-
|'''0'''||'''1'''||'''1'''||'''0'''||'''0'''||следующий битовый вектор
|}

== Специализация алгоритма для генерации [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 следующей перестановки] ==
* Двигаясь справа налево, находим элемент, нарушающий убывающую последовательность (в обычном порядке, слева направо, см. пример)
* Меняем его с минимальным элементом, большим нашего, стоящим правее
* Перевернем правую часть

'''function''' nextPermutation(a:array[1..n] of integer):array[1..n] of integer; // n - длина перестановки
'''for''' i = n - 1 '''downto''' 1
'''if''' a[i] < a[i + 1]
'''for''' j = i + 1 '''to''' n
'''if''' (a[j] < a[min]) and (a[j] > a[i])
min==j
swap(a[i], a[j])
reverse(a[i + 1]..a[n])
'''break'''
return(a);

=== Пример работы ===
{| class="wikitable" border = 1
|1||3||style="background:#FFCC00"|2||5||style="background:#FFCC00"|4||исходная перестановка
|-
| || ||^|| || ||находим элемент, нарушающий убывающую последовательность
|-
| || || || ||^||минимальный элемент больше нашего
|-
|1||3||style="background:#FFCC00"|4||5||style="background:#FFCC00"|2||меняем их местами
|-
|1||3||4||style="background:#FFCC00"|2||style="background:#FFCC00"|5||разворачивам правую часть
|-
|'''1'''||'''3'''||'''4'''||'''2'''||'''5'''||следующая перестановка
|}

== Специализация алгоритма для генерации следующей [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 мультиперестановки] ==
* Двигаясь справа налево, находим элемент, нарушающий убывающую последовательность (в обычном порядке, слева направо, см. пример).
* Меняем его с минимальным элементом, большим нашего, стоящим правее.
* Переворачиваем правую часть.
'''function''' nextMultiperm(var b:array[1..N] of integer): array[1..N] of integer;
'''var''' i , j : '''integer''';
'''begin'''
i := N - 1;
'''while''' (i > 0) '''and''' (b[i] >= b[i + 1]) '''do'''
dec(i);
'''if''' i > 0 '''then'''
'''begin'''
j := i + 1;
'''while''' (j < N) '''and''' (b[j + 1] > b[i]) '''do'''
inc(j);
swap(b[i] , b[j]);
'''for''' j := i + 1 '''to''' (N + i) '''div''' 2 '''do'''
swap(b[j], b[N - j + i + 1]);
return(b[1..N]);
'''end'''
'''else'''
'''begin'''
return(null);
'''end;'''
'''end;'''

=== Пример работы ===
{| class="wikitable" border = 1
|1||2||3||1||style="background:#FFCC00"|2||style="background:#FFCC00"|3||Исходная перестановка.
|-
| || || || ||^|| ||Находим элемент, нарушающий убывающую последовательность.
|-
| || || || || ||^||Минимальный элемент больше нашего.
|-
|1||2||3||1||style="background:#FFCC00"|3||style="background:#FFCC00"|2||Меняем их местами.
|-
|'''1'''||'''2'''||'''3'''||'''1'''||'''3'''||'''2'''||Следующая мультиперестановка.
|}

== Специализация алгоритма для генерации [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 следующего сочетания] ==

* Добавим в конец массива с сочетанием N+1 – максимальный элемент.
* Пойдём справа налево. Будем искать номер элемента, который отличается от предыдущего на 2.
* Увеличим найденный элемент на 1, и допишем в конец минимально возможный хвост, если такого элемента нет – на вход было дано последнее сочетание.
'''function''' nextChoose(var a:array[1..k] of integer): array[1..k] of integer; // n,k - параметры сочетания.
'''var'''
i,j : '''integer;'''
b:array[1..k+1] of '''integer;'''
'''begin'''
'''for''' i := 1 '''to''' k '''do'''
b[i]:=a[i];
b[k + 1] := n + 1;
i := n;
'''while''' (i > 0) '''and''' ((b[i + 1] - b[i]) < 2) '''do'''
i := i - 1;
'''if''' i > 0 '''then'''
'''begin'''
b[i] := b[i] + 1;
'''for''' j := i + 1 '''to''' k '''do'''
b[j] := b[j - 1] + 1;
'''for''' i := 1 '''to''' k '''do'''
a[i] := b[i];
return(a[1..k]);
'''end'''
'''else'''
return(null);
'''end;'''

=== Пример работы ===
{| class="wikitable" border = 1
|1||2||5||6||style="background:#FFCC00"|'''7'''||Дописываем 7 в конец сочетания.
|-
|1||style="background:#FFCC00"|2||5||6||'''7'''||
|-
| ||^|| || || ||Находим элемент i, a[i + 1] - a[ i ] >= 2
|-
|1||style="background:#FFCC00"|3||5||6||'''7'''||Увеличиваем его на 1.
|-
|1||3||style="background:#FFCC00"|4||style="background:#FFCC00"|5||style="background:#FFCC00"|'''6'''||Дописываем минимальный хвост.
|-
|'''1'''||'''3'''||'''4'''||'''5'''||''' '''||Следующее сочетание.
|}

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 разбиения на слагаемые] ==
Рассматриваемый алгоритм находит следующее разбиение на слагаемые, при этом разбиение упорядоченно по возрастанию.
* Увеличим предпоследнее слагаемое на 1, уменьшим последнее слагаемое на 1.
** Если предпоследнее слагаемое стало больше последнего, то увеличиваем предпоследнее слагаемое на величину последнего.
** Если предпоследнее слагаемое меньше последнего, то разбиваем последнее слагаемое <tex>s</tex> на два слагаемых <tex>a</tex> и <tex>b</tex> таких, что <tex>a</tex> равно предпоследнему слагаемому, а <tex>b = s - a</tex>. Повторяем этот процесс, пока разбиение остается корректным, то есть предпоследнее слагаемое хотя бы в два раза меньше последнего.

<code>
// b – список, содержащий разбиение данного числа, length – его размер.
'''function''' nextPartition(var b: list<int>): list<int>;
'''var''' i : '''integer;'''
'''begin'''
b[b.size] := b[b.size] - 1;
b[b.size - 1] := b[b.size - 1] + 1;
'''if''' b[b.size - 1] > b[b.size] '''then'''
'''begin'''
b[b.size - 1] := b[b.size - 1] + b[b.size];
b.pop();
'''end'''
'''else'''
'''begin'''
'''while''' b[b.size - 1] * 2 <= b[b.size] '''do'''
'''begin'''
b.add(b[b.size] - b[b.size - 1]);
b[b.size - 1] := b[b.size - 2];
'''end;'''
'''end;'''
'''return''' b;
'''end;'''
</code>

=== Пример работы ===
{| class="wikitable" border = 1
|1||style="background:#FFCC00"|1||style="background:#FFCC00"|7|| || ||Прибавим 1 + 1, вычтем 7 - 1.
|-
|1||style="background:#FFCC00"|2||style="background:#FFCC00"|6|| || ||Проверяем: 2<6, значит разбиваем 6 пока оно не станет <4
|-
|1||2||style="background:#FFCC00"|2||style="background:#FFCC00"|4|| ||
|-
|1||2||2||style="background:#FFCC00"|2||style="background:#FFCC00"|2||
|-
|'''1'''||'''2'''||'''2'''||'''2'''||'''2'''||Следующее разбиение на слагаемые числа 9.
|}

{| class="wikitable" border = 1
|1||style="background:#FFCC00"|4||style="background:#FFCC00"|5||Прибавим 4 + 1, вычтем 5 - 1.
|-
|1||style="background:#FFCC00"|5||style="background:#FFCC00"|4||Проверяем: 5>4, значит прибавим к 5 + 4.
|-
|1||9||style="background:#FFCC00"|4||Удалим последний элемент.
|-
|'''1'''||'''9'''||||Следующее разбиение на слагаемые числа 10.
|}

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 разбиения на подмножества] ==

Рассмотрим множество первых n натуральных чисел:<tex>N_n = \{1, 2, ..., n\}</tex>

Упорядочим все разбиения на множества <tex>N_n</tex> лексикографически. Для этого, во-первых, в каждом разбиении упорядочим множества лексикографически. Будем говорить, что подмножество <tex> A \subset N_n </tex> лексикографически меньше подмножества <tex> B \subset N_n </tex> , если верно одно из следующих условий:

*существует <tex>i</tex> такое, что <tex>i \in A</tex> , <tex>i \notin B</tex>, для всех <tex>j < i: j \in A</tex> если и только если <tex>j \in B</tex> , и существует <tex>k > i</tex> такое что <tex>k \in B</tex>;
* <tex> A \subset B </tex> и <tex>i < j</tex> для всех <tex>i \in A</tex> и <tex>j \in B</tex> \ <tex> A </tex>.

Разбиения упорядочены лексикографически следующим образом. Разбиение <tex>N_n = A_1 \cup A_2 \cup . . . \cup A_k</tex> лексикографически меньше разбиения <tex>N_n = B_1 \cup B_2 \cup . . . \cup B_l</tex> если существует такое <tex>i</tex>, что <tex>A_1 = B_1, A_2 = B_2, . . . ,A_{i - 1} = B_{i - 1}, A_i < B_i</tex>.

'''Рассмотрим алгоритм нахождения лексикографически следующего разбиения на подмножества:'''
*Будем хранить подмножества в списке списков, например, разбиение <tex> \{1, 2, 3\}~ \{4, 5\}</tex> будет выглядеть так:

{| class="wikitable" border = 1
|1||2||3
|-
|4||5||
|}

* Двигаясь снизу вверх и справа налево, будем удалять элементы, записывая их в отдельный массив. Будем повторять эту операцию, пока не сможем выполнить одно из действий, описанных ниже:
** Заменить рассматриваемый элемент уже удаленным. Из всех подходящих элементов выбираем минимальный. '''Важное замечание''': мы не можем заменить 1ый элемент подмножества, мы можем только удалить его.
** Дополнить рассматриваемое подмножество уже удаленным элементом. Из всех подходящих элементов выбираем минимальный.
* Допишем лексикографически минимальный хвост подмножеств из оставшихся элементов.

<code>
'''function''' nextSetPartition(a:list<list<int>>):list<list<int>>;
// a - список, содержащий подмножества
// used - список, в котором мы храним удаленные элементы
used = list<int>();
fl = ''false''
'''for''' i = a.size '''downto''' 1
'''if''' (used.size <> 0) and (used[used.size] > a[i][a[i].size]) '''then''' //если можем добавить в конец подмножества элемент из used
a[i].add(used[used.size]); //добавляем
used.remove(used.size);
'''break'''
'''for''' j = a[i].size '''downto''' 1
'''if''' (used.size <> 0) and (j <> 1) and (used[used.size] > a[i][j]) '''then''' //если можем заменить элемент, другим элементом из списка used
a[i][j] = used[used.size]; //заменяем
fl = ''true''
'''break'''
used.add(a[i][j]); // добавляем в used j элемент i-го подмножества
a[i].remove(j); // удаляем j элемент i-го подмножества
'''if''' (fl) '''break'''
// далее выведем все получившиеся подмножества
sort(used)
'''for''' i = 1 '''to''' used.size
a.add(list<int>(used[i])); // добавляем лексикографически минимальных хвост
return(a);
</code>

=== Пример работы ===

'''Рассмотрим следующее разбиение:'''

{| class="wikitable" border = 1
|1||2||3
|-
|4||5||
|}

'''1 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||
|-
|4||style="background:#FFCC00"|5||||
|-
| ||^|| ||Удалили элемент 5.
|-
| || || ||used
|}

'''2 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||
|-
|style="background:#FFCC00"|4|| ||||
|-
|^|| || ||Удалили элемент 4. Так как он является первым в подмножестве, то мы не можем заменить его на другой.
|-
|5|| || ||used
|}

'''3 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||style="background:#FFCC00"|4||
|-
| || || ||^||Дополнили первое подмножество элементом 4
|-
|5|| || || ||used
|}

'''4 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||4||
|-
|style="background:#FFCC00"|5|| || || ||Дописали лексикографически минимальный хвост
|-
| || || || ||used
|}

== Ссылки ==
* [[Получение объекта по номеру]]
* [[Получение номера по объекту]]
* [http://rain.ifmo.ru/cat/view.php/vis/combinations/permutations-2000 Визуализатор перестановок]
* [http://cppalgo.blogspot.com/2011/02/episode-2.html Пример компактного кода для перестановок (С++)]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Комбинаторика]]

Получение следующего объекта

2014-01-04T22:49:42Z

91.122.22.64: /* Специализация алгоритма для генерации следующего разбиения на подмножества */

== Алгоритм ==
{{Определение|definition= '''Получение следующего объекта''' {{---}} это нахождение объекта, следующего за данным в [[Лексикографический порядок|лексикографическом порядке]].
}}
Объект <tex>Q</tex> называется следующим за <tex>P</tex>, если <tex>P < Q</tex> и не найдется такого <tex>R</tex>, что <tex>P < R < Q</tex>.

Отсюда понятен алгоритм:
* Находим суффикс минимальной длины, который можно изменить без изменения префикса текущего объекта <tex>P</tex>
* К оставшейся части дописываем минимальный возможный элемент (чтобы было выполнено правило <tex>P < Q</tex>)
* Дописываем минимальный возможный хвост
По построению получаем, что <tex>Q</tex> {{---}} минимально возможный.

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 битового вектора] ==
* Находим минимальный суффикс, в котором есть 0, его можно увеличить, не меняя оставшейся части
* Вместо 0 записываем 1
* Дописываем минимально возможный хвост из нулей
'''function''' nextVector(a:array[1..n] of byte):array[1..n] of byte; // n - длина вектора
'''for''' i = n '''downto''' 1
'''if''' a[i] == 0
a[i] = 1
'''for''' j = i + 1 to n
a[j] = 0
'''break'''
return(a);

=== Пример работы ===
{| class="wikitable" border = 1
|0||1||style="background:#FFCC00"|0||1||1||исходный битовый вектор
|-
| || ||^|| || ||находим элемент 0 (самый правый)
|-
|0||1||style="background:#FFCC00"|1||1||1||меняем его на 1
|-
|0||1||1||style="background:#FFCC00"|0||style="background:#FFCC00"|0||меняем элементы правее на нули
|-
|'''0'''||'''1'''||'''1'''||'''0'''||'''0'''||следующий битовый вектор
|}

== Специализация алгоритма для генерации [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 следующей перестановки] ==
* Двигаясь справа налево, находим элемент, нарушающий убывающую последовательность (в обычном порядке, слева направо, см. пример)
* Меняем его с минимальным элементом, большим нашего, стоящим правее
* Перевернем правую часть

'''function''' nextPermutation(a:array[1..n] of integer):array[1..n] of integer; // n - длина перестановки
'''for''' i = n - 1 '''downto''' 1
'''if''' a[i] < a[i + 1]
'''for''' j = i + 1 '''to''' n
'''if''' (a[j] < a[min]) and (a[j] > a[i])
min==j
swap(a[i], a[j])
reverse(a[i + 1]..a[n])
'''break'''
return(a);

=== Пример работы ===
{| class="wikitable" border = 1
|1||3||style="background:#FFCC00"|2||5||style="background:#FFCC00"|4||исходная перестановка
|-
| || ||^|| || ||находим элемент, нарушающий убывающую последовательность
|-
| || || || ||^||минимальный элемент больше нашего
|-
|1||3||style="background:#FFCC00"|4||5||style="background:#FFCC00"|2||меняем их местами
|-
|1||3||4||style="background:#FFCC00"|2||style="background:#FFCC00"|5||разворачивам правую часть
|-
|'''1'''||'''3'''||'''4'''||'''2'''||'''5'''||следующая перестановка
|}

== Специализация алгоритма для генерации следующей [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 мультиперестановки] ==
* Двигаясь справа налево, находим элемент, нарушающий убывающую последовательность (в обычном порядке, слева направо, см. пример).
* Меняем его с минимальным элементом, большим нашего, стоящим правее.
* Переворачиваем правую часть.
'''function''' nextMultiperm(var b:array[1..N] of integer): array[1..N] of integer;
'''var''' i , j : '''integer''';
'''begin'''
i := N - 1;
'''while''' (i > 0) '''and''' (b[i] >= b[i + 1]) '''do'''
dec(i);
'''if''' i > 0 '''then'''
'''begin'''
j := i + 1;
'''while''' (j < N) '''and''' (b[j + 1] > b[i]) '''do'''
inc(j);
swap(b[i] , b[j]);
'''for''' j := i + 1 '''to''' (N + i) '''div''' 2 '''do'''
swap(b[j], b[N - j + i + 1]);
return(b[1..N]);
'''end'''
'''else'''
'''begin'''
return(null);
'''end;'''
'''end;'''

=== Пример работы ===
{| class="wikitable" border = 1
|1||2||3||1||style="background:#FFCC00"|2||style="background:#FFCC00"|3||Исходная перестановка.
|-
| || || || ||^|| ||Находим элемент, нарушающий убывающую последовательность.
|-
| || || || || ||^||Минимальный элемент больше нашего.
|-
|1||2||3||1||style="background:#FFCC00"|3||style="background:#FFCC00"|2||Меняем их местами.
|-
|'''1'''||'''2'''||'''3'''||'''1'''||'''3'''||'''2'''||Следующая мультиперестановка.
|}

== Специализация алгоритма для генерации [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 следующего сочетания] ==

* Добавим в конец массива с сочетанием N+1 – максимальный элемент.
* Пойдём справа налево. Будем искать номер элемента, который отличается от предыдущего на 2.
* Увеличим найденный элемент на 1, и допишем в конец минимально возможный хвост, если такого элемента нет – на вход было дано последнее сочетание.
'''function''' nextChoose(var a:array[1..k] of integer): array[1..k] of integer; // n,k - параметры сочетания.
'''var'''
i,j : '''integer;'''
b:array[1..k+1] of '''integer;'''
'''begin'''
'''for''' i := 1 '''to''' k '''do'''
b[i]:=a[i];
b[k + 1] := n + 1;
i := n;
'''while''' (i > 0) '''and''' ((b[i + 1] - b[i]) < 2) '''do'''
i := i - 1;
'''if''' i > 0 '''then'''
'''begin'''
b[i] := b[i] + 1;
'''for''' j := i + 1 '''to''' k '''do'''
b[j] := b[j - 1] + 1;
'''for''' i := 1 '''to''' k '''do'''
a[i] := b[i];
return(a[1..k]);
'''end'''
'''else'''
return(null);
'''end;'''

=== Пример работы ===
{| class="wikitable" border = 1
|1||2||5||6||style="background:#FFCC00"|'''7'''||Дописываем 7 в конец сочетания.
|-
|1||style="background:#FFCC00"|2||5||6||'''7'''||
|-
| ||^|| || || ||Находим элемент i, a[i + 1] - a[ i ] >= 2
|-
|1||style="background:#FFCC00"|3||5||6||'''7'''||Увеличиваем его на 1.
|-
|1||3||style="background:#FFCC00"|4||style="background:#FFCC00"|5||style="background:#FFCC00"|'''6'''||Дописываем минимальный хвост.
|-
|'''1'''||'''3'''||'''4'''||'''5'''||''' '''||Следующее сочетание.
|}

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 разбиения на слагаемые] ==
Рассматриваемый алгоритм находит следующее разбиение на слагаемые, при этом разбиение упорядоченно по возрастанию.
* Увеличим предпоследнее слагаемое на 1, уменьшим последнее слагаемое на 1.
** Если предпоследнее слагаемое стало больше последнего, то увеличиваем предпоследнее слагаемое на величину последнего.
** Если предпоследнее слагаемое меньше последнего, то разбиваем последнее слагаемое <tex>s</tex> на два слагаемых <tex>a</tex> и <tex>b</tex> таких, что <tex>a</tex> равно предпоследнему слагаемому, а <tex>b = s - a</tex>. Повторяем этот процесс, пока разбиение остается корректным, то есть предпоследнее слагаемое хотя бы в два раза меньше последнего.

<code>
// b – список, содержащий разбиение данного числа, length – его размер.
'''function''' nextPartition(var b: list<int>): list<int>;
'''var''' i : '''integer;'''
'''begin'''
b[b.size] := b[b.size] - 1;
b[b.size - 1] := b[b.size - 1] + 1;
'''if''' b[b.size - 1] > b[b.size] '''then'''
'''begin'''
b[b.size - 1] := b[b.size - 1] + b[b.size];
b.pop();
'''end'''
'''else'''
'''begin'''
'''while''' b[b.size - 1] * 2 <= b[b.size] '''do'''
'''begin'''
b.add(b[b.size] - b[b.size - 1]);
b[b.size - 1] := b[b.size - 2];
'''end;'''
'''end;'''
'''return''' b;
'''end;'''
</code>

=== Пример работы ===
{| class="wikitable" border = 1
|1||style="background:#FFCC00"|1||style="background:#FFCC00"|7|| || ||Прибавим 1 + 1, вычтем 7 - 1.
|-
|1||style="background:#FFCC00"|2||style="background:#FFCC00"|6|| || ||Проверяем: 2<6, значит разбиваем 6 пока оно не станет <4
|-
|1||2||style="background:#FFCC00"|2||style="background:#FFCC00"|4|| ||
|-
|1||2||2||style="background:#FFCC00"|2||style="background:#FFCC00"|2||
|-
|'''1'''||'''2'''||'''2'''||'''2'''||'''2'''||Следующее разбиение на слагаемые числа 9.
|}

{| class="wikitable" border = 1
|1||style="background:#FFCC00"|4||style="background:#FFCC00"|5||Прибавим 4 + 1, вычтем 5 - 1.
|-
|1||style="background:#FFCC00"|5||style="background:#FFCC00"|4||Проверяем: 5>4, значит прибавим к 5 + 4.
|-
|1||9||style="background:#FFCC00"|4||Удалим последний элемент.
|-
|'''1'''||'''9'''||||Следующее разбиение на слагаемые числа 10.
|}

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 разбиения на подмножества] ==

Рассмотрим множество первых n натуральных чисел:<tex>N_n = \{1, 2, ..., n\}</tex>

Упорядочим все разбиения на множества <tex>N_n</tex> лексикографически. Для этого, во-первых, в каждом разбиении упорядочим множества лексикографически. Будем говорить, что подмножество <tex> A \subset N_n </tex> лексикографически меньше подмножества <tex> B \subset N_n </tex> , если верно одно из следующих условий:

*существует <tex>i</tex> такое, что <tex>i \in A</tex> , <tex>i \notin B</tex>, для всех <tex>j < i: j \in A</tex> если и только если <tex>j \in B</tex> , и существует <tex>k > i</tex> такое что <tex>k \in B</tex>;
* <tex> A \subset B </tex> и <tex>i < j</tex> для всех <tex>i \in A</tex> и <tex>j \in B</tex> \ <tex> A </tex>.

Разбиения упорядочены лексикографически следующим образом. Разбиение <tex>N_n = A_1 \cup A_2 \cup . . . \cup A_k</tex> лексикографически меньше разбиения <tex>N_n = B_1 \cup B_2 \cup . . . \cup B_l</tex> если существует такое <tex>i</tex>, что <tex>A_1 = B_1, A_2 = B_2, . . . ,A_{i - 1} = B_{i - 1}, A_i < B_i</tex>.

'''Рассмотрим алгоритм нахождения лексикографически следующего разбиения на подмножества:'''
*Будем хранить подмножества в списке списков, например, разбиение <tex> \{1, 2, 3\}~ \{4, 5\}</tex> будет выглядеть так:

{| class="wikitable" border = 1
|1||2||3
|-
|4||5||
|}

* Двигаясь снизу вверх и справа налево, будем удалять элементы, записывая их в отдельный массив. Будем повторять эту операцию, пока не сможем выполнить одно из действий, описанных ниже:
** Заменить рассматриваемый элемент уже удаленным. Из всех подходящих элементов выбираем минимальный. '''Важное замечание''': мы не можем заменить 1ый элемент подмножества, мы можем только удалить его.
** Дополнить рассматриваемое подмножество уже удаленным элементом. Из всех подходящих элементов выбираем минимальный.
* Допишем лексикографически минимальный хвост подмножеств из оставшихся элементов.

<code>
'''function''' nextSetPartition(a:list<list<int>>):list<list<int>>;
// a - список, содержащий подмножества
// used - список, в котором мы храним удаленные элементы
used = list<int>();
fl = ''false''
'''for''' i = a.size '''downto''' 1
'''if''' (used.size <> 0) and (used[used.size] > a[i][a[i].size]) '''then''' //если можем добавить в конец подмножества элемент из used
a[i].add(used[used.size]); //добавляем
'''break'''
'''for''' j = a[i].size '''downto''' 1
'''if''' (used.size <> 0) and (j <> 1) and (used[used.size] > a[i][j]) '''then''' //если можем заменить элемент, другим элементом из списка used
a[i][j] = used[used.size]; //заменяем
fl = ''true''
'''break'''
used.add(a[i][j]);
a[i].pop(j); // удаляем j элемент i-го подмножества и добавляем его в список
'''if''' (fl) '''break'''
// далее выведем все получившиеся подмножества
sort(used)
'''for''' i = 1 '''to''' used.size
a.add(list<int>(used[i])); // добавляем лексикографически минимальных хвост
return(a);
</code>

=== Пример работы ===

'''Рассмотрим следующее разбиение:'''

{| class="wikitable" border = 1
|1||2||3
|-
|4||5||
|}

'''1 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||
|-
|4||style="background:#FFCC00"|5||||
|-
| ||^|| ||Удалили элемент 5.
|-
| || || ||used
|}

'''2 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||
|-
|style="background:#FFCC00"|4|| ||||
|-
|^|| || ||Удалили элемент 4. Так как он является первым в подмножестве, то мы не можем заменить его на другой.
|-
|5|| || ||used
|}

'''3 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||style="background:#FFCC00"|4||
|-
| || || ||^||Дополнили первое подмножество элементом 4
|-
|5|| || || ||used
|}

'''4 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||4||
|-
|style="background:#FFCC00"|5|| || || ||Дописали лексикографически минимальный хвост
|-
| || || || ||used
|}

== Ссылки ==
* [[Получение объекта по номеру]]
* [[Получение номера по объекту]]
* [http://rain.ifmo.ru/cat/view.php/vis/combinations/permutations-2000 Визуализатор перестановок]
* [http://cppalgo.blogspot.com/2011/02/episode-2.html Пример компактного кода для перестановок (С++)]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Комбинаторика]]

Получение следующего объекта

2014-01-04T22:34:40Z

91.122.22.64: /* Специализация алгоритма для генерации следующего разбиения на подмножества */

== Алгоритм ==
{{Определение|definition= '''Получение следующего объекта''' {{---}} это нахождение объекта, следующего за данным в [[Лексикографический порядок|лексикографическом порядке]].
}}
Объект <tex>Q</tex> называется следующим за <tex>P</tex>, если <tex>P < Q</tex> и не найдется такого <tex>R</tex>, что <tex>P < R < Q</tex>.

Отсюда понятен алгоритм:
* Находим суффикс минимальной длины, который можно изменить без изменения префикса текущего объекта <tex>P</tex>
* К оставшейся части дописываем минимальный возможный элемент (чтобы было выполнено правило <tex>P < Q</tex>)
* Дописываем минимальный возможный хвост
По построению получаем, что <tex>Q</tex> {{---}} минимально возможный.

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 битового вектора] ==
* Находим минимальный суффикс, в котором есть 0, его можно увеличить, не меняя оставшейся части
* Вместо 0 записываем 1
* Дописываем минимально возможный хвост из нулей
'''function''' nextVector(a:array[1..n] of byte):array[1..n] of byte; // n - длина вектора
'''for''' i = n '''downto''' 1
'''if''' a[i] == 0
a[i] = 1
'''for''' j = i + 1 to n
a[j] = 0
'''break'''
return(a);

=== Пример работы ===
{| class="wikitable" border = 1
|0||1||style="background:#FFCC00"|0||1||1||исходный битовый вектор
|-
| || ||^|| || ||находим элемент 0 (самый правый)
|-
|0||1||style="background:#FFCC00"|1||1||1||меняем его на 1
|-
|0||1||1||style="background:#FFCC00"|0||style="background:#FFCC00"|0||меняем элементы правее на нули
|-
|'''0'''||'''1'''||'''1'''||'''0'''||'''0'''||следующий битовый вектор
|}

== Специализация алгоритма для генерации [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 следующей перестановки] ==
* Двигаясь справа налево, находим элемент, нарушающий убывающую последовательность (в обычном порядке, слева направо, см. пример)
* Меняем его с минимальным элементом, большим нашего, стоящим правее
* Перевернем правую часть

'''function''' nextPermutation(a:array[1..n] of integer):array[1..n] of integer; // n - длина перестановки
'''for''' i = n - 1 '''downto''' 1
'''if''' a[i] < a[i + 1]
'''for''' j = i + 1 '''to''' n
'''if''' (a[j] < a[min]) and (a[j] > a[i])
min==j
swap(a[i], a[j])
reverse(a[i + 1]..a[n])
'''break'''
return(a);

=== Пример работы ===
{| class="wikitable" border = 1
|1||3||style="background:#FFCC00"|2||5||style="background:#FFCC00"|4||исходная перестановка
|-
| || ||^|| || ||находим элемент, нарушающий убывающую последовательность
|-
| || || || ||^||минимальный элемент больше нашего
|-
|1||3||style="background:#FFCC00"|4||5||style="background:#FFCC00"|2||меняем их местами
|-
|1||3||4||style="background:#FFCC00"|2||style="background:#FFCC00"|5||разворачивам правую часть
|-
|'''1'''||'''3'''||'''4'''||'''2'''||'''5'''||следующая перестановка
|}

== Специализация алгоритма для генерации следующей [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 мультиперестановки] ==
* Двигаясь справа налево, находим элемент, нарушающий убывающую последовательность (в обычном порядке, слева направо, см. пример).
* Меняем его с минимальным элементом, большим нашего, стоящим правее.
* Переворачиваем правую часть.
'''function''' nextMultiperm(var b:array[1..N] of integer): array[1..N] of integer;
'''var''' i , j : '''integer''';
'''begin'''
i := N - 1;
'''while''' (i > 0) '''and''' (b[i] >= b[i + 1]) '''do'''
dec(i);
'''if''' i > 0 '''then'''
'''begin'''
j := i + 1;
'''while''' (j < N) '''and''' (b[j + 1] > b[i]) '''do'''
inc(j);
swap(b[i] , b[j]);
'''for''' j := i + 1 '''to''' (N + i) '''div''' 2 '''do'''
swap(b[j], b[N - j + i + 1]);
return(b[1..N]);
'''end'''
'''else'''
'''begin'''
return(null);
'''end;'''
'''end;'''

=== Пример работы ===
{| class="wikitable" border = 1
|1||2||3||1||style="background:#FFCC00"|2||style="background:#FFCC00"|3||Исходная перестановка.
|-
| || || || ||^|| ||Находим элемент, нарушающий убывающую последовательность.
|-
| || || || || ||^||Минимальный элемент больше нашего.
|-
|1||2||3||1||style="background:#FFCC00"|3||style="background:#FFCC00"|2||Меняем их местами.
|-
|'''1'''||'''2'''||'''3'''||'''1'''||'''3'''||'''2'''||Следующая мультиперестановка.
|}

== Специализация алгоритма для генерации [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 следующего сочетания] ==

* Добавим в конец массива с сочетанием N+1 – максимальный элемент.
* Пойдём справа налево. Будем искать номер элемента, который отличается от предыдущего на 2.
* Увеличим найденный элемент на 1, и допишем в конец минимально возможный хвост, если такого элемента нет – на вход было дано последнее сочетание.
'''function''' nextChoose(var a:array[1..k] of integer): array[1..k] of integer; // n,k - параметры сочетания.
'''var'''
i,j : '''integer;'''
b:array[1..k+1] of '''integer;'''
'''begin'''
'''for''' i := 1 '''to''' k '''do'''
b[i]:=a[i];
b[k + 1] := n + 1;
i := n;
'''while''' (i > 0) '''and''' ((b[i + 1] - b[i]) < 2) '''do'''
i := i - 1;
'''if''' i > 0 '''then'''
'''begin'''
b[i] := b[i] + 1;
'''for''' j := i + 1 '''to''' k '''do'''
b[j] := b[j - 1] + 1;
'''for''' i := 1 '''to''' k '''do'''
a[i] := b[i];
return(a[1..k]);
'''end'''
'''else'''
return(null);
'''end;'''

=== Пример работы ===
{| class="wikitable" border = 1
|1||2||5||6||style="background:#FFCC00"|'''7'''||Дописываем 7 в конец сочетания.
|-
|1||style="background:#FFCC00"|2||5||6||'''7'''||
|-
| ||^|| || || ||Находим элемент i, a[i + 1] - a[ i ] >= 2
|-
|1||style="background:#FFCC00"|3||5||6||'''7'''||Увеличиваем его на 1.
|-
|1||3||style="background:#FFCC00"|4||style="background:#FFCC00"|5||style="background:#FFCC00"|'''6'''||Дописываем минимальный хвост.
|-
|'''1'''||'''3'''||'''4'''||'''5'''||''' '''||Следующее сочетание.
|}

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 разбиения на слагаемые] ==
Рассматриваемый алгоритм находит следующее разбиение на слагаемые, при этом разбиение упорядоченно по возрастанию.
* Увеличим предпоследнее слагаемое на 1, уменьшим последнее слагаемое на 1.
** Если предпоследнее слагаемое стало больше последнего, то увеличиваем предпоследнее слагаемое на величину последнего.
** Если предпоследнее слагаемое меньше последнего, то разбиваем последнее слагаемое <tex>s</tex> на два слагаемых <tex>a</tex> и <tex>b</tex> таких, что <tex>a</tex> равно предпоследнему слагаемому, а <tex>b = s - a</tex>. Повторяем этот процесс, пока разбиение остается корректным, то есть предпоследнее слагаемое хотя бы в два раза меньше последнего.

<code>
// b – список, содержащий разбиение данного числа, length – его размер.
'''function''' nextPartition(var b: list<int>): list<int>;
'''var''' i : '''integer;'''
'''begin'''
b[b.size] := b[b.size] - 1;
b[b.size - 1] := b[b.size - 1] + 1;
'''if''' b[b.size - 1] > b[b.size] '''then'''
'''begin'''
b[b.size - 1] := b[b.size - 1] + b[b.size];
b.pop();
'''end'''
'''else'''
'''begin'''
'''while''' b[b.size - 1] * 2 <= b[b.size] '''do'''
'''begin'''
b.add(b[b.size] - b[b.size - 1]);
b[b.size - 1] := b[b.size - 2];
'''end;'''
'''end;'''
'''return''' b;
'''end;'''
</code>

=== Пример работы ===
{| class="wikitable" border = 1
|1||style="background:#FFCC00"|1||style="background:#FFCC00"|7|| || ||Прибавим 1 + 1, вычтем 7 - 1.
|-
|1||style="background:#FFCC00"|2||style="background:#FFCC00"|6|| || ||Проверяем: 2<6, значит разбиваем 6 пока оно не станет <4
|-
|1||2||style="background:#FFCC00"|2||style="background:#FFCC00"|4|| ||
|-
|1||2||2||style="background:#FFCC00"|2||style="background:#FFCC00"|2||
|-
|'''1'''||'''2'''||'''2'''||'''2'''||'''2'''||Следующее разбиение на слагаемые числа 9.
|}

{| class="wikitable" border = 1
|1||style="background:#FFCC00"|4||style="background:#FFCC00"|5||Прибавим 4 + 1, вычтем 5 - 1.
|-
|1||style="background:#FFCC00"|5||style="background:#FFCC00"|4||Проверяем: 5>4, значит прибавим к 5 + 4.
|-
|1||9||style="background:#FFCC00"|4||Удалим последний элемент.
|-
|'''1'''||'''9'''||||Следующее разбиение на слагаемые числа 10.
|}

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 разбиения на подмножества] ==

Рассмотрим множество первых n натуральных чисел:<tex>N_n = \{1, 2, ..., n\}</tex>

Упорядочим все разбиения на множества <tex>N_n</tex> лексикографически. Для этого, во-первых, в каждом разбиении упорядочим множества лексикографически. Будем говорить, что подмножество <tex> A \subset N_n </tex> лексикографически меньше подмножества <tex> B \subset N_n </tex> , если верно одно из следующих условий:

*существует <tex>i</tex> такое, что <tex>i \in A</tex> , <tex>i \notin B</tex>, для всех <tex>j < i: j \in A</tex> если и только если <tex>j \in B</tex> , и существует <tex>k > i</tex> такое что <tex>k \in B</tex>;
* <tex> A \subset B </tex> и <tex>i < j</tex> для всех <tex>i \in A</tex> и <tex>j \in B</tex> \ <tex> A </tex>.

Разбиения упорядочены лексикографически следующим образом. Разбиение <tex>N_n = A_1 \cup A_2 \cup . . . \cup A_k</tex> лексикографически меньше разбиения <tex>N_n = B_1 \cup B_2 \cup . . . \cup B_l</tex> если существует такое <tex>i</tex>, что <tex>A_1 = B_1, A_2 = B_2, . . . ,A_{i - 1} = B_{i - 1}, A_i < B_i</tex>.

'''Рассмотрим алгоритм нахождения лексикографически следующего разбиения на подмножества:'''
*Будем хранить подмножества в списке списков, например, разбиение <tex> \{1, 2, 3\}~ \{4, 5\}</tex> будет выглядеть так:

{| class="wikitable" border = 1
|1||2||3
|-
|4||5||
|}

* Двигаясь снизу вверх и справа налево, будем удалять элементы, записывая их в отдельный массив. Будем повторять эту операцию, пока не сможем выполнить одно из действий, описанных ниже:
** Заменить рассматриваемый элемент уже удаленным. Из всех подходящих элементов выбираем минимальный. '''Важное замечание''': мы не можем заменить 1ый элемент подмножества, мы можем только удалить его.
** Дополнить рассматриваемое подмножество уже удаленным элементом. Из всех подходящих элементов выбираем минимальный.
* Допишем лексикографически минимальный хвост подмножеств из оставшихся элементов.

<code>
'''function''' nextSetPartition(a:list<list<int>>):list<list<int>>;
// a - список, содержащий подмножества
// used - список, в котором мы храним удаленные элементы
used = list<int>();
fl = ''false''
'''for''' i = a.size '''downto''' 1
'''if''' used[used.size] > a[i][a[i].size] '''then''' //если можем добавить в конец подмножества элемент из used
a[i].add(used[used.size]); //добавляем
'''break'''
'''for''' j = a[i].size '''downto''' 1
'''if''' (j <> 1) and used[used.size] > a[i][j] '''then''' //если можем заменить элемент, другим элементом из списка used
a[i][j] = used[used.size]; //заменяем
fl = ''true''
'''break'''
used.add(a[i][j]);
a[i].pop(j); // удаляем j элемент i подмножества и добавляем его в список
'''if''' (fl) '''break'''
// далее выведем все получившиеся подмножества
sort(used)
'''for''' i = 1 '''to''' used.size
a.add(used[i]); // добавляем лексикографически минимальных хвост
return(a);
</code>

=== Пример работы ===

'''Рассмотрим следующее разбиение:'''

{| class="wikitable" border = 1
|1||2||3
|-
|4||5||
|}

'''1 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||
|-
|4||style="background:#FFCC00"|5||||
|-
| ||^|| ||Удалили элемент 5.
|-
| || || ||used
|}

'''2 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||
|-
|style="background:#FFCC00"|4|| ||||
|-
|^|| || ||Удалили элемент 4. Так как он является первым в подмножестве, то мы не можем заменить его на другой.
|-
|5|| || ||used
|}

'''3 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||style="background:#FFCC00"|4||
|-
| || || ||^||Дополнили первое подмножество элементом 4
|-
|5|| || || ||used
|}

'''4 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||4||
|-
|style="background:#FFCC00"|5|| || || ||Дописали лексикографически минимальный хвост
|-
| || || || ||used
|}

== Ссылки ==
* [[Получение объекта по номеру]]
* [[Получение номера по объекту]]
* [http://rain.ifmo.ru/cat/view.php/vis/combinations/permutations-2000 Визуализатор перестановок]
* [http://cppalgo.blogspot.com/2011/02/episode-2.html Пример компактного кода для перестановок (С++)]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Комбинаторика]]

Получение следующего объекта

2014-01-04T21:52:45Z

91.122.22.64: /* Специализация алгоритма для генерации следующего разбиения на подмножества */

== Алгоритм ==
{{Определение|definition= '''Получение следующего объекта''' {{---}} это нахождение объекта, следующего за данным в [[Лексикографический порядок|лексикографическом порядке]].
}}
Объект <tex>Q</tex> называется следующим за <tex>P</tex>, если <tex>P < Q</tex> и не найдется такого <tex>R</tex>, что <tex>P < R < Q</tex>.

Отсюда понятен алгоритм:
* Находим суффикс минимальной длины, который можно изменить без изменения префикса текущего объекта <tex>P</tex>
* К оставшейся части дописываем минимальный возможный элемент (чтобы было выполнено правило <tex>P < Q</tex>)
* Дописываем минимальный возможный хвост
По построению получаем, что <tex>Q</tex> {{---}} минимально возможный.

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 битового вектора] ==
* Находим минимальный суффикс, в котором есть 0, его можно увеличить, не меняя оставшейся части
* Вместо 0 записываем 1
* Дописываем минимально возможный хвост из нулей
'''function''' nextVector(a:array[1..n] of byte):array[1..n] of byte; // n - длина вектора
'''for''' i = n '''downto''' 1
'''if''' a[i] == 0
a[i] = 1
'''for''' j = i + 1 to n
a[j] = 0
'''break'''
return(a);

=== Пример работы ===
{| class="wikitable" border = 1
|0||1||style="background:#FFCC00"|0||1||1||исходный битовый вектор
|-
| || ||^|| || ||находим элемент 0 (самый правый)
|-
|0||1||style="background:#FFCC00"|1||1||1||меняем его на 1
|-
|0||1||1||style="background:#FFCC00"|0||style="background:#FFCC00"|0||меняем элементы правее на нули
|-
|'''0'''||'''1'''||'''1'''||'''0'''||'''0'''||следующий битовый вектор
|}

== Специализация алгоритма для генерации [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 следующей перестановки] ==
* Двигаясь справа налево, находим элемент, нарушающий убывающую последовательность (в обычном порядке, слева направо, см. пример)
* Меняем его с минимальным элементом, большим нашего, стоящим правее
* Перевернем правую часть

'''function''' nextPermutation(a:array[1..n] of integer):array[1..n] of integer; // n - длина перестановки
'''for''' i = n - 1 '''downto''' 1
'''if''' a[i] < a[i + 1]
'''for''' j = i + 1 '''to''' n
'''if''' (a[j] < a[min]) and (a[j] > a[i])
min==j
swap(a[i], a[j])
reverse(a[i + 1]..a[n])
'''break'''
return(a);

=== Пример работы ===
{| class="wikitable" border = 1
|1||3||style="background:#FFCC00"|2||5||style="background:#FFCC00"|4||исходная перестановка
|-
| || ||^|| || ||находим элемент, нарушающий убывающую последовательность
|-
| || || || ||^||минимальный элемент больше нашего
|-
|1||3||style="background:#FFCC00"|4||5||style="background:#FFCC00"|2||меняем их местами
|-
|1||3||4||style="background:#FFCC00"|2||style="background:#FFCC00"|5||разворачивам правую часть
|-
|'''1'''||'''3'''||'''4'''||'''2'''||'''5'''||следующая перестановка
|}

== Специализация алгоритма для генерации следующей [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 мультиперестановки] ==
* Двигаясь справа налево, находим элемент, нарушающий убывающую последовательность (в обычном порядке, слева направо, см. пример).
* Меняем его с минимальным элементом, большим нашего, стоящим правее.
* Переворачиваем правую часть.
'''function''' nextMultiperm(var b:array[1..N] of integer): array[1..N] of integer;
'''var''' i , j : '''integer''';
'''begin'''
i := N - 1;
'''while''' (i > 0) '''and''' (b[i] >= b[i + 1]) '''do'''
dec(i);
'''if''' i > 0 '''then'''
'''begin'''
j := i + 1;
'''while''' (j < N) '''and''' (b[j + 1] > b[i]) '''do'''
inc(j);
swap(b[i] , b[j]);
'''for''' j := i + 1 '''to''' (N + i) '''div''' 2 '''do'''
swap(b[j], b[N - j + i + 1]);
return(b[1..N]);
'''end'''
'''else'''
'''begin'''
return(null);
'''end;'''
'''end;'''

=== Пример работы ===
{| class="wikitable" border = 1
|1||2||3||1||style="background:#FFCC00"|2||style="background:#FFCC00"|3||Исходная перестановка.
|-
| || || || ||^|| ||Находим элемент, нарушающий убывающую последовательность.
|-
| || || || || ||^||Минимальный элемент больше нашего.
|-
|1||2||3||1||style="background:#FFCC00"|3||style="background:#FFCC00"|2||Меняем их местами.
|-
|'''1'''||'''2'''||'''3'''||'''1'''||'''3'''||'''2'''||Следующая мультиперестановка.
|}

== Специализация алгоритма для генерации [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 следующего сочетания] ==

* Добавим в конец массива с сочетанием N+1 – максимальный элемент.
* Пойдём справа налево. Будем искать номер элемента, который отличается от предыдущего на 2.
* Увеличим найденный элемент на 1, и допишем в конец минимально возможный хвост, если такого элемента нет – на вход было дано последнее сочетание.
'''function''' nextChoose(var a:array[1..k] of integer): array[1..k] of integer; // n,k - параметры сочетания.
'''var'''
i,j : '''integer;'''
b:array[1..k+1] of '''integer;'''
'''begin'''
'''for''' i := 1 '''to''' k '''do'''
b[i]:=a[i];
b[k + 1] := n + 1;
i := n;
'''while''' (i > 0) '''and''' ((b[i + 1] - b[i]) < 2) '''do'''
i := i - 1;
'''if''' i > 0 '''then'''
'''begin'''
b[i] := b[i] + 1;
'''for''' j := i + 1 '''to''' k '''do'''
b[j] := b[j - 1] + 1;
'''for''' i := 1 '''to''' k '''do'''
a[i] := b[i];
return(a[1..k]);
'''end'''
'''else'''
return(null);
'''end;'''

=== Пример работы ===
{| class="wikitable" border = 1
|1||2||5||6||style="background:#FFCC00"|'''7'''||Дописываем 7 в конец сочетания.
|-
|1||style="background:#FFCC00"|2||5||6||'''7'''||
|-
| ||^|| || || ||Находим элемент i, a[i + 1] - a[ i ] >= 2
|-
|1||style="background:#FFCC00"|3||5||6||'''7'''||Увеличиваем его на 1.
|-
|1||3||style="background:#FFCC00"|4||style="background:#FFCC00"|5||style="background:#FFCC00"|'''6'''||Дописываем минимальный хвост.
|-
|'''1'''||'''3'''||'''4'''||'''5'''||''' '''||Следующее сочетание.
|}

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 разбиения на слагаемые] ==
Рассматриваемый алгоритм находит следующее разбиение на слагаемые, при этом разбиение упорядоченно по возрастанию.
* Увеличим предпоследнее слагаемое на 1, уменьшим последнее слагаемое на 1.
** Если предпоследнее слагаемое стало больше последнего, то увеличиваем предпоследнее слагаемое на величину последнего.
** Если предпоследнее слагаемое меньше последнего, то разбиваем последнее слагаемое <tex>s</tex> на два слагаемых <tex>a</tex> и <tex>b</tex> таких, что <tex>a</tex> равно предпоследнему слагаемому, а <tex>b = s - a</tex>. Повторяем этот процесс, пока разбиение остается корректным, то есть предпоследнее слагаемое хотя бы в два раза меньше последнего.

<code>
// b – список, содержащий разбиение данного числа, length – его размер.
'''function''' nextPartition(var b: list<int>): list<int>;
'''var''' i : '''integer;'''
'''begin'''
b[b.size] := b[b.size] - 1;
b[b.size - 1] := b[b.size - 1] + 1;
'''if''' b[b.size - 1] > b[b.size] '''then'''
'''begin'''
b[b.size - 1] := b[b.size - 1] + b[b.size];
b.pop();
'''end'''
'''else'''
'''begin'''
'''while''' b[b.size - 1] * 2 <= b[b.size] '''do'''
'''begin'''
b.add(b[b.size] - b[b.size - 1]);
b[b.size - 1] := b[b.size - 2];
'''end;'''
'''end;'''
'''return''' b;
'''end;'''
</code>

=== Пример работы ===
{| class="wikitable" border = 1
|1||style="background:#FFCC00"|1||style="background:#FFCC00"|7|| || ||Прибавим 1 + 1, вычтем 7 - 1.
|-
|1||style="background:#FFCC00"|2||style="background:#FFCC00"|6|| || ||Проверяем: 2<6, значит разбиваем 6 пока оно не станет <4
|-
|1||2||style="background:#FFCC00"|2||style="background:#FFCC00"|4|| ||
|-
|1||2||2||style="background:#FFCC00"|2||style="background:#FFCC00"|2||
|-
|'''1'''||'''2'''||'''2'''||'''2'''||'''2'''||Следующее разбиение на слагаемые числа 9.
|}

{| class="wikitable" border = 1
|1||style="background:#FFCC00"|4||style="background:#FFCC00"|5||Прибавим 4 + 1, вычтем 5 - 1.
|-
|1||style="background:#FFCC00"|5||style="background:#FFCC00"|4||Проверяем: 5>4, значит прибавим к 5 + 4.
|-
|1||9||style="background:#FFCC00"|4||Удалим последний элемент.
|-
|'''1'''||'''9'''||||Следующее разбиение на слагаемые числа 10.
|}

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 разбиения на подмножества] ==

Рассмотрим множество первых n натуральных чисел:<tex>N_n = \{1, 2, ..., n\}</tex>

Упорядочим все разбиения на множества <tex>N_n</tex> лексикографически. Для этого, во-первых, в каждом разбиении упорядочим множества лексикографически. Будем говорить, что подмножество <tex> A \subset N_n </tex> лексикографически меньше подмножества <tex> B \subset N_n </tex> , если верно одно из следующих условий:

*существует <tex>i</tex> такое, что <tex>i \in A</tex> , <tex>i \notin B</tex>, для всех <tex>j < i: j \in A</tex> если и только если <tex>j \in B</tex> , и существует <tex>k > i</tex> такое что <tex>k \in B</tex>;
* <tex> A \subset B </tex> и <tex>i < j</tex> для всех <tex>i \in A</tex> и <tex>j \in B</tex> \ <tex> A </tex>.

Разбиения упорядочены лексикографически следующим образом. Разбиение <tex>N_n = A_1 \cup A_2 \cup . . . \cup A_k</tex> лексикографически меньше разбиения <tex>N_n = B_1 \cup B_2 \cup . . . \cup B_l</tex> если существует такое <tex>i</tex>, что <tex>A_1 = B_1, A_2 = B_2, . . . ,A_{i - 1} = B_{i - 1}, A_i < B_i</tex>.

'''Рассмотрим алгоритм нахождения лексикографически следующего разбиения на подмножества:'''
*Будем хранить подмножества в списке списков, например, разбиение <tex> \{1, 2, 3\}~ \{4, 5\}</tex> будет выглядеть так:

{| class="wikitable" border = 1
|1||2||3
|-
|4||5||
|}

* Двигаясь снизу вверх и справа налево, будем удалять элементы, записывая их в отдельный массив. Будем повторять эту операцию, пока не сможем выполнить одно из действий, описанных ниже:
** Заменить рассматриваемый элемент уже удаленным. Из всех подходящих элементов выбираем минимальный. '''Важное замечание''': мы не можем заменить 1ый элемент подмножества, мы можем только удалить его.
** Дополнить рассматриваемое подмножество уже удаленным элементом. Из всех подходящих элементов выбираем минимальный.
* Допишем лексикографически минимальный хвост подмножеств из оставшихся элементов.

<code>
'''function''' nextSetPartition(a:list<list<int>>):list<list<int>>;
// индексация списка идет от 0
// a - список, содержащий подмножества
// used - список, в котором мы храним удаленные элементы
used = list<int>();
fl = ''false''
'''for''' i = a.size '''downto''' 1
'''if''' used[used.size] > a[i][a[i].size] '''then''' //если можем добавить в конец подмножества элемент из used
a[i].add(used[used.size]); //добавляем
'''break'''
'''for''' j = a[i].size '''downto''' 1
'''if''' (j <> 1) and used[used.size] > a[i][j] '''then''' //если можем заменить элемент, другим элементом из списка used
a[i][j] = used[used.size]; //заменяем
fl = ''true''
'''break'''
used.add(a[i][j]);
a[i].pop(j); // удаляем j элемент i подмножества и добавляем его в список
'''if''' (fl) '''break'''
// далее выведем все получившиеся подмножества
sort(used)
'''for''' i = 1 '''to''' used.size
a.add(used[i]); // добавляем лексикографически минимальных хвост
return(a);
</code>

=== Пример работы ===

'''Рассмотрим следующее разбиение:'''

{| class="wikitable" border = 1
|1||2||3
|-
|4||5||
|}

'''1 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||
|-
|4||style="background:#FFCC00"|5||||
|-
| ||^|| ||Удалили элемент 5.
|-
| || || ||used
|}

'''2 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||
|-
|style="background:#FFCC00"|4|| ||||
|-
|^|| || ||Удалили элемент 4. Так как он является первым в подмножестве, то мы не можем заменить его на другой.
|-
|5|| || ||used
|}

'''3 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||style="background:#FFCC00"|4||
|-
| || || ||^||Дополнили первое подмножество элементом 4
|-
|5|| || || ||used
|}

'''4 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||4||
|-
|style="background:#FFCC00"|5|| || || ||Дописали лексикографически минимальный хвост
|-
| || || || ||used
|}

== Ссылки ==
* [[Получение объекта по номеру]]
* [[Получение номера по объекту]]
* [http://rain.ifmo.ru/cat/view.php/vis/combinations/permutations-2000 Визуализатор перестановок]
* [http://cppalgo.blogspot.com/2011/02/episode-2.html Пример компактного кода для перестановок (С++)]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Комбинаторика]]

Получение следующего объекта

2014-01-04T21:47:35Z

91.122.22.64: /* Специализация алгоритма для генерации следующего разбиения на слагаемые */

== Алгоритм ==
{{Определение|definition= '''Получение следующего объекта''' {{---}} это нахождение объекта, следующего за данным в [[Лексикографический порядок|лексикографическом порядке]].
}}
Объект <tex>Q</tex> называется следующим за <tex>P</tex>, если <tex>P < Q</tex> и не найдется такого <tex>R</tex>, что <tex>P < R < Q</tex>.

Отсюда понятен алгоритм:
* Находим суффикс минимальной длины, который можно изменить без изменения префикса текущего объекта <tex>P</tex>
* К оставшейся части дописываем минимальный возможный элемент (чтобы было выполнено правило <tex>P < Q</tex>)
* Дописываем минимальный возможный хвост
По построению получаем, что <tex>Q</tex> {{---}} минимально возможный.

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 битового вектора] ==
* Находим минимальный суффикс, в котором есть 0, его можно увеличить, не меняя оставшейся части
* Вместо 0 записываем 1
* Дописываем минимально возможный хвост из нулей
'''function''' nextVector(a:array[1..n] of byte):array[1..n] of byte; // n - длина вектора
'''for''' i = n '''downto''' 1
'''if''' a[i] == 0
a[i] = 1
'''for''' j = i + 1 to n
a[j] = 0
'''break'''
return(a);

=== Пример работы ===
{| class="wikitable" border = 1
|0||1||style="background:#FFCC00"|0||1||1||исходный битовый вектор
|-
| || ||^|| || ||находим элемент 0 (самый правый)
|-
|0||1||style="background:#FFCC00"|1||1||1||меняем его на 1
|-
|0||1||1||style="background:#FFCC00"|0||style="background:#FFCC00"|0||меняем элементы правее на нули
|-
|'''0'''||'''1'''||'''1'''||'''0'''||'''0'''||следующий битовый вектор
|}

== Специализация алгоритма для генерации [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 следующей перестановки] ==
* Двигаясь справа налево, находим элемент, нарушающий убывающую последовательность (в обычном порядке, слева направо, см. пример)
* Меняем его с минимальным элементом, большим нашего, стоящим правее
* Перевернем правую часть

'''function''' nextPermutation(a:array[1..n] of integer):array[1..n] of integer; // n - длина перестановки
'''for''' i = n - 1 '''downto''' 1
'''if''' a[i] < a[i + 1]
'''for''' j = i + 1 '''to''' n
'''if''' (a[j] < a[min]) and (a[j] > a[i])
min==j
swap(a[i], a[j])
reverse(a[i + 1]..a[n])
'''break'''
return(a);

=== Пример работы ===
{| class="wikitable" border = 1
|1||3||style="background:#FFCC00"|2||5||style="background:#FFCC00"|4||исходная перестановка
|-
| || ||^|| || ||находим элемент, нарушающий убывающую последовательность
|-
| || || || ||^||минимальный элемент больше нашего
|-
|1||3||style="background:#FFCC00"|4||5||style="background:#FFCC00"|2||меняем их местами
|-
|1||3||4||style="background:#FFCC00"|2||style="background:#FFCC00"|5||разворачивам правую часть
|-
|'''1'''||'''3'''||'''4'''||'''2'''||'''5'''||следующая перестановка
|}

== Специализация алгоритма для генерации следующей [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 мультиперестановки] ==
* Двигаясь справа налево, находим элемент, нарушающий убывающую последовательность (в обычном порядке, слева направо, см. пример).
* Меняем его с минимальным элементом, большим нашего, стоящим правее.
* Переворачиваем правую часть.
'''function''' nextMultiperm(var b:array[1..N] of integer): array[1..N] of integer;
'''var''' i , j : '''integer''';
'''begin'''
i := N - 1;
'''while''' (i > 0) '''and''' (b[i] >= b[i + 1]) '''do'''
dec(i);
'''if''' i > 0 '''then'''
'''begin'''
j := i + 1;
'''while''' (j < N) '''and''' (b[j + 1] > b[i]) '''do'''
inc(j);
swap(b[i] , b[j]);
'''for''' j := i + 1 '''to''' (N + i) '''div''' 2 '''do'''
swap(b[j], b[N - j + i + 1]);
return(b[1..N]);
'''end'''
'''else'''
'''begin'''
return(null);
'''end;'''
'''end;'''

=== Пример работы ===
{| class="wikitable" border = 1
|1||2||3||1||style="background:#FFCC00"|2||style="background:#FFCC00"|3||Исходная перестановка.
|-
| || || || ||^|| ||Находим элемент, нарушающий убывающую последовательность.
|-
| || || || || ||^||Минимальный элемент больше нашего.
|-
|1||2||3||1||style="background:#FFCC00"|3||style="background:#FFCC00"|2||Меняем их местами.
|-
|'''1'''||'''2'''||'''3'''||'''1'''||'''3'''||'''2'''||Следующая мультиперестановка.
|}

== Специализация алгоритма для генерации [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 следующего сочетания] ==

* Добавим в конец массива с сочетанием N+1 – максимальный элемент.
* Пойдём справа налево. Будем искать номер элемента, который отличается от предыдущего на 2.
* Увеличим найденный элемент на 1, и допишем в конец минимально возможный хвост, если такого элемента нет – на вход было дано последнее сочетание.
'''function''' nextChoose(var a:array[1..k] of integer): array[1..k] of integer; // n,k - параметры сочетания.
'''var'''
i,j : '''integer;'''
b:array[1..k+1] of '''integer;'''
'''begin'''
'''for''' i := 1 '''to''' k '''do'''
b[i]:=a[i];
b[k + 1] := n + 1;
i := n;
'''while''' (i > 0) '''and''' ((b[i + 1] - b[i]) < 2) '''do'''
i := i - 1;
'''if''' i > 0 '''then'''
'''begin'''
b[i] := b[i] + 1;
'''for''' j := i + 1 '''to''' k '''do'''
b[j] := b[j - 1] + 1;
'''for''' i := 1 '''to''' k '''do'''
a[i] := b[i];
return(a[1..k]);
'''end'''
'''else'''
return(null);
'''end;'''

=== Пример работы ===
{| class="wikitable" border = 1
|1||2||5||6||style="background:#FFCC00"|'''7'''||Дописываем 7 в конец сочетания.
|-
|1||style="background:#FFCC00"|2||5||6||'''7'''||
|-
| ||^|| || || ||Находим элемент i, a[i + 1] - a[ i ] >= 2
|-
|1||style="background:#FFCC00"|3||5||6||'''7'''||Увеличиваем его на 1.
|-
|1||3||style="background:#FFCC00"|4||style="background:#FFCC00"|5||style="background:#FFCC00"|'''6'''||Дописываем минимальный хвост.
|-
|'''1'''||'''3'''||'''4'''||'''5'''||''' '''||Следующее сочетание.
|}

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 разбиения на слагаемые] ==
Рассматриваемый алгоритм находит следующее разбиение на слагаемые, при этом разбиение упорядоченно по возрастанию.
* Увеличим предпоследнее слагаемое на 1, уменьшим последнее слагаемое на 1.
** Если предпоследнее слагаемое стало больше последнего, то увеличиваем предпоследнее слагаемое на величину последнего.
** Если предпоследнее слагаемое меньше последнего, то разбиваем последнее слагаемое <tex>s</tex> на два слагаемых <tex>a</tex> и <tex>b</tex> таких, что <tex>a</tex> равно предпоследнему слагаемому, а <tex>b = s - a</tex>. Повторяем этот процесс, пока разбиение остается корректным, то есть предпоследнее слагаемое хотя бы в два раза меньше последнего.

<code>
// b – список, содержащий разбиение данного числа, length – его размер.
'''function''' nextPartition(var b: list<int>): list<int>;
'''var''' i : '''integer;'''
'''begin'''
b[b.size] := b[b.size] - 1;
b[b.size - 1] := b[b.size - 1] + 1;
'''if''' b[b.size - 1] > b[b.size] '''then'''
'''begin'''
b[b.size - 1] := b[b.size - 1] + b[b.size];
b.pop();
'''end'''
'''else'''
'''begin'''
'''while''' b[b.size - 1] * 2 <= b[b.size] '''do'''
'''begin'''
b.add(b[b.size] - b[b.size - 1]);
b[b.size - 1] := b[b.size - 2];
'''end;'''
'''end;'''
'''return''' b;
'''end;'''
</code>

=== Пример работы ===
{| class="wikitable" border = 1
|1||style="background:#FFCC00"|1||style="background:#FFCC00"|7|| || ||Прибавим 1 + 1, вычтем 7 - 1.
|-
|1||style="background:#FFCC00"|2||style="background:#FFCC00"|6|| || ||Проверяем: 2<6, значит разбиваем 6 пока оно не станет <4
|-
|1||2||style="background:#FFCC00"|2||style="background:#FFCC00"|4|| ||
|-
|1||2||2||style="background:#FFCC00"|2||style="background:#FFCC00"|2||
|-
|'''1'''||'''2'''||'''2'''||'''2'''||'''2'''||Следующее разбиение на слагаемые числа 9.
|}

{| class="wikitable" border = 1
|1||style="background:#FFCC00"|4||style="background:#FFCC00"|5||Прибавим 4 + 1, вычтем 5 - 1.
|-
|1||style="background:#FFCC00"|5||style="background:#FFCC00"|4||Проверяем: 5>4, значит прибавим к 5 + 4.
|-
|1||9||style="background:#FFCC00"|4||Удалим последний элемент.
|-
|'''1'''||'''9'''||||Следующее разбиение на слагаемые числа 10.
|}

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 разбиения на подмножества] ==

Рассмотрим множество первых n натуральных чисел:<tex>N_n = \{1, 2, ..., n\}</tex>

Упорядочим все разбиения на множества <tex>N_n</tex> лексикографически. Для этого, во-первых, в каждом разбиении упорядочим множества лексикографически. Будем говорить, что подмножество <tex> A \subset N_n </tex> лексикографически меньше подмножества <tex> B \subset N_n </tex> , если верно одно из следующих условий:

*существует <tex>i</tex> такое, что <tex>i \in A</tex> , <tex>i \notin B</tex>, для всех <tex>j < i: j \in A</tex> если и только если <tex>j \in B</tex> , и существует <tex>k > i</tex> такое что <tex>k \in B</tex>;
* <tex> A \subset B </tex> и <tex>i < j</tex> для всех <tex>i \in A</tex> и <tex>j \in B</tex> \ <tex> A </tex>.

Разбиения упорядочены лексикографически следующим образом. Разбиение <tex>N_n = A_1 \cup A_2 \cup . . . \cup A_k</tex> лексикографически меньше разбиения <tex>N_n = B_1 \cup B_2 \cup . . . \cup B_l</tex> если существует такое <tex>i</tex>, что <tex>A_1 = B_1, A_2 = B_2, . . . ,A_{i - 1} = B_{i - 1}, A_i < B_i</tex>.

'''Рассмотрим алгоритм нахождения лексикографически следующего разбиения на подмножества:'''
*Будем хранить подмножества в списке списков, например, разбиение <tex> \{1, 2, 3\}~ \{4, 5\}</tex> будет выглядеть так:

{| class="wikitable" border = 1
|1||2||3
|-
|4||5||
|}

* Двигаясь снизу вверх и справа налево, будем удалять элементы, записывая их в отдельный массив. Будем повторять эту операцию, пока не сможем выполнить одно из действий, описанных ниже:
** Заменить рассматриваемый элемент уже удаленным. Из всех подходящих элементов выбираем минимальный. '''Важное замечание''': мы не можем заменить 1ый элемент подмножества, мы можем только удалить его.
** Дополнить рассматриваемое подмножество уже удаленным элементом. Из всех подходящих элементов выбираем минимальный.
* Допишем лексикографически минимальный хвост подмножеств из оставшихся элементов.

<code>
'''function''' nextSetPartition(a:list<list<int>>):list<list<int>>;
// индексация списка идет от 0
// a - список, содержащий подмножества
// used - список, в котором мы храним удаленные элементы
used = list<int>();
fl = ''false''
'''for''' i = a.size - 1 '''downto''' 0
'''if''' used[used.size] > a[i][a[i].size] '''then''' //если можем добавить в конец подмножества элемент из used
a[i].add(used[used.size]); //добавляем
'''break'''
'''for''' j = a[i].size - 1 '''downto''' 0
'''if''' (j <> 1) and used[used.size] > a[i][j] '''then''' //если можем заменить элемент, другим элементом из списка used
a[i][j] = used[used.size]; //заменяем
fl = ''true''
'''break'''
used.add(a[i][j]);
a[i].pop(j); // удаляем j элемент i подмножества и добавляем его в список
'''if''' (fl) '''break'''
// далее выведем все получившиеся подмножества
sort(used)
'''for''' i = 0 '''to''' used.size - 1
a.add(used[i]); // добавляем лексикографически минимальных хвост
return(a);
</code>

=== Пример работы ===

'''Рассмотрим следующее разбиение:'''

{| class="wikitable" border = 1
|1||2||3
|-
|4||5||
|}

'''1 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||
|-
|4||style="background:#FFCC00"|5||||
|-
| ||^|| ||Удалили элемент 5.
|-
| || || ||used
|}

'''2 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||
|-
|style="background:#FFCC00"|4|| ||||
|-
|^|| || ||Удалили элемент 4. Так как он является первым в подмножестве, то мы не можем заменить его на другой.
|-
|5|| || ||used
|}

'''3 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||style="background:#FFCC00"|4||
|-
| || || ||^||Дополнили первое подмножество элементом 4
|-
|5|| || || ||used
|}

'''4 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||4||
|-
|style="background:#FFCC00"|5|| || || ||Дописали лексикографически минимальный хвост
|-
| || || || ||used
|}

== Ссылки ==
* [[Получение объекта по номеру]]
* [[Получение номера по объекту]]
* [http://rain.ifmo.ru/cat/view.php/vis/combinations/permutations-2000 Визуализатор перестановок]
* [http://cppalgo.blogspot.com/2011/02/episode-2.html Пример компактного кода для перестановок (С++)]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Комбинаторика]]

Получение следующего объекта

2014-01-04T21:43:48Z

91.122.22.64: /* Специализация алгоритма для генерации следующего разбиения на слагаемые */

== Алгоритм ==
{{Определение|definition= '''Получение следующего объекта''' {{---}} это нахождение объекта, следующего за данным в [[Лексикографический порядок|лексикографическом порядке]].
}}
Объект <tex>Q</tex> называется следующим за <tex>P</tex>, если <tex>P < Q</tex> и не найдется такого <tex>R</tex>, что <tex>P < R < Q</tex>.

Отсюда понятен алгоритм:
* Находим суффикс минимальной длины, который можно изменить без изменения префикса текущего объекта <tex>P</tex>
* К оставшейся части дописываем минимальный возможный элемент (чтобы было выполнено правило <tex>P < Q</tex>)
* Дописываем минимальный возможный хвост
По построению получаем, что <tex>Q</tex> {{---}} минимально возможный.

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 битового вектора] ==
* Находим минимальный суффикс, в котором есть 0, его можно увеличить, не меняя оставшейся части
* Вместо 0 записываем 1
* Дописываем минимально возможный хвост из нулей
'''function''' nextVector(a:array[1..n] of byte):array[1..n] of byte; // n - длина вектора
'''for''' i = n '''downto''' 1
'''if''' a[i] == 0
a[i] = 1
'''for''' j = i + 1 to n
a[j] = 0
'''break'''
return(a);

=== Пример работы ===
{| class="wikitable" border = 1
|0||1||style="background:#FFCC00"|0||1||1||исходный битовый вектор
|-
| || ||^|| || ||находим элемент 0 (самый правый)
|-
|0||1||style="background:#FFCC00"|1||1||1||меняем его на 1
|-
|0||1||1||style="background:#FFCC00"|0||style="background:#FFCC00"|0||меняем элементы правее на нули
|-
|'''0'''||'''1'''||'''1'''||'''0'''||'''0'''||следующий битовый вектор
|}

== Специализация алгоритма для генерации [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 следующей перестановки] ==
* Двигаясь справа налево, находим элемент, нарушающий убывающую последовательность (в обычном порядке, слева направо, см. пример)
* Меняем его с минимальным элементом, большим нашего, стоящим правее
* Перевернем правую часть

'''function''' nextPermutation(a:array[1..n] of integer):array[1..n] of integer; // n - длина перестановки
'''for''' i = n - 1 '''downto''' 1
'''if''' a[i] < a[i + 1]
'''for''' j = i + 1 '''to''' n
'''if''' (a[j] < a[min]) and (a[j] > a[i])
min==j
swap(a[i], a[j])
reverse(a[i + 1]..a[n])
'''break'''
return(a);

=== Пример работы ===
{| class="wikitable" border = 1
|1||3||style="background:#FFCC00"|2||5||style="background:#FFCC00"|4||исходная перестановка
|-
| || ||^|| || ||находим элемент, нарушающий убывающую последовательность
|-
| || || || ||^||минимальный элемент больше нашего
|-
|1||3||style="background:#FFCC00"|4||5||style="background:#FFCC00"|2||меняем их местами
|-
|1||3||4||style="background:#FFCC00"|2||style="background:#FFCC00"|5||разворачивам правую часть
|-
|'''1'''||'''3'''||'''4'''||'''2'''||'''5'''||следующая перестановка
|}

== Специализация алгоритма для генерации следующей [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 мультиперестановки] ==
* Двигаясь справа налево, находим элемент, нарушающий убывающую последовательность (в обычном порядке, слева направо, см. пример).
* Меняем его с минимальным элементом, большим нашего, стоящим правее.
* Переворачиваем правую часть.
'''function''' nextMultiperm(var b:array[1..N] of integer): array[1..N] of integer;
'''var''' i , j : '''integer''';
'''begin'''
i := N - 1;
'''while''' (i > 0) '''and''' (b[i] >= b[i + 1]) '''do'''
dec(i);
'''if''' i > 0 '''then'''
'''begin'''
j := i + 1;
'''while''' (j < N) '''and''' (b[j + 1] > b[i]) '''do'''
inc(j);
swap(b[i] , b[j]);
'''for''' j := i + 1 '''to''' (N + i) '''div''' 2 '''do'''
swap(b[j], b[N - j + i + 1]);
return(b[1..N]);
'''end'''
'''else'''
'''begin'''
return(null);
'''end;'''
'''end;'''

=== Пример работы ===
{| class="wikitable" border = 1
|1||2||3||1||style="background:#FFCC00"|2||style="background:#FFCC00"|3||Исходная перестановка.
|-
| || || || ||^|| ||Находим элемент, нарушающий убывающую последовательность.
|-
| || || || || ||^||Минимальный элемент больше нашего.
|-
|1||2||3||1||style="background:#FFCC00"|3||style="background:#FFCC00"|2||Меняем их местами.
|-
|'''1'''||'''2'''||'''3'''||'''1'''||'''3'''||'''2'''||Следующая мультиперестановка.
|}

== Специализация алгоритма для генерации [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 следующего сочетания] ==

* Добавим в конец массива с сочетанием N+1 – максимальный элемент.
* Пойдём справа налево. Будем искать номер элемента, который отличается от предыдущего на 2.
* Увеличим найденный элемент на 1, и допишем в конец минимально возможный хвост, если такого элемента нет – на вход было дано последнее сочетание.
'''function''' nextChoose(var a:array[1..k] of integer): array[1..k] of integer; // n,k - параметры сочетания.
'''var'''
i,j : '''integer;'''
b:array[1..k+1] of '''integer;'''
'''begin'''
'''for''' i := 1 '''to''' k '''do'''
b[i]:=a[i];
b[k + 1] := n + 1;
i := n;
'''while''' (i > 0) '''and''' ((b[i + 1] - b[i]) < 2) '''do'''
i := i - 1;
'''if''' i > 0 '''then'''
'''begin'''
b[i] := b[i] + 1;
'''for''' j := i + 1 '''to''' k '''do'''
b[j] := b[j - 1] + 1;
'''for''' i := 1 '''to''' k '''do'''
a[i] := b[i];
return(a[1..k]);
'''end'''
'''else'''
return(null);
'''end;'''

=== Пример работы ===
{| class="wikitable" border = 1
|1||2||5||6||style="background:#FFCC00"|'''7'''||Дописываем 7 в конец сочетания.
|-
|1||style="background:#FFCC00"|2||5||6||'''7'''||
|-
| ||^|| || || ||Находим элемент i, a[i + 1] - a[ i ] >= 2
|-
|1||style="background:#FFCC00"|3||5||6||'''7'''||Увеличиваем его на 1.
|-
|1||3||style="background:#FFCC00"|4||style="background:#FFCC00"|5||style="background:#FFCC00"|'''6'''||Дописываем минимальный хвост.
|-
|'''1'''||'''3'''||'''4'''||'''5'''||''' '''||Следующее сочетание.
|}

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 разбиения на слагаемые] ==
Рассматриваемый алгоритм находит следующее разбиение на слагаемые, при этом разбиение упорядоченно по возрастанию.
* Увеличим предпоследнее слагаемое на 1, уменьшим последнее слагаемое на 1.
** Если предпоследнее слагаемое стало больше последнего, то увеличиваем предпоследнее слагаемое на величину последнего.
** Если предпоследнее слагаемое меньше последнего, то разбиваем последнее слагаемое <tex>s</tex> на два слагаемых <tex>a</tex> и <tex>b</tex> таких, что <tex>a</tex> равно предпоследнему слагаемому, а <tex>b = s - a</tex>. Повторяем этот процесс, пока разбиение остается корректным, то есть предпоследнее слагаемое хотя бы в два раза меньше последнего.

<code>
// индексация списка идёт от 1
// b – список, содержащий разбиение данного числа, length – его размер.
'''function''' nextPartition(var b: list<int>): list<int>;
'''var''' i : '''integer;'''
'''begin'''
b[b.size] := b[b.size] - 1;
b[b.size - 1] := b[b.size - 1] + 1;
'''if''' b[b.size - 1] > b[b.size] '''then'''
'''begin'''
b[b.size - 1] := b[b.size - 1] + b[b.size];
b.pop();
'''end'''
'''else'''
'''begin'''
'''while''' b[b.size - 1] * 2 <= b[b.size] '''do'''
'''begin'''
b.add(b[b.size] - b[b.size - 1]);
b[b.size - 1] := b[b.size - 2];
'''end;'''
'''end;'''
'''return''' b;
'''end;'''
</code>

=== Пример работы ===
{| class="wikitable" border = 1
|1||style="background:#FFCC00"|1||style="background:#FFCC00"|7|| || ||Прибавим 1 + 1, вычтем 7 - 1.
|-
|1||style="background:#FFCC00"|2||style="background:#FFCC00"|6|| || ||Проверяем: 2<6, значит разбиваем 6 пока оно не станет <4
|-
|1||2||style="background:#FFCC00"|2||style="background:#FFCC00"|4|| ||
|-
|1||2||2||style="background:#FFCC00"|2||style="background:#FFCC00"|2||
|-
|'''1'''||'''2'''||'''2'''||'''2'''||'''2'''||Следующее разбиение на слагаемые числа 9.
|}

{| class="wikitable" border = 1
|1||style="background:#FFCC00"|4||style="background:#FFCC00"|5||Прибавим 4 + 1, вычтем 5 - 1.
|-
|1||style="background:#FFCC00"|5||style="background:#FFCC00"|4||Проверяем: 5>4, значит прибавим к 5 + 4.
|-
|1||9||style="background:#FFCC00"|4||Удалим последний элемент.
|-
|'''1'''||'''9'''||||Следующее разбиение на слагаемые числа 10.
|}

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 разбиения на подмножества] ==

Рассмотрим множество первых n натуральных чисел:<tex>N_n = \{1, 2, ..., n\}</tex>

Упорядочим все разбиения на множества <tex>N_n</tex> лексикографически. Для этого, во-первых, в каждом разбиении упорядочим множества лексикографически. Будем говорить, что подмножество <tex> A \subset N_n </tex> лексикографически меньше подмножества <tex> B \subset N_n </tex> , если верно одно из следующих условий:

*существует <tex>i</tex> такое, что <tex>i \in A</tex> , <tex>i \notin B</tex>, для всех <tex>j < i: j \in A</tex> если и только если <tex>j \in B</tex> , и существует <tex>k > i</tex> такое что <tex>k \in B</tex>;
* <tex> A \subset B </tex> и <tex>i < j</tex> для всех <tex>i \in A</tex> и <tex>j \in B</tex> \ <tex> A </tex>.

Разбиения упорядочены лексикографически следующим образом. Разбиение <tex>N_n = A_1 \cup A_2 \cup . . . \cup A_k</tex> лексикографически меньше разбиения <tex>N_n = B_1 \cup B_2 \cup . . . \cup B_l</tex> если существует такое <tex>i</tex>, что <tex>A_1 = B_1, A_2 = B_2, . . . ,A_{i - 1} = B_{i - 1}, A_i < B_i</tex>.

'''Рассмотрим алгоритм нахождения лексикографически следующего разбиения на подмножества:'''
*Будем хранить подмножества в списке списков, например, разбиение <tex> \{1, 2, 3\}~ \{4, 5\}</tex> будет выглядеть так:

{| class="wikitable" border = 1
|1||2||3
|-
|4||5||
|}

* Двигаясь снизу вверх и справа налево, будем удалять элементы, записывая их в отдельный массив. Будем повторять эту операцию, пока не сможем выполнить одно из действий, описанных ниже:
** Заменить рассматриваемый элемент уже удаленным. Из всех подходящих элементов выбираем минимальный. '''Важное замечание''': мы не можем заменить 1ый элемент подмножества, мы можем только удалить его.
** Дополнить рассматриваемое подмножество уже удаленным элементом. Из всех подходящих элементов выбираем минимальный.
* Допишем лексикографически минимальный хвост подмножеств из оставшихся элементов.

<code>
'''function''' nextSetPartition(a:list<list<int>>):list<list<int>>;
// индексация списка идет от 0
// a - список, содержащий подмножества
// used - список, в котором мы храним удаленные элементы
used = list<int>();
fl = ''false''
'''for''' i = a.size - 1 '''downto''' 0
'''if''' used[used.size] > a[i][a[i].size] '''then''' //если можем добавить в конец подмножества элемент из used
a[i].add(used[used.size]); //добавляем
'''break'''
'''for''' j = a[i].size - 1 '''downto''' 0
'''if''' (j <> 1) and used[used.size] > a[i][j] '''then''' //если можем заменить элемент, другим элементом из списка used
a[i][j] = used[used.size]; //заменяем
fl = ''true''
'''break'''
used.add(a[i][j]);
a[i].pop(j); // удаляем j элемент i подмножества и добавляем его в список
'''if''' (fl) '''break'''
// далее выведем все получившиеся подмножества
sort(used)
'''for''' i = 0 '''to''' used.size - 1
a.add(used[i]); // добавляем лексикографически минимальных хвост
return(a);
</code>

=== Пример работы ===

'''Рассмотрим следующее разбиение:'''

{| class="wikitable" border = 1
|1||2||3
|-
|4||5||
|}

'''1 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||
|-
|4||style="background:#FFCC00"|5||||
|-
| ||^|| ||Удалили элемент 5.
|-
| || || ||used
|}

'''2 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||
|-
|style="background:#FFCC00"|4|| ||||
|-
|^|| || ||Удалили элемент 4. Так как он является первым в подмножестве, то мы не можем заменить его на другой.
|-
|5|| || ||used
|}

'''3 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||style="background:#FFCC00"|4||
|-
| || || ||^||Дополнили первое подмножество элементом 4
|-
|5|| || || ||used
|}

'''4 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||4||
|-
|style="background:#FFCC00"|5|| || || ||Дописали лексикографически минимальный хвост
|-
| || || || ||used
|}

== Ссылки ==
* [[Получение объекта по номеру]]
* [[Получение номера по объекту]]
* [http://rain.ifmo.ru/cat/view.php/vis/combinations/permutations-2000 Визуализатор перестановок]
* [http://cppalgo.blogspot.com/2011/02/episode-2.html Пример компактного кода для перестановок (С++)]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Комбинаторика]]

Получение следующего объекта

2014-01-04T21:38:43Z

91.122.22.64: /* Специализация алгоритма для генерации следующего разбиения на подмножества */

== Алгоритм ==
{{Определение|definition= '''Получение следующего объекта''' {{---}} это нахождение объекта, следующего за данным в [[Лексикографический порядок|лексикографическом порядке]].
}}
Объект <tex>Q</tex> называется следующим за <tex>P</tex>, если <tex>P < Q</tex> и не найдется такого <tex>R</tex>, что <tex>P < R < Q</tex>.

Отсюда понятен алгоритм:
* Находим суффикс минимальной длины, который можно изменить без изменения префикса текущего объекта <tex>P</tex>
* К оставшейся части дописываем минимальный возможный элемент (чтобы было выполнено правило <tex>P < Q</tex>)
* Дописываем минимальный возможный хвост
По построению получаем, что <tex>Q</tex> {{---}} минимально возможный.

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 битового вектора] ==
* Находим минимальный суффикс, в котором есть 0, его можно увеличить, не меняя оставшейся части
* Вместо 0 записываем 1
* Дописываем минимально возможный хвост из нулей
'''function''' nextVector(a:array[1..n] of byte):array[1..n] of byte; // n - длина вектора
'''for''' i = n '''downto''' 1
'''if''' a[i] == 0
a[i] = 1
'''for''' j = i + 1 to n
a[j] = 0
'''break'''
return(a);

=== Пример работы ===
{| class="wikitable" border = 1
|0||1||style="background:#FFCC00"|0||1||1||исходный битовый вектор
|-
| || ||^|| || ||находим элемент 0 (самый правый)
|-
|0||1||style="background:#FFCC00"|1||1||1||меняем его на 1
|-
|0||1||1||style="background:#FFCC00"|0||style="background:#FFCC00"|0||меняем элементы правее на нули
|-
|'''0'''||'''1'''||'''1'''||'''0'''||'''0'''||следующий битовый вектор
|}

== Специализация алгоритма для генерации [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 следующей перестановки] ==
* Двигаясь справа налево, находим элемент, нарушающий убывающую последовательность (в обычном порядке, слева направо, см. пример)
* Меняем его с минимальным элементом, большим нашего, стоящим правее
* Перевернем правую часть

'''function''' nextPermutation(a:array[1..n] of integer):array[1..n] of integer; // n - длина перестановки
'''for''' i = n - 1 '''downto''' 1
'''if''' a[i] < a[i + 1]
'''for''' j = i + 1 '''to''' n
'''if''' (a[j] < a[min]) and (a[j] > a[i])
min==j
swap(a[i], a[j])
reverse(a[i + 1]..a[n])
'''break'''
return(a);

=== Пример работы ===
{| class="wikitable" border = 1
|1||3||style="background:#FFCC00"|2||5||style="background:#FFCC00"|4||исходная перестановка
|-
| || ||^|| || ||находим элемент, нарушающий убывающую последовательность
|-
| || || || ||^||минимальный элемент больше нашего
|-
|1||3||style="background:#FFCC00"|4||5||style="background:#FFCC00"|2||меняем их местами
|-
|1||3||4||style="background:#FFCC00"|2||style="background:#FFCC00"|5||разворачивам правую часть
|-
|'''1'''||'''3'''||'''4'''||'''2'''||'''5'''||следующая перестановка
|}

== Специализация алгоритма для генерации следующей [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 мультиперестановки] ==
* Двигаясь справа налево, находим элемент, нарушающий убывающую последовательность (в обычном порядке, слева направо, см. пример).
* Меняем его с минимальным элементом, большим нашего, стоящим правее.
* Переворачиваем правую часть.
'''function''' nextMultiperm(var b:array[1..N] of integer): array[1..N] of integer;
'''var''' i , j : '''integer''';
'''begin'''
i := N - 1;
'''while''' (i > 0) '''and''' (b[i] >= b[i + 1]) '''do'''
dec(i);
'''if''' i > 0 '''then'''
'''begin'''
j := i + 1;
'''while''' (j < N) '''and''' (b[j + 1] > b[i]) '''do'''
inc(j);
swap(b[i] , b[j]);
'''for''' j := i + 1 '''to''' (N + i) '''div''' 2 '''do'''
swap(b[j], b[N - j + i + 1]);
return(b[1..N]);
'''end'''
'''else'''
'''begin'''
return(null);
'''end;'''
'''end;'''

=== Пример работы ===
{| class="wikitable" border = 1
|1||2||3||1||style="background:#FFCC00"|2||style="background:#FFCC00"|3||Исходная перестановка.
|-
| || || || ||^|| ||Находим элемент, нарушающий убывающую последовательность.
|-
| || || || || ||^||Минимальный элемент больше нашего.
|-
|1||2||3||1||style="background:#FFCC00"|3||style="background:#FFCC00"|2||Меняем их местами.
|-
|'''1'''||'''2'''||'''3'''||'''1'''||'''3'''||'''2'''||Следующая мультиперестановка.
|}

== Специализация алгоритма для генерации [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 следующего сочетания] ==

* Добавим в конец массива с сочетанием N+1 – максимальный элемент.
* Пойдём справа налево. Будем искать номер элемента, который отличается от предыдущего на 2.
* Увеличим найденный элемент на 1, и допишем в конец минимально возможный хвост, если такого элемента нет – на вход было дано последнее сочетание.
'''function''' nextChoose(var a:array[1..k] of integer): array[1..k] of integer; // n,k - параметры сочетания.
'''var'''
i,j : '''integer;'''
b:array[1..k+1] of '''integer;'''
'''begin'''
'''for''' i := 1 '''to''' k '''do'''
b[i]:=a[i];
b[k + 1] := n + 1;
i := n;
'''while''' (i > 0) '''and''' ((b[i + 1] - b[i]) < 2) '''do'''
i := i - 1;
'''if''' i > 0 '''then'''
'''begin'''
b[i] := b[i] + 1;
'''for''' j := i + 1 '''to''' k '''do'''
b[j] := b[j - 1] + 1;
'''for''' i := 1 '''to''' k '''do'''
a[i] := b[i];
return(a[1..k]);
'''end'''
'''else'''
return(null);
'''end;'''

=== Пример работы ===
{| class="wikitable" border = 1
|1||2||5||6||style="background:#FFCC00"|'''7'''||Дописываем 7 в конец сочетания.
|-
|1||style="background:#FFCC00"|2||5||6||'''7'''||
|-
| ||^|| || || ||Находим элемент i, a[i + 1] - a[ i ] >= 2
|-
|1||style="background:#FFCC00"|3||5||6||'''7'''||Увеличиваем его на 1.
|-
|1||3||style="background:#FFCC00"|4||style="background:#FFCC00"|5||style="background:#FFCC00"|'''6'''||Дописываем минимальный хвост.
|-
|'''1'''||'''3'''||'''4'''||'''5'''||''' '''||Следующее сочетание.
|}

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 разбиения на слагаемые] ==
Рассматриваемый алгоритм находит следующее разбиение на слагаемые, при этом разбиение упорядоченно по возрастанию.
* Увеличим предпоследнее слагаемое на 1, уменьшим последнее слагаемое на 1.
** Если предпоследнее слагаемое стало больше последнего, то увеличиваем предпоследнее слагаемое на величину последнего.
** Если предпоследнее слагаемое меньше последнего, то разбиваем последнее слагаемое <tex>s</tex> на два слагаемых <tex>a</tex> и <tex>b</tex> таких, что <tex>a</tex> равно предпоследнему слагаемому, а <tex>b = s - a</tex>. Повторяем этот процесс, пока разбиение остается корректным, то есть предпоследнее слагаемое хотя бы в два раза меньше последнего.

<code>
// b – список, содержащий разбиение данного числа, length – его размер.
'''function''' nextPartition(var b: list<int>): list<int>;
'''var''' i : '''integer;'''
'''begin'''
b[b.size] := b[b.size] - 1;
b[b.size - 1] := b[b.size - 1] + 1;
'''if''' b[b.size - 1] > b[b.size] '''then'''
'''begin'''
b[b.size - 1] := b[b.size - 1] + b[b.size];
b.pop();
'''end'''
'''else'''
'''begin'''
'''while''' b[b.size - 1] * 2 <= b[b.size] '''do'''
'''begin'''
b.add(b[b.size] - b[b.size - 1]);
b[b.size - 1] := b[b.size - 2];
'''end;'''
'''end;'''
'''return''' b;
'''end;'''
</code>

=== Пример работы ===
{| class="wikitable" border = 1
|1||style="background:#FFCC00"|1||style="background:#FFCC00"|7|| || ||Прибавим 1 + 1, вычтем 7 - 1.
|-
|1||style="background:#FFCC00"|2||style="background:#FFCC00"|6|| || ||Проверяем: 2<6, значит разбиваем 6 пока оно не станет <4
|-
|1||2||style="background:#FFCC00"|2||style="background:#FFCC00"|4|| ||
|-
|1||2||2||style="background:#FFCC00"|2||style="background:#FFCC00"|2||
|-
|'''1'''||'''2'''||'''2'''||'''2'''||'''2'''||Следующее разбиение на слагаемые числа 9.
|}

{| class="wikitable" border = 1
|1||style="background:#FFCC00"|4||style="background:#FFCC00"|5||Прибавим 4 + 1, вычтем 5 - 1.
|-
|1||style="background:#FFCC00"|5||style="background:#FFCC00"|4||Проверяем: 5>4, значит прибавим к 5 + 4.
|-
|1||9||style="background:#FFCC00"|4||Удалим последний элемент.
|-
|'''1'''||'''9'''||||Следующее разбиение на слагаемые числа 10.
|}

== Специализация алгоритма для генерации следующего [http://neerc.ifmo.ru/wiki/index.php?title=%D0%9A%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%82%D0%BE%D1%80%D0%BD%D1%8B%D0%B5_%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D1%8B#.D0.9F.D1.80.D0.B8.D0.BC.D0.B5.D1.80.D1.8B_.D0.BA.D0.BE.D0.BC.D0.B1.D0.B8.D0.BD.D0.B0.D1.82.D0.BE.D1.80.D0.BD.D1.8B.D1.85_.D0.BE.D0.B1.D1.8A.D0.B5.D0.BA.D1.82.D0.BE.D0.B2 разбиения на подмножества] ==

Рассмотрим множество первых n натуральных чисел:<tex>N_n = \{1, 2, ..., n\}</tex>

Упорядочим все разбиения на множества <tex>N_n</tex> лексикографически. Для этого, во-первых, в каждом разбиении упорядочим множества лексикографически. Будем говорить, что подмножество <tex> A \subset N_n </tex> лексикографически меньше подмножества <tex> B \subset N_n </tex> , если верно одно из следующих условий:

*существует <tex>i</tex> такое, что <tex>i \in A</tex> , <tex>i \notin B</tex>, для всех <tex>j < i: j \in A</tex> если и только если <tex>j \in B</tex> , и существует <tex>k > i</tex> такое что <tex>k \in B</tex>;
* <tex> A \subset B </tex> и <tex>i < j</tex> для всех <tex>i \in A</tex> и <tex>j \in B</tex> \ <tex> A </tex>.

Разбиения упорядочены лексикографически следующим образом. Разбиение <tex>N_n = A_1 \cup A_2 \cup . . . \cup A_k</tex> лексикографически меньше разбиения <tex>N_n = B_1 \cup B_2 \cup . . . \cup B_l</tex> если существует такое <tex>i</tex>, что <tex>A_1 = B_1, A_2 = B_2, . . . ,A_{i - 1} = B_{i - 1}, A_i < B_i</tex>.

'''Рассмотрим алгоритм нахождения лексикографически следующего разбиения на подмножества:'''
*Будем хранить подмножества в списке списков, например, разбиение <tex> \{1, 2, 3\}~ \{4, 5\}</tex> будет выглядеть так:

{| class="wikitable" border = 1
|1||2||3
|-
|4||5||
|}

* Двигаясь снизу вверх и справа налево, будем удалять элементы, записывая их в отдельный массив. Будем повторять эту операцию, пока не сможем выполнить одно из действий, описанных ниже:
** Заменить рассматриваемый элемент уже удаленным. Из всех подходящих элементов выбираем минимальный. '''Важное замечание''': мы не можем заменить 1ый элемент подмножества, мы можем только удалить его.
** Дополнить рассматриваемое подмножество уже удаленным элементом. Из всех подходящих элементов выбираем минимальный.
* Допишем лексикографически минимальный хвост подмножеств из оставшихся элементов.

<code>
'''function''' nextSetPartition(a:list<list<int>>):list<list<int>>;
// индексация списка идет от 0
// a - список, содержащий подмножества
// used - список, в котором мы храним удаленные элементы
used = list<int>();
fl = ''false''
'''for''' i = a.size - 1 '''downto''' 0
'''if''' used[used.size] > a[i][a[i].size] '''then''' //если можем добавить в конец подмножества элемент из used
a[i].add(used[used.size]); //добавляем
'''break'''
'''for''' j = a[i].size - 1 '''downto''' 0
'''if''' (j <> 1) and used[used.size] > a[i][j] '''then''' //если можем заменить элемент, другим элементом из списка used
a[i][j] = used[used.size]; //заменяем
fl = ''true''
'''break'''
used.add(a[i][j]);
a[i].pop(j); // удаляем j элемент i подмножества и добавляем его в список
'''if''' (fl) '''break'''
// далее выведем все получившиеся подмножества
sort(used)
'''for''' i = 0 '''to''' used.size - 1
a.add(used[i]); // добавляем лексикографически минимальных хвост
return(a);
</code>

=== Пример работы ===

'''Рассмотрим следующее разбиение:'''

{| class="wikitable" border = 1
|1||2||3
|-
|4||5||
|}

'''1 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||
|-
|4||style="background:#FFCC00"|5||||
|-
| ||^|| ||Удалили элемент 5.
|-
| || || ||used
|}

'''2 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||
|-
|style="background:#FFCC00"|4|| ||||
|-
|^|| || ||Удалили элемент 4. Так как он является первым в подмножестве, то мы не можем заменить его на другой.
|-
|5|| || ||used
|}

'''3 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||style="background:#FFCC00"|4||
|-
| || || ||^||Дополнили первое подмножество элементом 4
|-
|5|| || || ||used
|}

'''4 Шаг:'''

{| class="wikitable" border = 1
|1||2||3||4||
|-
|style="background:#FFCC00"|5|| || || ||Дописали лексикографически минимальный хвост
|-
| || || || ||used
|}

== Ссылки ==
* [[Получение объекта по номеру]]
* [[Получение номера по объекту]]
* [http://rain.ifmo.ru/cat/view.php/vis/combinations/permutations-2000 Визуализатор перестановок]
* [http://cppalgo.blogspot.com/2011/02/episode-2.html Пример компактного кода для перестановок (С++)]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Комбинаторика]]