LeetCode中與Permutations相關的共有四題：
??31. Next Permutation
??46. Permutations
??47. Permutations II
??60. Permutation Sequence
??大致包括了所有全排列問題可能考到的題型。
??本文按序列出了解這四道題的詳細思路和AC代碼。在各題之間，盡可能地使用了不同的解法，使大家對各種方法能有個了解。
目錄
下一個全排列數
題一描述：
原題鏈接：31. Next Permutation
??給定任一非空正整數序列，生成這些數所能排列出的下一個較大序列。若給出的序列為最大序列，則生成最小序列。
輸入 → 輸出
1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1
題一解析：
概念:
這里，先考慮一個序列的最大最小情況。當一個序列為非遞減序列時，它必然是該組數的最小的排列數；同理，當一個序列為非遞增序列時，它必然是該組數的最大的排列數。
舉例:
那么給定一個p(n)要如何才能生成p(n+1)呢？先來看下面的例子：
??我們用<a1,a2,...,am>來表示m個數的一種序列。設序列p(n)=<3,6,4,2>，根據定義可算得下一個序列p(n+1)=<4,2,3,6>。
??1. 觀察p(n)可以發現，其子序列<6,4,2>已經為減序，那么這個子序列不可能通過交換元素位置得出更大的序列了。因此必須移動最高位3（即a1）的位置，且要在子序列<6,4,2>中找一個數來取代3的位置。
??2. 子序列<6,4,2>中6和4都比3大，但6大于4。如果用6去替換3得到的序列一定會大于4替換3得到的序列，因此只能選4。將4和3的位置對調后形成排列<4,6,3,2>。對調后得到的子序列<6,3,2>仍保持減序，即這3個數能夠生成的最大的一種序列。
??3. 而4是第1次作為首位的，需要右邊的子序列最小，因此4右邊的子序列應為<2,3,6>，這樣就得到了正確的一個序列p(n+1)=<4,2,3,6>。
結論:
由此，我們可以知道，本題的關鍵即是求出數組末尾的最長的非遞增子序列。
??不妨假設在數組nums中，nums[k+1]...nums[n]均滿足前一個元素大于等于后一個元素，即這一子序列非遞增。
??那么，我們要做的，就是把nums[k]與其后序列中稍大于nums[k]的數交換，接著再逆序nums[k+1]...nums[n]即可。
??
??根據這個思路，可以得到如下的AC代碼。
題一Java解答：
public class Solution {
public void nextPermutation(int[] nums) {
int len = nums.length;
if (len<2) return ;
int[] res = new int [len];
/* 從倒數第二個元素開始，從后向前，找到第一個滿足(后元素>前元素)的情況
* 此時，記錄前元素下標k，則[k+1,n-1]為一個單調非增子序列
* 那么，這里只需要將一個比nums[k]大的最小數與nums[k]交換
*/
int lastEle = nums[len-1];
int k = len-2;
for (; k>=0; k--){
if (lastEle > nums[k]) break;
else {
lastEle = nums[k];
continue;
}
}
// 當前排列為最大排列，逆序之
if (k<0) {
for (int i=0; i<(len+1)/2; i++) {
swap(nums, i, len-1-i);
}
} else {
// 在nums[k+1,n-1]中尋找大于nums[k]的最小數
int index=0;
for (int i=len-1; i>k; i--) {
if (nums[i]>nums[k]) {
swap(nums, i, k);
index=i;
break;
}
}
// index為0，表示當前nums[k]小于其后任意一個數，直接交換k與len-1
if (index==0){
swap(nums, k, len-1);
}
// 將nums[k+1,n-1]逆序
for (int i=k+1; i<(k+len+2)/2; i++) {
swap(nums, i, k+len-i);
}
}
return ;
}
// 交換元素
public void swap(int[] nums, int i, int j){
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
}
無重復數字的全排列數
題二描述：
原題鏈接：46. Permutations
??給定一個無重復數字的序列，返回這些數所能排列出所有序列。
樣例輸入：
[1,2,3]
樣例輸出：
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]
題二解析：
這是很經典的全排列問題，本題的解法很多。因為這里的所有數都是相異的，故筆者采用了交換元素+DFS的方法來求解。
??下面列出我的AC代碼。代碼中附有中文注釋，在此就不再贅述具體步驟。
題二Java解答：
public class Solution {
// 最終返回的結果集
List<List<Integer>> res = new ArrayList<List<Integer>>();
public List<List<Integer>> permute(int[] nums) {
int len = nums.length;
if (len==0||nums==null) return res;
// 采用前后元素交換的辦法，dfs解題
exchange(nums, 0, len);
return res;
}
public void exchange(int[] nums, int i, int len) {
// 將當前數組加到結果集中
if(i==len-1) {
List<Integer> list = new ArrayList<>();
for (int j=0; j<len; j++){
list.add(nums[j]);
}
res.add(list);
return ;
}
// 將當前位置的數跟后面的數交換，并搜索解
for (int j=i; j<len; j++) {
swap(nums, i, j);
exchange(nums, i+1, len);
swap(nums, i, j);
}
}
public void swap(int[] nums, int i, int j) {
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
}
有重復數字的全排列數
題三描述：
原題鏈接：47. Permutations II
??給定一個含有重復數字的序列，返回這些數所能排列出的所有不同的序列。
樣例輸入：
[1,1,2]
樣例輸出：
[
[1,1,2],
[1,2,1],
[2,1,1]
]
題三解析
題意：
本題與題二略有不同，給定的序列中含有重復元素，需要返回這些數所能排列出的所有不同的序列集合。
思路：
這里我們先考慮一下，它與第二題唯一的不同在于：在DFS函數中，做循環遍歷時，如果與當前元素相同的一個元素已經被取用過，則要跳過所有值相同的元素。
??舉個例子：對于序列<1,1,2,3>。在DFS首遍歷時，1 作為首元素被加到list中，并進行后續元素的添加；那么，當DFS跑完第一個分支，遍歷到1 (第二個)時，這個1 不再作為首元素添加到list中，因為1 作為首元素的情況已經在第一個分支中考慮過了。
??為了實現這一剪枝思路，有了如下的解題算法。
解題算法：
1. 先對給定的序列nums進行排序，使得大小相同的元素排在一起。
??2. 新建一個used數組，大小與nums相同，用來標記在本次DFS讀取中，位置i的元素是否已經被添加到list中了。
??3. 根據思路可知，我們選擇跳過一個數，當且僅當這個數與前一個數相等，并且前一個數未被添加到list中。
??根據以上算法，對題二的代碼略做修改，可以得到如下的AC代碼。
??(在處理一般性問題時，建議用此算法，畢竟題二只是特殊情況)
題三Java解答
public class Solution {
List<List<Integer>> res = new ArrayList<List<Integer>>();
public List<List<Integer>> permuteUnique(int[] nums) {
int len = nums.length;
if(len==0||nums==null) return res;
boolean[] used = new boolean[len];
List<Integer> list = new ArrayList<Integer>();
Arrays.sort(nums);
dfs(nums, used, list, len);
return res;
}
public void dfs(int[] nums, boolean[] used, List<Integer> list, int len) {
if(list.size()==len) {
res.add(new ArrayList<Integer>(list));
return ;
}
for (int i=0; i<len; i++) {
// 當前位置的數已經在List中了
if(used[i]) continue;
// 當前元素與其前一個元素值相同 且 前元素未被加到list中，跳過該元素
if(i>0 && nums[i]==nums[i-1] && !used[i-1]) continue;
// 深度優先搜索遍歷
used[i]=true;
list.add(nums[i]);
dfs(nums, used, list, len);
list.remove(list.size()-1);
used[i]=false;
}
}
}
取特定位置的全排列字符串
題四描述：
原題鏈接：60. Permutation Sequence
??給定正整數n和k，要求返回在[1,2,...,n]所有的全排列中，第k大的字符串序列。
樣例輸入：
3 4
樣例輸出：
"231"
題四解析：
思路：
這里我們先考慮一個特殊情況，當n=4時，序列為[1,2,3,4]，有以下幾種情況：
??"1+(2,3,4)的全排列"
??"2+(1,3,4)的全排列"
??"3+(1,2,4)的全排列"
??"4+(1,2,3)的全排列"
??我們已經知道，對于n個數的全排列，有n!種情況。所以，3個數的全排列就有6種情況。
??
??如果我們這里給定的k為14，那么它將會出現在：
????"3+(1,2,4)的全排列"
??這一情況中。
我們可以程式化地得到這個結果：取k=13(從0開始計數)，(n-1)!=3!=6，k/(n-1)!=2，而3在有序序列[1,2,3,4]中的索引就是2。
??同理，我們繼續計算，新的k=13%6=1，新的n=3，那么1/(n-1)!=2/2=0。在序列[1,2,4]中，索引0的數是1。那么，此時的字符串為"31"。
??繼續迭代，新的k=1%2=1，新的n=2，那么k/(n-1)!=1/1=1。在序列[2,4]中，索引為1的數是4。那么，此時的字符串為"314"。最后在串尾添上僅剩的2，可以得到字符串"3142"。
??經過驗算，此串確實是序列[1,2,3,4]的全排列數中第14大的序列。
解題算法：
1. 創建一個長度為n 的數組array，存放對應下標n的階乘值。
??2. 再新建一個長度為n 的數組nums，初始值為nums[i]=i+1，用來存放待選的字符序列。
??3. 將得到的k減1后，開始迭代。迭代的規則是：迭代n次，每次選nums數組中下標為k/(n-1)!的數放在字符串的末尾，新的k=k%(n-1)!，新的n=n-1。
??4. 最后，返回得到的字符串。
??根據以上算法，可以得到如下的AC代碼。
題四Java解答：
public class Solution {
public String getPermutation(int n, int k) {
StringBuilder sb = new StringBuilder();
int[] array = new int[n+1];
int sum = 1;
array[0] = 1;
// array[] = [1, 1, 2, 6, 24, ... , n!]
for (int i=1; i<=n; i++){
sum *= i;
array[i] = sum;
}
// nums[] = [1, 2, 3, ... n]
List<Integer> nums = new LinkedList<>();
for (int i=0; i<n; i++){
nums.add(i+1);
}
k--;
for (int i=1; i<=n; i++){
int index = k / array[n-i];
sb.append("" + nums.get(index));
nums.remove(index);
k = k % array[n-i];
}
return sb.toString();
}
}
行文倉促，文中如有不足或不當之處，歡迎拍磚指正。轉載請注明出處。
