LeetCode 60. Permutation Sequence

最新推荐文章于 2020-06-01 17:59:09 发布

monkey_rose

最新推荐文章于 2020-06-01 17:59:09 发布

阅读量180

点赞数

分类专栏： LeetCode 文章标签： LeetCode c++ 回溯法

本文链接：https://blog.youkuaiyun.com/monkey_rose/article/details/78760874

版权

LeetCode 专栏收录该内容

29 篇文章

订阅专栏

本文介绍了一种高效算法来找到数字集合 [1, n] 中第 k 个字典序排列。通过数学方法确定每个位置上的数字，避免了全排列搜索导致的时间超支。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接

60. 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):

"123"
"132"
"213"
"231"
"312"
"321"

Given n and k, return the kth permutation sequence.

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

解：回溯法稳稳的，但是有几个n=8的样例超时了，坚持用回溯法，想到先通过k的区间判断出第一个字符，然后开始回溯，这样避免了超时。不过根据这个，想到可以直接通过区间依次判断出每一位了，于是放弃了回溯法，毕竟此题没有要输出全部的序列，下面讲非回溯的方法：

1.首先让k是从0开始的数，k--

2.根据规律可以看出当 n = 3 第一个字符，为‘1’，k区间应该是(0, 2!]，‘2’对应区间(2!, 2*2!] ...

3.根据2中规律得到第一个字符，如果得到的是‘1’，那么就要k不变，若得到‘2’，k -= 2! （减去1开头的那些字符串） ...

4.用新的k值和区间继续算后面的字符，其中还要维持一个vector，装可用的字符（按顺序），算出的字符将其从vector中拿出，后面的字符只从vector中选

代码：

class Solution {
public:
    string getPermutation(int n, int k) {
        int limit;
        vector<char> valid;
        string result = "";
        for (int i = 0; i < n; i++) {
            char a = '0' + i + 1;
            valid.push_back(a);
        }
        k--;
        while (n) {
            limit = 1;
            for (int i = 2; i < n; i++) limit *= i;
            int i;
            for (i = 0; i < n; i++) if (k >= limit*i && k < limit*(i+1)) break;
            char a = valid[i];
            std::vector<char>::iterator it = valid.begin();
            k -= limit*i;
            while (i--) it++;
            valid.erase(it);
            result += a;
            n--;
        }
        return result;
    }
};

回溯代码（超时）：

class Solution {
public:
    string find(string now, int n, int k, bool *status, int &count) {
        if (now.length() == n) {
            count++;
            if (count == k) return now;
            else return "";
        }
        for (int i = 0; i < n; i++) {
            if (status[i]) {
                status[i] = false;
                char a = '0'+i+1;
                string result = find(now+a, n, k, status, count);
                if (result != "") return result;
                status[i] = true;
            }
        }
        return "";
    }
    string getPermutation(int n, int k) {
        bool *status = new bool[n];
        for (int i = 0; i < n; i++)
            status[i] = true;
        int count = 0;
        return find("", n, k, status, count); 
    }
};

回溯法（解决超时）：

class Solution {
public:
    string find(string now, int n, int &k, bool *status) {
        if (now.length() == n) {
            k--;
            if (k == 0) return now;
            else return "";
        }
        for (int i = 0; i < n; i++) {
            if (status[i]) {
                status[i] = false;
                char a = '0'+i+1;
                string result = find(now+a, n, k, status);
                if (result != "") return result;
                status[i] = true;
            }
        }
        return "";
    }
    string getPermutation(int n, int k) {
        bool *status = new bool[n];
        for (int i = 0; i < n; i++)
            status[i] = true;
        int limit = 1;
        for (int i = 2; i < n; i++) limit *= i;
        int i = 0;
        for (i = 0; i < n; i++) if (k > limit*i && k <= limit*(i+1)) break;
        char a = '0'+i+1;
        status[i] = false;
        k -= limit*i;
        string str = "";
        return find(str + a, n, k, status); 
    }
};