60. 排列序列(递归回溯+逆康托展开)

题目链接：力扣

 方法一：递归+回溯

通过递归枚举出所有的排列组合，保存到结果中，第k个即可

直接使用递归+回溯会超时，因为题目中n的最大值为9，所以可以在类初始化时提前将所有长度为n的排列组合记录下来，在getPermutation(int n, int k)函数中，直接从保存的排列组合中获取值

具体算法如下：

1. 定义递归函数：process(int n, boolean[] used, List<String> result, StringBuilder sb)
   1. 参数：
      1. n：集合的长度
      2. used：记录数字 i 是否已经在排列中(下标从0开始，used[0]代表数字1是否已经在排列中的情况)
      3. result：保存所有的排列结果
      4. sb：保存当前的一种排列 
2. 递归终止条件
   1. 如果sb.length()==n，说明sb中保存的是一种排列，result.add(sb.toString())
3. 否则，从1到n循环选择当前加入到排列中的数字(可以保证result的排列是按照升序排列的)
   1. 如果used[i-1]==false，说明数字 i 还没有被加入到排列中
      1. sb.append(i)
      2. used[i-1]=true
      3. process(n, used, result, sb)：递归的加入下一个数字
      4. 回溯：
         1. used[i-1]=false，重新标记为false，可以供下次选择
         2. sb.deleteCharAt(sb.length()-1)：将刚才选择的元素从排列中删除

AC代码：

class Solution {
    public static List<List<String>> data= new ArrayList<>();
    //类初始化时打表
    static {
        for (int i = 0;i<9;i++){
            data.add(init(i+1));
        }
    }
    //按照升序返回长度为n的的集合的所有排列
    public static List<String> init(int n){
        StringBuilder sb = new StringBuilder();
        List<String> result = new ArrayList<>();
        boolean[] used = new boolean[n];
        process(n, used, result, sb);
        return result;
    }

    public static void process(int n, boolean[] used, List<String> result, StringBuilder sb) {
        if (sb.length() == n) {
            result.add(sb.toString());
        }
        for (int i = 1; i <= n; i++) {
            if (!used[i-1]) {
                sb.append(i);
                used[i-1] = true;
                process(n, used, result, sb);
                used[i-1] = false;
                sb.deleteCharAt(sb.length() - 1);
            }
        }
    }

    public static String getPermutation(int n, int k) {
        return data.get(n-1).get(k-1);
    }
}

 递归的方式，时间复杂度比较高，时间复杂度和空间复杂度为O(n!)

方法二：其实就是逆康托展开的思想，尼康托展开可以看这篇博文：康托展开&逆康托展开详解

找规律：对于递增的排列，第i位固定后，后面的所有位的排列个数是固定的

1. 第一位：
   1. 第一位为1时，一共有(n-1)! 种排列
   2. 第一位为2时，一共有(n-1)! 种排列
   3. ...
   4. 第一位为n时，一共有(n-1)! 种排列
2. 所以对于第k个排列的第1位的数值是可以计算出来的
   1. 第一位的数值   ，num表示集合中的第几个数
3. 第一位确定后，只需要求解剩下的n-1位排列种第 k1个排列，k1也是可以计算出来的
   1. k1满足：k1=(k-1)%(n-1)! + 1，这里(k-1)是为了防止k的值恰好等于(n-1)!的情况，因为这个时候k1就等于1了，但是k1应该是剩下得n-1位排列得第n-1个排列而不是第一个排列，所以先减1取模后，再加上一个1，让其值继续为n-1，上述求解num时先k-1也是这个原因
   2. 假设第一位为2，则之后求解相当于集合{1，3，...，n}这n-1个数的第k1个排列，现在的目标是确定这n-1个数组成的排列的第一位，然后在确定剩下的n-2个数组成的排列种的第一位，依次类推

AC代码：

class Solution {
    public static String getPermutation(int n, int k) {
        int[] factorial = new int[n];
        factorial[0] = 1;
        //阶乘
        for (int i = 1; i < n; i++) {
            factorial[i] = i * factorial[i - 1];
        }
        StringBuilder sb = new StringBuilder();
        boolean[] used = new boolean[n + 1];
        //确定每一位
        for (int i = 1; i <= n; i++) {
            int num = (k - 1) / factorial[n - i] + 1;
            for (int j = 1; j <= n; j++) {
                if (!used[j]) {
                    num--;
                    if (num == 0) {
                        sb.append(j);
                        used[j] = true;
                        break;
                    }
                }
            }
            k=(k-1)%factorial[n-i]+1;
        }
        return sb.toString();
    }
}