std :: next_permutation Объяснение реализации

Мне было любопытно, как это std:next_permutationбыло реализовано, поэтому я извлек gnu libstdc++ 4.7версию и обработал идентификаторы и форматирование, чтобы создать следующую демонстрацию ...

#include <vector>
#include <iostream>
#include <algorithm>

using namespace std;

template<typename It>
bool next_permutation(It begin, It end)
{
        if (begin == end)
                return false;

        It i = begin;
        ++i;
        if (i == end)
                return false;

        i = end;
        --i;

        while (true)
        {
                It j = i;
                --i;

                if (*i < *j)
                {
                        It k = end;

                        while (!(*i < *--k))
                                /* pass */;

                        iter_swap(i, k);
                        reverse(j, end);
                        return true;
                }

                if (i == begin)
                {
                        reverse(begin, end);
                        return false;
                }
        }
}

int main()
{
        vector<int> v = { 1, 2, 3, 4 };

        do
        {
                for (int i = 0; i < 4; i++)
                {
                        cout << v[i] << " ";
                }
                cout << endl;
        }
        while (::next_permutation(v.begin(), v.end()));
}

Результат ожидаемый: http://ideone.com/4nZdx

Мои вопросы: как это работает? Что означает i, jи k? Какое значение они имеют на разных этапах исполнения? Какой эскиз доказательства его правильности?

Очевидно, что перед входом в основной цикл он просто проверяет тривиальные случаи списка элементов 0 или 1. При входе в основной цикл i указывает на последний элемент (а не на один конец), и список состоит как минимум из двух элементов.

Что происходит в теле основного цикла?

Давайте посмотрим на некоторые перестановки:

1 2 3 4
1 2 4 3
1 3 2 4
1 3 4 2
1 4 2 3
1 4 3 2
2 1 3 4
...

Как нам перейти от одной перестановки к другой? Во-первых, давайте посмотрим на вещи немного по-другому. Мы можем рассматривать элементы как цифры, а перестановки как числа . Рассматривая проблему таким образом, мы хотим упорядочить перестановки / числа в «возрастающем» порядке .

Заказывая номера, мы хотим «увеличить их на наименьшую сумму». Например, при подсчете мы не считаем 1, 2, 3, 10, ... потому что все еще есть 4, 5, ... между ними, и хотя 10 больше 3, есть недостающие числа, которые можно получить увеличивая 3 на меньшую величину. В приведенном выше примере мы видим, что оно 1остается первым номером в течение длительного времени, поскольку есть много перестановок последних 3 «цифр», которые «увеличивают» перестановку на меньшую величину.

Итак, когда мы наконец "используем" 1? Когда больше нет перестановок последних 3 цифр.
А когда больше нет перестановок последних 3 цифр? Когда последние 3 цифры расположены в порядке убывания.

Ага! Это ключ к пониманию алгоритма. Мы изменяем положение «цифры» только тогда, когда все справа находится в порядке убывания, потому что, если это не в порядке убывания, то есть еще другие перестановки (т.е. мы можем «увеличить» перестановку на меньшую величину) .

Вернемся к коду:

while (true)
{
    It j = i;
    --i;

    if (*i < *j)
    { // ...
    }

    if (i == begin)
    { // ...
    }
}

Из первых двух строк цикла j- это элемент, а iэто элемент перед ним.
Затем, если элементы расположены в порядке возрастания, ( if (*i < *j)) что-то делает.
В противном случае, если все идет в порядке убывания ( if (i == begin)), то это последняя перестановка.
В противном случае мы продолжаем и видим, что j и i существенно уменьшаются.

Теперь мы понимаем if (i == begin)часть, поэтому все, что нам нужно понять, это if (*i < *j)часть.

Также обратите внимание: «Тогда, если элементы расположены в порядке возрастания ...», что подтверждает наше предыдущее наблюдение, что нам нужно сделать что-то только с цифрой, «когда все справа находится в порядке убывания». Оператор восходящего порядка ifпо сути находит крайнее левое место, где «все справа находится в порядке убывания».

Давайте еще раз посмотрим на несколько примеров:

...
1 4 3 2
2 1 3 4
...
2 4 3 1
3 1 2 4
...

Мы видим, что когда все справа от цифры находится в порядке убывания, мы находим следующую по величине цифру и помещаем ее впереди, а затем помещаем оставшиеся цифры в порядке возрастания .

Посмотрим на код:

It k = end;

while (!(*i < *--k))
    /* pass */;

iter_swap(i, k);
reverse(j, end);
return true;

Что ж, поскольку элементы справа расположены в порядке убывания, чтобы найти «следующую по величине цифру», нам просто нужно выполнить итерацию с конца, что мы видим в первых трех строках кода.

Затем мы меняем «следующую по величине цифру» на передний план с помощью iter_swap()оператора, а затем, поскольку мы знаем, что эта цифра была следующей по величине, мы знаем, что цифры справа все еще находятся в порядке убывания, поэтому, чтобы поместить их в порядке возрастания, мы просто должны reverse()это сделать.

Реализация gcc генерирует перестановки в лексикографическом порядке. Википедия объясняет это следующим образом:

Следующий алгоритм лексикографически генерирует следующую перестановку после данной перестановки. Он изменяет данную перестановку на месте.

1. Найдите наибольший индекс k такой, что a [k] <a [k + 1]. Если такого индекса не существует, перестановка является последней перестановкой.
2. Найдите наибольший индекс l такой, что a [k] <a [l]. Поскольку k + 1 является таким индексом, l корректно определено и удовлетворяет k <l.
3. Поменяйте местами a [k] на [l].
4. Переверните последовательность от a [k + 1] до последнего элемента a [n] включительно.

Кнут подробно описывает этот алгоритм и его обобщения в разделах 7.2.1.2 и 7.2.1.3 книги «Искусство компьютерного программирования» . Он называет это «Алгоритм L» - очевидно, он восходит к 13 веку.

Вот полная реализация с использованием других алгоритмов стандартной библиотеки:

template <typename I, typename C>
    // requires BidirectionalIterator<I> && Compare<C>
bool my_next_permutation(I begin, I end, C comp) {
    auto rbegin = std::make_reverse_iterator(end);
    auto rend = std::make_reverse_iterator(begin);
    auto rsorted_end = std::is_sorted_until(rbegin, rend, comp);
    bool has_more_permutations = rsorted_end != rend;
    if (has_more_permutations) {
        auto next_permutation_rend = std::upper_bound(
            rbegin, rsorted_end, *rsorted_end, comp);
        std::iter_swap(rsorted_end, next_permutation_rend);
    }
    std::reverse(rbegin, rsorted_end);
    return has_more_permutations;
}

Демо

Существует очевидная возможная реализация с использованием cppreference<algorithm> .

template <class Iterator>
bool next_permutation(Iterator first, Iterator last) {
    if (first == last) return false;
    Iterator i = last;
    if (first == --i) return false;
    while (1) {
        Iterator i1 = i, i2;
        if (*--i < *i1) {
            i2 = last;
            while (!(*i < *--i2));
            std::iter_swap(i, i2);
            std::reverse(i1, last);
            return true;
        }
        if (i == first) {
            std::reverse(first, last);
            return false;
        }
    }
}

Измените содержимое на лексикографически следующую перестановку (на месте) и верните истину, если существует, в противном случае сортируйте и верните ложь, если она не существует.