leetcode_33 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 and use only constant 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

 

方法一：暴力搜索，罗列出所有的排列情况，寻找下一个排列

方法二：直接寻找下一个排列

算法如下：

First, we observe that for any given sequence that is in descending order, no next larger permutation is possible. For example, no next permutation is possible for the following array: 如果数组降序排列，没有下一个元素，那么就是第一个排列，将数组反转，从小到大排列

[9, 5, 4, 3, 1]

We need to find the first pair of two successive numbers a[i]a[i] and a[i-1]a[i−1], from the right, which satisfy a[i] > a[i-1]a[i]>a[i−1]. Now, no rearrangements to the right of a[i-1]a[i−1] can create a larger permutation since that subarray consists of numbers in descending order. Thus, we need to rearrange the numbers to the right of a[i-1]a[i−1] including itself.

Now, what kind of rearrangement will produce the next larger number? We want to create the permutation just larger than the current one. Therefore, we need to replace the number a[i-1]a[i−1] with the number which is just larger than itself among the numbers lying to its right section, say a[j]a[j].

我们需要找到这样的 i 和 j ，从右到左第一个 i，满足a[i - 1] < a[ i ] ，j为从右到左，第一个 j 使得 a[i-1] < a[j]

We swap the numbers a[i-1]a[i−1] and a[j]a[j]. We now have the correct number at index i-1i−1. But still the current permutation isn't the permutation that we are looking for. We need the smallest permutation that can be formed by using the numbers only to the right of a[i-1]a[i−1]. Therefore, we need to place those numbers in ascending order to get their smallest permutation.

But, recall that while scanning the numbers from the right, we simply kept decrementing the index until we found the pair a[i]a[i] and a[i-1]a[i−1] where, a[i] > a[i-1]a[i]>a[i−1]. Thus, all numbers to the right of a[i-1]a[i−1] were already sorted in descending order. Furthermore, swapping a[i-1]a[i−1] and a[j]a[j] didn't change that order. Therefore, we simply need to reverse the numbers following a[i-1]a[i−1] to get the next smallest lexicographic permutation.

我们交换 a[i - 1] 和 a[ j ] ,然后将 i ~ n - 1的元素，进行反转。开始这些元素是 从左到右降序排列的，反转后变为从左到右升序排列

The following animation will make things clearer:

 

 

算法代码如下：

class Solution {
public:
    void nextPermutation(vector<int>& nums) {
        int n = nums.size();
        if(n < 2)    return ;
        int i , j;
        for(i = n - 1; i > 0; i--)
        {
            if(nums[i - 1] < nums[i])
            {
                for(j = n - 1; j > i- 1; j--)
                {
                    if(nums[j] > nums[i - 1])
                        break;
                }
                break;
            }
        }
        if(i == 0)
            reverse(nums.begin(),nums.end());
        else
            swap(nums[i-1],nums[j]);
    }
};