[LeetCode][Java] 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.

题意：

集合[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 之间的一个数。

算法分析：

方法一：

利用了题目《permutations》的方法，先得到所有的排列，然后找出第 k 个元素，但是超时了，后面也给出代码吧

方法二：

参考博客http://www.cnblogs.com/springfor/p/3896201.html

数学的解法，适用度不高，仅限于这题，了解一下吧。

题目告诉我们：对于n个数可以有n!种排列；那么n-1个数就有(n-1)!种排列。

那么对于n位数来说，如果除去最高位不看，后面的n-1位就有 (n-1)!种排列。

所以，还是对于n位数来说，每一个不同的最高位数，后面可以拼接(n-1)!种排列。

所以你就可以看成是按照每组(n-1)!个这样分组。 

利用 k/(n-1)! 可以取得最高位在数列中的index。这样第k个排列的最高位就能从数列中的index位取得，此时还要把这个数从数列中删除。

然后，新的k就可以有k%(n-1)!获得。（恕我愚笨，现在也没想明白为啥要这么更新k~~）

循环n次即可。 同时，为了可以跟数组坐标对其，令k先--。

AC代码：

方法一：（超时了）

   public String getPermutation(int n, int k) 
    {
		int num[]=new int[n];
		ArrayList<ArrayList<Integer>> temres= new ArrayList<ArrayList<Integer>>();
		for(int i=0;i<n;i++)
			num[i]=i+1;
		temres=permute(num);
    	return temres.get(k-1).toString();
        
    }
    public static ArrayList<ArrayList<Integer>> permute(int[] num) 
    {
    	ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
    	permute(num, 0, result);
    	return result;
    }
    static void permute(int[] num, int start, ArrayList<ArrayList<Integer>> result) 
    {
    	if (start >= num.length) //终止条件，递归到末尾节点是，将数组转化为链表
    	{
    		ArrayList<Integer> item = convertArrayToList(num);
    		result.add(item);
    	}
    	for (int j = start; j <= num.length - 1; j++)
    	{
    		swap(num, start, j);//交换
    		permute(num, start + 1, result);//交换后子代递归
    		swap(num, start, j);//恢复到交换前的初始状态，以便于得出下一次的交换结果
    	}
    }
    private static ArrayList<Integer> convertArrayToList(int[] num) //数组变链表
    {
    	ArrayList<Integer> item = new ArrayList<Integer>();
    	for (int h = 0; h < num.length; h++) 
    		item.add(num[h]);
    	return item;
    }
    private static void swap(int[] a, int i, int j) //交换
    {
    	int temp = a[i];
    	a[i] = a[j];
    	a[j] = temp;
    }

方法二：

    public String getPermutation(int n, int k) 
    {  
        k--;//to transfer it as begin from 0 rather than 1
        
        List<Integer> numList = new ArrayList<Integer>();  
        for(int i = 1; i<= n; i++)
            numList.add(i);
       
        int factorial = 1;    
        for(int i = 2; i < n; i++)  
            factorial *= i;    
        
        StringBuilder res = new StringBuilder();//StringBuffer的简易替换|用在字符串缓冲区被单个线程使用时|它比StringBuffer要快(most of time)
        int times = n-1;
        while(times>=0)
        {
            int indexInList = k/factorial;
            res.append(numList.get(indexInList));  
            numList.remove(indexInList);  
            
            k = k%factorial;//new k for next turn
            if(times!=0)
                factorial = factorial/times;//new (n-1)!
            
            times--;
        }
        
        return res.toString();
    }