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]
.
Two Approach:
Solution_1: Recursion+DFS.
Idea:
To be clear, the permutation problem is belong to NP problem which means
the time complexity is will not consider to be polynomial time
Solve by method of recursion:
1.Define a new array "visited[num.length]" to keep track the which element of
the original array has been visited, thus to ensure only the remaining elements
will be processed.
Ex: array[0]=1, then set visited[0]=true, so there are only 2,3 can be
process for array[1];
2.remove the last elements from the array, and resume the visited flag in order
to process next possible permutation.
Ex: we have [1,2,3], remove element on index 2, As a result, array will be
[1,2] and visited[2]=false => will be un-flag.
public class Solution {
public ArrayList<ArrayList<Integer>> permute(int[] num) {
ArrayList<ArrayList<Integer>> result=new ArrayList<ArrayList<Integer>>();
if(num.length==0) return result;
helperDFS(num, new boolean[num.length],result,new ArrayList<Integer>());
return result;
}
private static void helperDFS(int[] num,boolean[] visited,ArrayList<ArrayList<Integer>> result, ArrayList<Integer> sub){
//new permutation was found
if(num.length==sub.size()){
result.add(new ArrayList<Integer>(sub));
return;
}
for(int i=0;i<num.length;i++){
if(visited[i]==false){
//flag num[i] has been visited
visited[i]=true;
sub.add(num[i]);
helperDFS(num,visited,result,sub);
//remove the last number after completed a permutation
sub.remove(sub.size()-1);
visited[i]=false;
}
}
}
}