Permutations I
Given a collection of numbers, return all possible permutations.
For example, [1,2,3] have the following permutations: [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], and [3,2,1].
交换法
复杂度
时间 O(N^2) 空间 O(N) 递归栈
思路
置换实际上是给出所有的排列方式,同样是用深度优先搜索,不过为了避免重复选择的情况,我们要保证两点:第一,所有数必须是数组中的,第二,数组中每个数只能用不多于也不少于一次。如果我们要单独写一个函数,来判断下一轮搜索该选择哪一个数就很麻烦了。这里有一个技巧,我们可以只将数两两交换,不过交换时只能跟自己后面的交换。
代码
public class Solution {
List<List<Integer>> res;
public List<List<Integer>> permute(int[] nums) {
res = new LinkedList<List<Integer>>();
helper(nums, 0);
return res;
}
public void helper(int[] nums, int i){
// 找到转置完成后的解,将其存入列表中
if(i == nums.length - 1){
List<Integer> list = new LinkedList<Integer>();
for(int j = 0; j < nums.length; j++){
list.add(nums[j]);
}
res.add(list);
}
// 将当前位置的数跟后面的数交换,并搜索解
for(int j = i; j < nums.length; j++){
swap(nums, i , j);
helper(nums, i + 1);
swap(nums, i, j);
}
}
private void swap(int[] nums, int i, int j){
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
}
深度优先搜索
复杂度
时间 O(N) 空间 O(N) 递归栈
思路
我们还可以简单的使用深度优先搜索来解决这题。每一轮搜索选择一个数加入列表中,同时我们还要维护一个全局的布尔数组,来标记哪些元素已经被加入列表了,这样在下一轮搜索中要跳过这些元素。
代码
public class Solution {
List<List<Integer>> res;
boolean[] used;
public List<List<Integer>> permute(int[] nums) {
res = new LinkedList<List<Integer>>();
used = new boolean[nums.length];
List<Integer> tmp = new LinkedList<Integer>();
helper(nums, tmp);
return res;
}
private void helper(int[] nums, List<Integer> tmp){
if(tmp.size() == nums.length){
List<Integer> list = new LinkedList<Integer>(tmp);
res.add(list);
} else {
for(int idx = 0; idx < nums.length; idx++){
// 遇到已经加过的元素就跳过
if(used[idx]){
continue;
}
// 加入该元素后继续搜索
used[idx] = true;
tmp.add(nums[idx]);
helper(nums, tmp);
tmp.remove(tmp.size()-1);
used[idx] = false;
}
}
}
}
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].
深度优先搜索
复杂度
时间 O(N) 空间 O(N) 递归栈
思路
这题和上题的深度优先搜索很相似,区别在于:1、要先将数组排序,确保重复的元素是在一起的。2、除了不能加入之前出现过的元素之外,还不能加入本轮搜索中出现过的元素。如何判断哪些元素本轮出现过呢?我们加过一个数字并搜索后,在这一轮中把剩余的重复数字都跳过就行了,保证每一轮只有一个unique的数字出现。这和Combination Sum II中跳过重复元素的方法是一样的,注意要判断nums[i] == nums[i + 1]
,因为for循环结束时i还会额外加1,我们要把i留在最后一个重复元素处。
代码
public class Solution {
List<List<Integer>> res;
boolean[] used;
public List<List<Integer>> permuteUnique(int[] nums) {
res = new LinkedList<List<Integer>>();
used = new boolean[nums.length];
Arrays.sort(nums);
List<Integer> tmp = new LinkedList<Integer>();
helper(nums, tmp);
return res;
}
private void helper(int[] nums, List<Integer> tmp){
if(tmp.size() == nums.length){
List<Integer> list = new LinkedList<Integer>(tmp);
res.add(list);
} else {
for(int idx = 0; idx < nums.length; idx++){
// 遇到已经加过的元素就跳过
if(used[idx]){
continue;
}
// 加入该元素后继续搜索
used[idx] = true;
tmp.add(nums[idx]);
helper(nums, tmp);
tmp.remove(tmp.size()-1);
used[idx] = false;
// 跳过本轮的重复元素,确保每一轮只会加unique的数字
while(idx < nums.length - 1 && nums[idx] == nums[idx + 1]){
idx++;
}
}
}
}
}
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用
。你还可以使用@
来通知其他用户。