Leetcode47 Permutations II

Permutations II

Given a collection of numbers that might contain duplicates, return all possible unique permutations.

For example,

[1,1,2] have the following unique permutations:

[1,1,2], [1,2,1], and [2,1,1].

Solution1

回溯法解决，但是要注意本轮循环要跳过已经使用过的重复的数字。

import java.util.List;
import java.util.ArrayList;
import java.util.HashSet;
public class Solution {
public List<List<Integer>> permuteUnique(int[] nums) {
List<List<Integer>> result = new ArrayList<List<Integer>>();
if(nums.length==0) return result;
List<Integer> temp = new ArrayList<Integer>();
HashSet<Integer> used = new HashSet<Integer>();
help(nums,used,temp,result);
return result;
}
public void help(int[] nums,HashSet<Integer> used,List<Integer>temp,List<List<Integer>>result){
if(temp.size()==nums.length){
result.add(temp);
return;
}
HashSet<Integer> duplicate = new HashSet<Integer>();
for(int i=0;i<nums.length;i++){
if(used.contains(i)) continue;//如果这个位置上的数已经被用过了，则往下再搜寻
if(duplicate.contains(nums[i])) continue;//重复的数，在本次位置上不能再使用
HashSet<Integer> usedTemp = new HashSet<Integer>(used);
usedTemp.add(i);//这里是存储下标
duplicate.add(nums[i]);//这里是存储数值
List<Integer> temp1 = new ArrayList<Integer>(temp);
temp1.add(nums[i]);
help(nums,usedTemp,temp1,result);
}
}
}

Solution2

另一种类型的回溯。

public class Solution {
public List<List<Integer>> permuteUnique(int[] nums) {
List<List<Integer>> result = new ArrayList<List<Integer>>();
//Arrays.sort(nums);
permuteUnique2(nums,0,result);
return result;
}
public void permuteUnique2(int[] nums,int start,List<List<Integer>> result){
if(start>=nums.length){
List<Integer> item = new ArrayList<Integer>();
for(int num:nums) item.add(num);
result.add(item);
return;
}
HashSet<Integer> used = new HashSet<Integer>();
for(int i=start;i<nums.length;i++){
if(used.contains(nums[i])) continue;
int temp = nums[i];
nums[i] = nums[start];
nums[start] = temp;
used.add(nums[start]);
permuteUnique2(nums,start+1,result);
nums[start] = nums[i];
nums[i] = temp;
}
}
}

Solution3

和Leetcode46 Permutations中的解法4一样，这里仍然可以用插入法来求解，但是要复杂得多。这里插入数的时候不是以单个数为单位，而是以所有重复的数字为单位。

public class Solution {
public List<List<Integer>> permuteUnique(int[] nums) {
List<List<Integer>> result = new ArrayList<List<Integer>>();
result.add(new ArrayList<Integer>());
Arrays.sort(nums);
for(int i=0;i<nums.length;i++){
int count = 1;
for(;i+1<nums.length&&nums[i+1]==nums[i];i++,count++);//统计重复的数字个数
int size = result.size();
for(int j=0;j<size;j++) insert(result.get(j),count,nums[i],result);
while(size-->0) result.remove(0);
}
return result;
}
public void insert(List<Integer> item,int count,int num,List<List<Integer>> result){//将重复的数字插入已有的结果中
Stack<Integer> stack = new Stack<Integer>();
while(true){
for(int index=stack.empty()?0:stack.peek()+1;count>0;index++,count--){//插入
stack.push(index);
item.add(index,num);
}
result.add(new ArrayList<Integer>(item));
int i = stack.pop();
item.remove(i);
count++;
for(;i==item.size();count++){//回溯
if(stack.empty()) return;
i = stack.pop();
item.remove(i);
}
stack.push(i+1);//回溯成功后往后挪一个位置再插入
item.add(i+1,num);
count--;
}
}
}

思路较复杂，不推荐此算法。

Solution4

这里借鉴 Leetcode31 Next Permutation的思路来求解本题。

public class Solution {
public List<List<Integer>> permuteUnique(int[] nums) {
List<List<Integer>> result = new ArrayList<List<Integer>>();
Arrays.sort(nums);
while(true){
List<Integer> item = new ArrayList<Integer>();
for(int num:nums) item.add(num);
result.add(item);
int i,j;
for(i=nums.length-1;i>0;i--) if(nums[i-1]<nums[i]) break;
if(i<=0) break;
for(j=nums.length-1;j>0;j--) if(nums[j]>nums[i-1]) break;
int temp = nums[j];
nums[j] = nums[i-1];
nums[i-1] = temp;
for(j = nums.length-1;i<j;i++,j--){
temp = nums[j];
nums[j] = nums[i];
nums[i] = temp;
}
}
return result;
}
}

思路清晰易懂，并且还复用性还非常高。不管是有重复数字还是没有重复数字都可以用这种方法求解。所以比回溯法更值得推荐。