力扣46和60

力扣46：给定一个没有重复数字的序列，返回其所有可能的全排列

思路：递归解决
每次排列前一个都是和后一个数交换
交换到最后一位时存入lists中

	public static void dfs(List<List<Integer>> lists, int[] nums, int n) {
        if (n == nums.length) {
            List<Integer> list = new ArrayList<>();
            for (int num : nums) {
                list.add(num);
            }
            lists.add(list);
        }else {
            for (int i = n; i < nums.length; i++) {
                swap(nums,n,i);
                dfs(lists,nums,n+1);
                swap(nums,n,i);
            }
        }
    }
    public static void swap(int[] nums,int n,int m){
        int temp = nums[n];
        nums[n] = nums[m];
        nums[m] = temp;
    }

力扣60：给出集合 [1,2,3,…,n]，其所有元素共有 n! 种排列。

按大小顺序列出所有排列情况，并一一标记，当 n = 3 时, 所有排列如下：
“123” “132” “213” “231” “312” “321” 给定 n 和 k，返回第 k 个排列。
说明：给定 n 的范围是 [1, 9]。 给定 k 的范围是[1, n!]。
示例 1:
输入: n = 3, k = 3 输出: “213”
示例 2:
输入: n = 4, k = 9 输出: “2314”

思路1：暴力回溯
运行时间超时

	public static String getPermutation(int n, int k) {
        int[] ints = new int[n];
        for (int i = 0; i < ints.length; i++) {
            ints[i] = i + 1;
        }
        ArrayList<List<Integer>> list = new ArrayList<>();
        dfs(list,ints,0);
        long[] arr = new long[list.size()];
        int count = 0;
        for (List<Integer> in : list) {
            for (Integer i : in) {
                arr[count] = (arr[count] + i) * 10;
            }
            arr[count] = arr[count] / 10;
            count++;
        }
        Arrays.sort(arr);
        return arr[k-1]+"";
    }
    public static void dfs(List<List<Integer>> lists, int[] nums, int n) {
        if (n == nums.length) {
            List<Integer> list = new ArrayList<>();
            for (int num : nums) {
                list.add(num);
            }
            lists.add(list);
        }else {
            for (int i = n; i < nums.length; i++) {
                swap(nums,n,i);
                dfs(lists,nums,n+1);
                swap(nums,n,i);
            }
        }
    }
    public static void swap(int[] nums,int n,int m){
        int temp = nums[n];
        nums[n] = nums[m];
        nums[m] = temp;
    }

思路2：找规律
由于排列情况是按大小顺序排列的
第k个的排列情况为
确定第一位:
k = 5(从0开始计数)
index = k / (n-1)! = 2, 说明第6个数的第一位是3
更新k
k = k - index*(n-1)! = 1
确定第二位:
k = 1
index = k / (n-2)! = 1, 说明第15个数的第二位是2
更新k
k = k - index*(n-2)! = 0
确定第三位:
k = 0
index = k / (n-3)! = 0, 说明第15个数的第三位是1
最终确定n=3时第15个数为321：

	public static String getPermutation(int n, int k) {
		StringBuilder sb = new StringBuilder();
        // 候选数字
        List<Integer> candidates = new ArrayList<>();
        // 分母的阶乘数
        int[] factorials = new int[n+1];
        factorials[0] = 1;
        int fact = 1;
        for(int i = 1; i <= n; ++i) {
            candidates.add(i);
            fact *= i;
            factorials[i] = fact;
        }
        k -= 1;
        for(int i = n-1; i >= 0; --i) {
            // 计算候选数字的index
            int index = k / factorials[i];
            sb.append(candidates.remove(index));
            k -= index*factorials[i];
        }
        return sb.toString();
    }