【LeetCode】Permutations && Permutations II

1、Permutations 
Total Accepted: 6396 Total Submissions: 20594 My Submissions
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].
Discuss
2、Permutations II 
Total Accepted: 4371 Total Submissions: 17520 My Submissions
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].
求所有的排列，一种是不包含重复数据，一种是包含重复数据。
不管是哪种情况，都有两种方法可以处理。
1、最常见的nextPermutation，从原字符串开始，每次求next，一直到结束，就直接break。这个思路很经典，建议动手模拟。也可以参考【LeetCode】Next Permutation
2、DFS，这个也很好理解。每次取数合并。但是这个处理重复数据的时候，需要注意，如果已经处理过了，
就不需要处理了。可以对原字符串或者数组进行排序，那是否有重复就可以判断两个相邻的数据是否相等。
也可以对处理过的数据进行统计，如果已经处理了，就不再处理了。
1、速度比较快的是nextPermutation
   方法1：nextPermutation，没有重复数据，直接处理
   Java AC

public class Solution {
    public ArrayList<ArrayList<Integer>> list;
    public ArrayList<ArrayList<Integer>> permute(int[] num) {
		list = new ArrayList<ArrayList<Integer>>();
		if (num == null || num.length == 0) {
			return list;
		}
		int len = num.length;
		Arrays.sort(num);
		nextpermutation(num,len);
		return list;
	}
    public void nextpermutation(int []num, int len){
        while(true){
            ArrayList<Integer> numList = new ArrayList<Integer>();
            for(int i = 0; i < len; i++){
                numList.add(num[i]);
            }
            list.add(numList);
            int first = getFirst(num, len);
            if(first == -1){
                break;
            }
            int i = len-1;
            for(; i > first; i--){
                if(num[i] > num[first]){
                    break;
                }
            }
            swap(num,i,first);
            reverse(num,first+1,len-1);
        }
    }
    public int getFirst(int []num, int len){
        for(int i = len-2; i >= 0 ; i--){
            if(num[i] < num[i+1]){
                return i;
            }
        }
        return -1;
    }
    public void swap(int []num, int low, int high){
        int temp = num[low];
        num[low] = num[high];
        num[high] = temp;
    }
    public void reverse(int []num, int low, int high){
        while(low < high){
            swap(num, low,high);
            low++;
            high--;
        }
    }
}

方法2：DFS

  Java AC

public class Solution {
    public ArrayList<ArrayList<Integer>> permute(int[] num) {
		ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();
		if (num == null || num.length == 0) {
			return list;
		}
		int len = num.length;
		int visit[] = new int[len];
		ArrayList<Integer> numList = new ArrayList<Integer>();
		dfs(list, numList, num, visit, len);
		return list;
	}

	public void dfs(ArrayList<ArrayList<Integer>> list,
			ArrayList<Integer> numList, int[] num, int[] visit, int len) {
		if (numList.size() == len) {
			list.add(new ArrayList<Integer>(numList));
			return;
		}
		for (int i = 0; i < len; i++) {
			if (visit[i] == 0) {
				visit[i] = 1;
				numList.add(num[i]);
				dfs(list, numList, num, visit, len);
				numList.remove(numList.size()-1);
				visit[i] = 0;
			}
		}
	}
}

2、速度最快的是DFS中的b方法。

   方法1：nextPermutation，有重复数据也没关系，也直接处理

public class Solution {
    public ArrayList<ArrayList<Integer>> list;
    public ArrayList<ArrayList<Integer>> permuteUnique(int[] num) {
		list = new ArrayList<ArrayList<Integer>>();
		if (num == null || num.length == 0) {
			return list;
		}
		int len = num.length;
		Arrays.sort(num);
		nextpermutation(num,len);
		return list;
	}
    public void nextpermutation(int []num, int len){
        while(true){
            ArrayList<Integer> numList = new ArrayList<Integer>();
            for(int i = 0; i < len; i++){
                numList.add(num[i]);
            }
            list.add(numList);
            int first = getFirst(num, len);
            if(first == -1){
                break;
            }
            int i = len-1;
            for(; i > first; i--){
                if(num[i] > num[first]){
                    break;
                }
            }
            swap(num,i,first);
            reverse(num,first+1,len-1);
        }
    }
    public int getFirst(int []num, int len){
        for(int i = len-2; i >= 0 ; i--){
            if(num[i] < num[i+1]){
                return i;
            }
        }
        return -1;
    }
    public void swap(int []num, int low, int high){
        int temp = num[low];
        num[low] = num[high];
        num[high] = temp;
    }
    public void reverse(int []num, int low, int high){
        while(low < high){
            swap(num, low,high);
            low++;
            high--;
        }
    }
}

  方法2：DFS
   a、排序，判断相邻的两个数是否相等，如果相等，就不处理了。
   Java AC

public class Solution {
    public ArrayList<ArrayList<Integer>> permuteUnique(int[] num) {
		ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();
		if (num == null || num.length == 0) {
			return list;
		}
		int len = num.length;
		int visit[] = new int[len];
		ArrayList<Integer> numList = new ArrayList<Integer>();
		Arrays.sort(num);
		dfs(list, numList, num, visit, len);
		return list;
	}

	public void dfs(ArrayList<ArrayList<Integer>> list,
			ArrayList<Integer> numList, int[] num, int[] visit, int len) {
		if (numList.size() == len) {
			list.add(new ArrayList<Integer>(numList));
			return;
		}
		for (int i = 0; i < len; i++) {
			if (visit[i] == 0) {
				visit[i] = 1;
				numList.add(num[i]);
				dfs(list, numList, num, visit, len);
				numList.remove(numList.size()-1);
				visit[i] = 0;
				while (i < len-1 && num[i] == num[i+1]) {
					i++;
				}
			}
		}
	}
}

  b、使用list，判断当前list是否包含当前数，如果包含就不处理了。

   Java AC

public class Solution {
    public ArrayList<ArrayList<Integer>> permuteUnique(int[] num) {
		ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();
		if (num == null || num.length == 0) {
			return list;
		}
		int len = num.length;
		int visit[] = new int[len];
		ArrayList<Integer> numList = new ArrayList<Integer>();
		dfs(list, numList, num, visit, len);
		return list;
	}

	public void dfs(ArrayList<ArrayList<Integer>> list,
			ArrayList<Integer> numList, int[] num, int[] visit, int len) {
		if (numList.size() == len) {
			list.add(new ArrayList<Integer>(numList));
			return;
		}
		List<Integer> usedList = new ArrayList<Integer>();
		for (int i = 0; i < len; i++) {
			if (visit[i] == 0) {
			    if(usedList.contains(num[i])){
			        continue;
			    }else{
			        usedList.add(num[i]);
			    }
				visit[i] = 1;
				numList.add(num[i]);
				dfs(list, numList, num, visit, len);
				numList.remove(numList.size()-1);
				visit[i] = 0;
			}
		}
	}
}