LeetCode:Permutation Sequence

題目鏈接

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.

---

 

在面試時需要注意咨詢面試官，輸入的k 是否小於1 或者 是否大於n!

分析：按照一般的遞歸求全排列的算法（LeetCode:Permutations），輸出的序列不是按字典序有序的，比如對於1,2,3，輸出序列為：

1 2 3
1 3 2
2 1 3
2 3 1
3 2 1
3 1 2

以3開頭的排列舉例，算法中是把1和3交換得到3 2 1，然后遞歸的求解，但是3 2 1不是以3開頭的最小序列，應該是3 1 2. 為了得到有序的序列，我們不是把1 3 交換，而是應該把3移動到1的前面，這樣得到的第一個以3開頭的序列就是3 1 2。因此有如下的算法：

算法1

class Solution {
private:
    int k_;
    string res_;
public:
    string getPermutation(int n, int k) {
        k_ = k;
        string str = string("123456789").substr(0, n);
        int cnt = 0;
        PermutationRecur(str, 0, cnt);
        return res_;
    }
    
    bool PermutationRecur(string &str, int index, int &cnt)
    {
        int len = str.size();
        if(index == len - 1)
        {
            cnt++;
            if(cnt == k_)
            {
                res_ = str;
                return true;
            }
        }
        else
        {
            for(int i = index; i < len; i++)
            {
                rotate(&str[index], &str[i], &str[i+1]);
                if(PermutationRecur(str, index + 1, cnt))
                    return true;
                rotate(&str[index], &str[i], &str[i+1]);
            }
        }
        return false;
    }
};

該算法在大數據下超時了。

---

 

算法2

利用next_permutation函數（該函數的詳解請參考LeetCode:Permutations算法3），這種做法也超時了

class Solution {
public:
    string getPermutation(int n, int k) {
        string str = string("123456789").substr(0, n);
        for(int i = 1; i <= k-1; i++)
            next_permutation(str.begin(), str.end());
        return str;
    }
};

---

算法3                                                 

上面的算法都是逐個的求排列，有沒有什么方法不是逐個求，而是直接構造出第k個排列呢？我們以n = 4，k = 17為例，數組src = [1,2,3,...,n]。

第17個排列的第一個數是什么呢：我們知道以某個數固定開頭的排列個數 = (n-1)! = 3! = 6, 即以1和2開頭的排列總共6*2 = 12個，12 < 17, 因此第17個排列的第一個數不可能是1或者2，6*3 > 17, 因此第17個排列的第一個數是3。即第17個排列的第一個數是原數組（原數組遞增有序）的第m = upper(17/6) = 3（upper表示向上取整）個數。                                           本文地址

第一個數固定后，我們從src數組中刪除該數，那么就相當於在當前src的基礎上求第k - (m-1)*(n-1)! = 17 - 2*6 = 5個排列，因此可以遞歸的求解該問題。

class Solution {
public:
    string getPermutation(int n, int k) {
        string str = string("123456789").substr(0, n);
        string res(n, ' ');
        for(int i = 0; i < n; i++)
            res[i] = helper(str, k);
        return res;
    }
    //以s中字符構造的全排列中，返回第k個排列的第一個字符，並且刪除s中該字符
    //s中字符遞增有序
    char helper(string &s, int &k)
    {
        int tmp = factorial(s.size()-1), i = (k-1)/tmp;
        char res = s[i];
        s.erase(i, 1);
        k -= i*tmp;//更新k
        return res;
    }
    //求正整數n的階乘
    int factorial(int n)
    {
        int res = 1;
        for(int i = 2; i <= n; i++)
            res *= i;
        return res;
    }
};

當然也可以非遞歸實現

class Solution {
public:
    string getPermutation(int n, int k) {
        int total = factorial(n);
        string candidate = string("123456789").substr(0, n);
        string res(n,' ');
        for(int i = 0; i < n; i++)//依次計算排列的每個位
        {
            total /= (n-i);
            int index = (k-1) / total;
            res[i] = candidate[index];
            candidate.erase(index, 1);
            k -= index*total;
        }
        return res;
    }
    int factorial(int n)
    {
        int res = 1;
        for(int i = 2; i <= n; i++)
            res *= i;
        return res;
    }
};

 

【版權聲明】轉載請注明出處：http://www.cnblogs.com/TenosDoIt/p/3721918.html