- 全排列
- 帶重復元素的排列
- 下一個排列
- 上一個排列
- 第 k 個排列
- 排列序號
- 排列序號II
全排列
給定一個數字列表，返回其所有可能的排列。
注意事項
你可以假設沒有重復數字。
樣例
給出一個列表[1,2,3]，其全排列為：
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]
分析
可以用遞歸和非遞歸解決
首先遞歸法，也是利用了回溯法和深度優先搜索。
我們考慮一個一個將數組元素加入到排列中，遞歸求解，就好像下面的解答樹：
添加的時候排除掉相同的元素即可，回溯法我們經常會設置一個已訪問標識數組，來表示數組被訪問過，但這里不用這樣，因為如果list里面已經包含就說明已經訪問過了，所以只要判斷，跳過已有的元素即可。
再考慮遞歸的結束條件，當元素都添加足夠就結束了，添加足夠的意思就是，元素個數等于數組的長度。
class Solution {
/**
* @param nums: A list of integers.
* @return: A list of permutations.
*/
public List<List<Integer>> permute(int[] nums) {
List<List<Integer>> res = new ArrayList<>();
if(nums == null)
return res;
if(nums.length == 0)
{
res.add(new ArrayList<Integer>());
return res;
}
ArrayList<Integer> list = new ArrayList<>();
dfs(res, list, nums);
return res;
}
private void dfs(List<List<Integer>> res, ArrayList<Integer> list, int[] nums) {
int n = nums.length;
if(list.size() == n)
{
res.add(new ArrayList<Integer>(list));
return;
}
for(int i = 0;i < n;i++) {
if(list.contains(nums[i]))
continue;
list.add(nums[i]);
dfs(res, list, nums);
list.remove(list.size() - 1);
}
}
}
非遞歸實現
思路是這樣的，就是高中的排列組合知識，運用插入法即可，假設有i個元素的排列組合，那么對于i+1個元素，可以考慮就是將i+1的元素插入到上述的排列的每一個位置即可。
class Solution {
/**
* @param nums: A list of integers.
* @return: A list of permutations.
*/
public List<List<Integer>> permute(int[] nums) {
List<List<Integer>> res = new ArrayList<List<Integer>>();
if ( nums == null)
return res;
if( nums.length == 0)
{
res.add(new ArrayList<Integer>());
return res;
}
List<Integer> list = new ArrayList<>();
list.add(nums[0]);
res.add(new ArrayList<Integer>(list));
for(int i=1;i<nums.length;i++) {
int size1 = res.size();
for(int j=0;j<size1;j++) {
int size2 = res.get(0).size();
for(int k=0;k<=size2;k++) {
ArrayList<Integer> temp = new ArrayList<>(res.get(0));
temp.add(k,nums[i]);
res.add(temp);
}
res.remove(0);
}
}
return res;
}
}
帶重復元素的全排列
給出一個具有重復數字的列表，找出列表所有不同的排列。
樣例
給出列表 [1,2,2]，不同的排列有：
代碼
class Solution {
/**
* @param nums: A list of integers.
* @return: A list of unique permutations.
*/
public List<List<Integer>> permuteUnique(int[] nums) {
ArrayList<List<Integer>> res = new ArrayList<>();
if(nums == null)
return null;
if(nums.length == 0)
{
res.add(new ArrayList<Integer>());
return res;
}
ArrayList<Integer> list = new ArrayList<>();
//先將數組排序，這樣相同元素將會出現在一起
Arrays.sort(nums);
int n = nums.length;
int[] visited = new int[n];
for(int i=0;i<n;i++)
visited[i] = 0;//0標識未訪問
helper(res, list, visited, nums);
return res;
}
private void helper(ArrayList<List<Integer>> res, ArrayList<Integer> list, int[] visited, int[] nums) {
if(nums.length == list.size()) {
res.add( new ArrayList<Integer>(list));
}
for(int i=0;i<nums.length;i++) {
if(visited[i] == 1 || i!= 0 && (visited[i-1] == 0 && nums[i] == nums[i-1]))
continue;
/*
上面的判斷主要是為了去除重復元素影響。
比如，給出一個排好序的數組，[1,2,2]，那么第一個2和第二2如果在結果中互換位置，
我們也認為是同一種方案，所以我們強制要求相同的數字，原來排在前面的，在結果
當中也應該排在前面，這樣就保證了唯一性。所以當前面的2還沒有使用的時候，就
不應該讓后面的2使用。
*/
list.add(nums[i]);
visited[i] = 1;
helper(res, list, visited, nums);
list.remove(list.size()-1);
visited[i] = 0;
}
}
}
下一個排列
給定一個若干整數的排列，給出按正數大小進行字典序從小到大排序后的下一個排列。
如果沒有下一個排列，則輸出字典序最小的序列。
樣例
左邊是原始排列，右邊是對應的下一個排列。
1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1
分析
這道題讓我們求下一個排列順序，有題目中給的例子可以看出來，如果給定數組是降序，則說明是全排列的最后一種情況，則下一個排列就是最初始情況，可以參見之前的博客 Permutations 全排列。我們再來看下面一個例子，有如下的一個數組
1 2 7 4 3 1
下一個排列為：
1 3 1 2 4 7
那么是如何得到的呢，我們通過觀察原數組可以發現，如果從末尾往前看，數字逐漸變大，到了2時才減小的，然后我們再從后往前找第一個比2大的數字，是3，那么我們交換2和3，再把此時3后面的所有數字轉置一下即可，步驟如下：
1 2 7 4 3 1
1 2 7 4 3 1
1 3 7 4 2 1
1 3 1 2 4 7
所以我們要做的就是找到第一個比peak元素大的數字，交換，然后反轉
public class Solution {
/**
* @param nums: an array of integers
* @return: return nothing (void), do not return anything, modify nums in-place instead
*/
public int[] nextPermutation(int[] nums) {
int i = nums.length - 2;
while (i >= 0 && nums[i + 1] <= nums[i]) {
i--;
}
if (i >= 0) {
int j = nums.length - 1;
while (j >= 0 && nums[j] <= nums[i]) {
j--;
}
swap(nums, i, j);
}
reverse(nums, i + 1);
return nums;
}
private void reverse(int[] nums, int start) {
int i = start, j = nums.length - 1;
while (i < j) {
swap(nums, i, j);
i++;
j--;
}
}
private void swap(int[] nums, int i, int j) {
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
}
上一個排列
給定一個整數數組來表示排列，找出其上一個排列。
注意事項
排列中可能包含重復的整數
樣例
給出排列[1,3,2,3]，其上一個排列是[1,2,3,3]
給出排列[1,2,3,4]，其上一個排列是[4,3,2,1]
分析
與求下一個排列是一樣的方法，只是相應的操作變反即可
public class Solution {
/**
* @param nums: A list of integers
* @return: A list of integers that's previous permuation
*/
public void swapItem(ArrayList<Integer> nums, int i, int j) {
Integer tmp = nums.get(i);
nums.set(i, nums.get(j));
nums.set(j, tmp);
}
public void swapList(ArrayList<Integer> nums, int i, int j) {
while ( i < j) {
swapItem(nums, i, j);
i ++; j --;
}
}
public ArrayList<Integer> previousPermuation(ArrayList<Integer> nums) {
int len = nums.size();
if ( len <= 1)
return nums;
int i = len - 1;
while ( i > 0 && nums.get(i) >= nums.get(i-1) )
i --;
swapList(nums, i, len - 1);
if ( i != 0) {
int j = i;
while ( nums.get(j) >= nums.get(i-1) ) j++;
swapItem(nums, j, i-1);
}
return nums;
}
}
第k個排列
給定 n 和 k，求123..n組成的排列中的第 k 個排列。
注意事項
1 ≤ n ≤ 9
樣例
對于 n = 3, 所有的排列如下：
123
132
213
231
312
321
如果 k = 4, 第4個排列為，231.
分析
康托展開的公式：（不用記，看形勢就行，下面會有例子）
X=an(n-1)!+an-1(n-2)!+...+ai(i-1)!+...+a21!+a1*0!
ai為整數，并且0<=ai<i(1<=i<=n)
適用范圍：沒有重復元素的全排列
N個數的第k個排序，例子，1，2，3，4共有4！種排列，1234,1243,1324等等。按順序應該是
1234
1243
1324
1342
1423
1432等等
可以通過STL中next_permutation（begin, end）;來算下一個全排列，理論上你要算n個數的第k個排列只要調用k-1次next_permutation()就行，但是一般來說肯定會超時的，因為next_permutation的時間復雜度是O(n)（如果自己寫出來next_permutation時間復雜度比n大就要注意了，其中一個容易疏忽的地方是最后排序可以用reverse而不是sort）。所以如果用這個的話時間復雜度是O(N^2)。
而用康托展開只要O(n)就行，下面來說說具體怎么做:
題目：找出第16個n = 5的序列（12345）
首先第十六個也就是要前面有15個數，要調用15次next_permutation函數。
根據第一行的那個全排列公式，15 / 4! = 0 …15 =》 有0個數比他小的數是1，所以第一位是1
拿走剛才的余數15，用15 / 3! = 2 …3 => 剩下的數里有兩個數比他小的是4（1已經沒了），所以第二位是4
拿走余數3， 用 3 / 2! = 1 …1 =》 剩下的數里有一個數比他小的是3，所以第三位是3
拿走余數1， 用 1/ 1! = 1 …0 => 剩下的數里有一個數比他小的是 5（只剩2和5了），所以第四位是5
所以排列是 1,4,3,5,2
class Solution {
/**
* @param n: n
* @param k: the kth permutation
* @return: return the k-th permutation
*/
public String getPermutation(int n, int k) {
StringBuilder sb = new StringBuilder();
boolean[] used = new boolean[n];
k = k - 1;
int factor = 1;
for (int i = 1; i < n; i++) {
factor *= i;
}
for (int i = 0; i < n; i++) {
int index = k / factor;
k = k % factor;
for (int j = 0; j < n; j++) {
if (used[j] == false) {
if (index == 0) {
used[j] = true;
sb.append((char) ('0' + j + 1));
break;
} else {
index--;
}
}
}
if (i < n - 1) {
factor = factor / (n - 1 - i);
}
}
return sb.toString();
}
}
排列序號
給出一個不含重復數字的排列，求這些數字的所有排列按字典序排序后該排列的編號。其中，編號從1開始。
樣例
例如，排列 [1,2,4] 是第 1 個排列。
分析
這道題是求第k個排列的反向思維
已知是n = 5，求14352是它的第幾個序列？（同一道題）
用剛才的那道題的反向思維：
第一位是1，有0個數小于1，即0* 4！
第二位是4，有2個數小于4，即2* 3！
第三位是3，有1個數小于3，即1* 2！
第四位是5，有1個數小于5，即1* 1！
第五位是2，不過不用算，因為肯定是0
所以14352是 n = 5的第 0 + 12 + 2 + 1 + 0 = 15 + 1（求的是第幾個，所以要加一） = 16
第16個，跟剛才那道題一樣，證明對了
public class Solution {
/**
* @param A an integer array
* @return a long integer
*/
public long permutationIndex(int[] A) {
// Write your code here
HashMap<Integer, Integer> hash = new HashMap<Integer, Integer>();
for (int i = 0; i < A.length; i++) {
if (hash.containsKey(A[i]))
hash.put(A[i], hash.get(A[i]) + 1);
else {
hash.put(A[i], 1);
}
}
long ans = 0;
for (int i = 0; i < A.length; i++) {
for (int j = i + 1; j < A.length; j++) {
if (A[j] < A[i]) {
hash.put(A[j], hash.get(A[j])-1);
ans += generateNum(hash);
hash.put(A[j], hash.get(A[j])+1);
}
}
hash.put(A[i], hash.get(A[i])-1);
}
return ans+1;
}
long fac(int numerator) {
long now = 1;
for (int i = 1; i <= numerator; i++) {
now *= (long) i;
}
return now;
}
long generateNum(HashMap<Integer, Integer> hash) {
long denominator = 1;
int sum = 0;
for (int val : hash.values()) {
if(val == 0 )
continue;
denominator *= fac(val);
sum += val;
}
if(sum==0) {
return sum;
}
return fac(sum) / denominator;
}
}
排列序號II
給出一個可能包含重復數字的排列，求這些數字的所有排列按字典序排序后該排列在其中的編號。編號從1開始。
樣例
給出排列[1, 4, 2, 2]，其編號為3。
分析
這道題基于查找不存在重復元素中排列序號的基礎之上，
即P(n) = P(n-1)+C(n-1)
C(n-1) = (首元素為小于當前元素，之后的全排列值)
P(1) = 1;
而不存在重復元素的全排列值C(n-1) = (n-1)!*k(k為首元素之后小于當前元素的個數)
在存在重復元素的排列中首先全排列的值的求法變為：
C(n-1) = (n-1)!/(A1!A2!···Aj!)k(其中Ai 為重復元素的個數，k為小于首元素前不重復的個數)
/**
* @param A an integer array
* @return a long integer
*/
long fac(int numerator) {
long now = 1;
for (int i = 1; i <= numerator; i++) {
now *= (long) i;
}
return now;
}
long generateNum(HashMap<Integer, Integer> hash) {
long denominator = 1;
int sum = 0;
for (int val : hash.values()) {
if(val == 0 )
continue;
denominator *= fac(val);
sum += val;
}
if(sum==0) {
return sum;
}
return fac(sum) / denominator;
}
public long permutationIndexII(int[] A) {
HashMap<Integer, Integer> hash = new HashMap<Integer, Integer>();
for (int i = 0; i < A.length; i++) {
if (hash.containsKey(A[i]))
hash.put(A[i], hash.get(A[i]) + 1);
else {
hash.put(A[i], 1);
}
}
long ans = 0;
for (int i = 0; i < A.length; i++) {
HashMap<Integer, Integer> flag = new HashMap<Integer, Integer>();
for (int j = i + 1; j < A.length; j++) {
if (A[j] < A[i] && !flag.containsKey(A[j])) {
flag.put(A[j], 1);
hash.put(A[j], hash.get(A[j])-1);
ans += generateNum(hash);
hash.put(A[j], hash.get(A[j])+1);
}
}
hash.put(A[i], hash.get(A[i])-1);
}
return ans + 1;
}
