class Solution(object):
def permute(self, nums):
"""
:type nums: List[int]
:rtype: List[List[int]]
"""
res = [];
self.backtracking(nums, [], res);
return res;
def backtracking(self, nums, temp, res):
if len(nums) == 0:
return res.append(temp);
for i in range(len(nums)):
self.backtracking(nums[:i] + nums[i+1:] , temp + [nums[i]], res);
public class Solution {
public List<List<Integer>> permute(int[] nums) {
List<List<Integer>> res = new ArrayList<>();
dfs(nums, res, 0);
return res;
}
private void dfs(int[] nums, List<List<Integer>> res, int start) {
if (start == nums.length) {
List<Integer> list = new ArrayList<>();
for (int i = 0; i < nums.length; i++) {
list.add(nums[i]);
}
res.add(list);
return;
}
for (int i = start; i < nums.length; i++) {
swap(nums, i, start);
dfs(nums, res, start + 1);
swap(nums, i, start);
}
}
private void swap(int[] nums, int i, int j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
}
public class Solution {
public List<List<Integer>> permute(int[] nums) {
List<List<Integer>> res = new ArrayList<List<Integer>>();
List<Integer> temp = new ArrayList<Integer>();
backtracking(nums, temp, res);
return res;
}
private void backtracking(int[] nums, List<Integer> temp, List<List<Integer>> res) {
if(temp.size() == nums.length) {
res.add(new ArrayList<Integer>(temp));
return;
}
for(int num : nums) {
if(temp.contains(num)) continue;
temp.add(num);
backtracking(nums, temp, res);
temp.remove(temp.size() - 1);
}
}
}
public class Solution {
public List<List<Integer>> permute(int[] num) {
LinkedList<List<Integer>> res = new LinkedList<List<Integer>>();
res.add(new ArrayList<Integer>());
for (int n : num) {
int size = res.size();
for (; size > 0; size--) {
List<Integer> r = res.pollFirst();
for (int i = 0; i <= r.size(); i++) {
List<Integer> t = new ArrayList<Integer>(r);
t.add(i, n);
res.add(t);
}
}
}
return res;
}
}