LeetCode

Permutation Sequence

2014.2.9 01:00

The set [1,2,3,…,n] contains a total of n! unique permutations.

By listing and labeling all of the permutations in order,
We get the following sequence (ie, for n = 3):

1. "123"
2. "132"
3. "213"
4. "231"
5. "312"
6. "321"

Given n and k, return the kth permutation sequence.

Note: Given n will be between 1 and 9 inclusive.

Solution:

　　My first reaction on this problem was recursion. But soon I realized it would be a tail recursion.

　　The problem can be solved in polynomial time.

　　Let's consider a permutation of [1,n]. There're (n - 1)! permutations starting with one number from 1 to n. Thus an n-permutation starting with '4' has at least (4 - 1) * n! permutations before it. We swap '4' to the front and sort the remaing elements behind it in ascending order. In this manner, the problem is changed to (n - 1) scale. You know what to do next.

　　Here is one demonstration for the process, the 23rd permutation of [1 2 3 4]:

　　　　(23 is expressed as 22, zero-indexed)

　　　　[1 2 3 4], 22

　　　　[4 1 2 3], 22 / (3!) = 3, 22 % (3!) = 4

　　　　[4 3 1 2], 4 / (2!) = 2, 4 % (2!) = 0

　　　　[4 3 1 2], 0 / (1!) = 0, 0 % (1!) = 0

　　Actually we don't really need to sort the remaining elements in O(n * log(n)) time. Shifting the elements one by one will keep the sequence sorted, and can be done in O(n) time.

　　During the whole process, we need an array to store the permutation.

　　Total time complexity is O(n^2), space complexity is O(n).

Accepted code:

// 1AC, good~
// #define MY_MAIN
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>
using namespace std;

class Solution {
public:
    string getPermutation(int n, int k) {
        const int fac[10] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};
        int i, j, tmp;
        int div;
        string result;
        
        --k;
        permutation.clear();
        for (i = 1; i <= n; ++i) {
            permutation.push_back(i);
        }
        
        for (i = n - 1; i >= 1; --i) {
            div = k / fac[i];
            tmp = permutation[n - 1 - i + div];
            for (j = 0; j < div; ++j) {
                permutation[n - 1 - i + div - j] = permutation[n - 1 - i + div - j - 1];
            }
            permutation[n - 1 - i] = tmp;
            k = k % fac[i];
        }
        
        result = "";
        for (i = 0; i < n; ++i) {
            sprintf(s, "%d", permutation[i]);
            result = result + string(s);
        }
        permutation.clear();
        
        return result;
    }
private:
    vector<int> permutation;
    char s[100];
};

#ifdef MY_MAIN
int main()
{
    Solution solution;
    int n, k;
    const int fac[10] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};
    
    while (scanf("%d%d", &n, &k) == 2) {
        if (n < 1 || n > 9) {
            continue;
        }
        if (k < 1 || k > fac[n]) {
            continue;
        }
        printf("%s
", solution.getPermutation(n, k).c_str());
    }
    
    return 0;
}
#endif