LeetCode60 第k个排列（搜索+剪枝 | 思维）

题目链接：leetcode60

题目大意

给出集合 [1,2,3,…,n]，其所有元素共有 n! 种排列。
按大小顺序列出所有排列情况，并一一标记，当 n = 3 时, 所有排列如下：

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

给定 n 和 k，返回第 k 个排列。
说明：
给定 n 的范围是 [1, 9]。
给定 k 的范围是[1, n!]。

输入: n = 3, k = 3
输出: “213”

输入: n = 4, k = 9
输出: "2314"

解题思路

数学规律

不难发现，对于一个长度为 n 的串，其排列方案数为 $n!$ 。根据上篇博客 下一个排列 中提到的缩小规模，前缀不变的思想可以应用到这题中。我们假定一个初试串按当前字典序最小，也就是从小到大排列。对于我们要寻找的第 k 个排列，我们可以找到一个数字 s ，使得$(s-1)!<k<=s!$。显然，这个s就是我们要去进行重新排列的序列规模，则前缀 n-s 个则可以按其字典序原样输出。

我们设 $a=(s-1)!，b=s!，t=k/a$，则必有 $0<t<=s$。为什么要计算这样一个 t 呢？因为这个 t 就是我们要寻找的当前位置所要填的数字，除以 a 的作用相当于考虑将更小一层规模的数字经过排列后升到第一个位置的数字。这里通俗地讲就是每次经过 a 次寻找后第一个数字一定会产生交换，换到比他小且最接近当前数的数。例如，{$1,2,3$}经过2次后第一个数一定换成2，而经过4次后第一个数字一定换成3。（第几次表示第几次变换，本身不变属于第0次）

需要注意的一点，当我们取到后续字典序相对递增的数字交换后，可能会怕破坏这个递增的性质，如果要让这个算法/规律延续，则要把后续的重新排序。但因为后面最多有一个位置逆序，扫一遍即可复原。

时间复杂度$O(n^2)$，空间复杂度$O(1)$。

搜索+剪枝

思路实际上和上面的方法类似，只不过可以不交换，用一个 vis 表示每个数字是否已选择，这样 $O(n)$ 的处理剩余数字升序的部分转变为 $O(n)$ 地寻找后续的第 t 个数字。

时间复杂度$O(n^2)$，空间复杂度$O(n)$。当然这里可以加入链表优化空间复杂度。

代码实现

数学规律

/*
 * @lc app=leetcode.cn id=60 lang=cpp
 *
 * [60] 第k个排列
 */

// @lc code=start
class Solution {
public:
    string getPermutation(int n, int k) {
        string ans = "";
        int fac[n + 1];
        fac[0] = 1;
        for (int i = 0; i < n; i++) {
            ans += '1' + i;
            fac[i + 1] = fac[i] * (i + 1);
        }
        int s, t; 
        k--; //初始序列本身就是第一个序列
        for (int i = 0; i < n - 1; i++) {
            s = k / fac[n - i - 1];
            if (s == 0) continue; //忽略前s个不属于变动部分的前缀
            swap(ans[i], ans[i+s]);
            for (int j = n - 1; j > i + 1; j--) { //使得后续的数字序列仍是递增
                if (ans[j] < ans[j - 1]) {
                    swap(ans[j], ans[j - 1]);
                }
            }
            k  = k % fac[n - i - 1];
        }

        return ans;
    }
};
// @lc code=end

搜索+剪枝

/**
 * Coder: https://leetcode-cn.com/problems/permutation-sequence/solution/hui-su-jian-zhi-python-dai-ma-java-dai-ma-by-liwei/
 */
import java.util.LinkedList;
import java.util.List;

public class Solution {

    public String getPermutation(int n, int k) {
        // 注意：相当于在 n 个数字的全排列中找到索引为 k - 1 的那个数，因此 k 先减 1
        k --;

        int[] factorial = new int[n];
        factorial[0] = 1;
        // 先算出所有的阶乘值
        for (int i = 1; i < n; i++) {
            factorial[i] = factorial[i - 1] * i;
        }

        // 因为要频繁做删除，使用链表
        List<Integer> nums = new LinkedList<>();
        for (int i = 1; i <= n; i++) {
            nums.add(i);
        }

        StringBuilder stringBuilder = new StringBuilder();

        // i 表示剩余的数字个数，初始化为 n - 1
        for (int i = n - 1; i >= 0; i--) {
            int index = k / factorial[i] ;
            stringBuilder.append(nums.remove(index));
            k -= index * factorial[i];
        }
        return stringBuilder.toString();
    }
}