LeetCode OJ:Next Permutation

Next Permutation

 

Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers.

If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order).

The replacement must be in-place, do not allocate extra memory.

Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column.
1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

算法思想：

STL库中有next_permutation函数

class Solution {
public:
    void nextPermutation(vector<int> &num) {
        next_permutation(begin(num), end(num));  
    }
};

算法流程如下：

Example 6 8 7 4 3 2

step 1      6 8 7 4 3 2

step 2      6 8 7 4 3 2

step 3      7 8 6 4 3 2

step 4      7 8 6 4 3 2

                 7 2 3 4 6 8

1、从右向左找到第一个非递增元素，即6

2、从右向左找到第一个大于6的元素，即7

3、将6与7置换

4、将6后的元素反转

next_permutation函数实现：

class Solution {
public:
    void nextPermutation(vector<int> &num) {
        _next_permutation(begin(num), end(num));  
    }
    template<typename BidirIt>
    bool _next_permutation(BidirIt first, BidirIt last)
    {
        const auto rfirst = reverse_iterator<BidirIt>(last);
        const auto rlast = reverse_iterator<BidirIt>(first);
        
        auto pivot = next(rfirst);
        
        while(pivot != rlast && *pivot >= *prev(pivot))//step1
            ++pivot;
        
        if(pivot == rlast){
            reverse(rfirst,rlast);
            return false;
        }
        
        auto change = find_if(rfirst,pivot,bind2nd(greater<int>(),*pivot));//step2
        
        swap(*change,*pivot);//step3
        reverse(rfirst,pivot);//step4
        
        return true;
    }
};

另一种实现：

template<class BidirIt>
bool next_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 (*--i < *i1) {//step1
            i2 = last;
            while (!(*i < *--i2));//step2
            
            std::iter_swap(i, i2);//step3
            std::reverse(i1, last);//step4
            return true;
        }
        if (i == first) {
            std::reverse(first, last);
            return false;
        }
    }
}