LeetCode - Next Permutation

Next Permutation

2013.12.7 05:14

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

Solution:

　　First of all, if a sequence is non-increasing, we can't find any of its permutations greater than itself. Then let's see this example.

　　　　this: [3, 5, 4, 2, 1] -> next: [4, 1, 2, 3, 5]

　　　　this: [3 5, 1, 2, 4] -> next: [3, 5, 1, 4, 2]

　　A non-increasing sequence doesn't have a greater "next-permutation", so we'll have to find the first position where it is increasing, namely "3, 5" in sample 1, and "2, 4" in sampe 2.

　　Take the first case for example, "3 5" is the first increasing position, we pick out "4", which is the first element greater than "3" from the right side, and do a swap:

　　　　[3, 5, 4, 2, 1]->[4, 5, 3, 2, 1]

　　Then reverse the part after "4":

　　　　[3, 5, 4, 2, 1]->[4, 5, 3, 2, 1]->[4, 1, 2, 3, 5]

　　You might wanna ask:

　　　　1. Why check the right part? It's for lexicological order.

　　　　2. Why choose the first element "4" that is greater than that "3"? To ensure it's the next greater permutation.

　　Still, if the sequence is non-increasing at all, just reverse it to get the smallest permuation as the answer.

　　Time complexity is O(n), space complexity is O(1).

Accepted code:

// 1WA, 1AC
class Solution {
public:
    void nextPermutation(vector<int> &num) {
        // IMPORTANT: Please reset any member data you declared, as
        // the same Solution instance will be reused for each test case.
        int i, j, n;
        int tmp;
        
        n = num.size();
        // 1WA here, wrong direction of $i
        i = n - 2;
        while(i >= 0 && num[i] >= num[i + 1]){
            --i;
        }
        
        if(i == -1){
            reverse(num, 0, n - 1);
            return;
        }
        
        j = n - 1;
        while(num[i] >= num[j]){
            --j;
        }
        tmp = num[i];
        num[i] = num[j];
        num[j] = tmp;
        
        reverse(num, i + 1, n - 1);
    }
private:
    void reverse(vector<int> &num, int left, int right) {
        int tmp;
        int i;
        
        if(left >= right){
            return;
        }
        
        i = left;
        while(i < left + right - i){
            tmp = num[i];
            num[i] = num[left + right - i];
            num[left + right - i] = tmp;
            ++i;
        }
    }
};