Namespaces
Variants

std::prev_permutation

С сайта ru.cppreference.net
 
 
Библиотека алгоритмов
Ограниченные алгоритмы и алгоритмы над диапазонами (C++20)
Ограниченные алгоритмы, например ranges::copy, ranges::sort, ...
Операции последовательности, не изменяющие данные    
Пакетные операции
(C++17)
Операции поиска
Операции изменения последовательности
Операции копирования
(C++11)
(C++11)
Операции обмена
Операции преобразования
Операции генерации
Операции удаления
Операции изменения порядка
(до C++17)(C++11)
(C++20)(C++20)
Операции выборки
(C++17)

Сортировка и связанные операции
Операции разделения
(C++11)    

Операции сортировки
Операции бинарного поиска
(на разделенных диапазонах)
Операции над множествами (на отсортированных диапазонах)
Операции слияния (на отсортированных диапазонах)
Операции над кучей
Операции минимума/максимума
(C++11)
(C++17)
Операции лексикографического сравнения
Операции перестановок


Политики выполнения (C++17)
(только для пояснения*)(C++26)

Числовые операции
(C++11)
(C++17)
(C++17)    

Специализированные<memory> алгоритмы

Специализированные<random> алгоритмы
C-библиотека









 
Определён в заголовке <algorithm>
template< class BidirIt >
bool prev_permutation( BidirIt first, BidirIt last );
(1) (constexpr начиная с C++20)
template< class BidirIt, class Compare >
bool prev_permutation( BidirIt first, BidirIt last, Compare comp );
(2) (constexpr начиная с C++20)

Преобразует диапазон [first, last) в предыдущую перестановку. Возвращает true если такая перестановка существует, в противном случае преобразует диапазон в последнюю перестановку (в порядке убывания) и возвращает false.

1) Множество всех перестановок упорядочено лексикографически относительно operator<(до C++20)std::less{}(начиная с C++20).
2) Множество всех перестановок упорядочено лексикографически относительно comp.

Если тип *first не является Swappable(до C++11)BidirIt не является ValueSwappable(начиная с C++11), поведение не определено.

Параметры

first, last - пара итераторов, определяющих диапазон переставляемых элементов
comp - функциональный объект сравнения (т.е. объект, удовлетворяющий требованиям Compare), который возвращает true если первый аргумент меньше второго.

Сигнатура функции сравнения должна быть эквивалентна следующей:

bool cmp(const Type1& a, const Type2& b);

Хотя в сигнатуре не обязательно указывать const&, функция не должна изменять переданные ей объекты и должна принимать все значения типа (возможно, const) Type1 и Type2 независимо от категории значения (таким образом, Type1& не допускается, как и Type1 если только для Type1 перемещение эквивалентно копированию(начиная с C++11)).
Типы Type1 и Type2 должны быть такими, что объект типа BidirIt можно разыменовать и неявно преобразовать к каждому из них.

Требования к типам
-
BidirIt должен соответствовать требованиям ValueSwappable и LegacyBidirectionalIterator.

Возвращаемое значение

true если новая перестановка предшествует старой в лексикографическом порядке. false если была достигнута первая перестановка и диапазон сброшен до последней перестановки.

Исключения

Любые исключения, возникающие при операциях с итераторами или обмене элементами.

Сложность

Пусть N равно std::distance(first, last):

1,2) Не более
N
2
обменов.

Возможная реализация

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

Примечания

В среднем по всей последовательности перестановок типичные реализации выполняют около 3 сравнений и 1.5 обменов на вызов.

Реализации (например, MSVC STL) могут включать векторизацию, если тип итератора удовлетворяет LegacyContiguousIterator и обмен его значением не вызывает ни нетривиальную специальную функцию-член, ни ADL-найденную swap.

Пример

Следующий код выводит все шесть перестановок строки "cab" в обратном порядке.

#include <algorithm>
#include <iostream>
#include <string>

int main()
{
    std::string s = "cab";
    
    do
    {
        std::cout << s << ' ';
    }
    while (std::prev_permutation(s.begin(), s.end()));
    
    std::cout << s << '\n';
}

Вывод:

cab bca bac acb abc cba

См. также

определяет, является ли последовательность перестановкой другой последовательности
(шаблон функции &функциональный объект алгоритма)
генерирует следующую большую лексикографическую перестановку диапазона элементов
(шаблон функции &функциональный объект алгоритма)
генерирует следующую меньшую лексикографическую перестановку диапазона элементов
(функциональный объект алгоритма)