46, 47. Permutations | & II

Given a collection of distinct 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],
  [3,2,1]
]

分析：

当array里没有重复数的时候，要找出所有的排列，我们可以把每个数放在第一位，然后获得后面的数排列。利用递归原理，为了获得后面的数的排列，把剩余的数都逐个放在第二位，，，，直到一个新的数组填满。

public class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> list = new ArrayList<List<Integer>>();
        permutation(nums, 0, nums.length, list);
        return list;
    }

    void permutation(int[] arr, int index, int size, List<List<Integer>> list) {
        if (index == size) { //填满了
            addToList(arr, list);
            return;
        } 
        for (int i = index; i < size; i++) {
            swap(arr, i, index); // 把每个数都放在当前数组的“第一位”
            permutation(arr, index + 1, size, list); //获得后面的数的排列
            swap(arr, i, index);
        }
    }
    
    void addToList(int[] arr, List<List<Integer>> list) {
        ArrayList<Integer> temp = new ArrayList<Integer>();
        for (int i : arr) {
            temp.add(i);
        }
        list.add(temp);
    }
    
    void swap(int[] arr, int idx1, int idx2) {
        int temp = arr[idx1];
        arr[idx1] = arr[idx2];
        arr[idx2] = temp;
    }
}

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],
  [2,1,1]
]

分析：

在这个问题里，因为有了重复数字的出现，所以，当把每个数字放在当前数组的第一位的时候，我们需要确保没有重复，我们可以用hashset来check是否重复。

public class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> list = new ArrayList<List<Integer>>();
        Arrays.sort(nums);
        permutation(nums, 0, nums.length, list);
        return list;
    }

    void permutation(int[] arr, int index, int size, List<List<Integer>> list) {
        if (index == size) {
            addToList(arr, list);
            return;
        } 
        // when swaping arr[i] with arr[index], we need to make sure the uniqueness of arr[i],
        // otherwise, we will have duplicates.
        HashSet<Integer> set = new HashSet<Integer>();
        for (int i = index; i < size; i++) {
            if (!set.contains(arr[i])) {
                set.add(arr[i]);
                swap(arr, i, index);
                permutation(arr, index + 1, size, list);
                swap(arr, i, index);
            }
        }
    }
    
    void swap(int[] arr, int idx1, int idx2) {
        int temp = arr[idx1];
        arr[idx1] = arr[idx2];
        arr[idx2] = temp;
    }

    void addToList(int[] arr, List<List<Integer>> list) {
        ArrayList<Integer> temp = new ArrayList<Integer>();
        for (int i : arr) {
            temp.add(i);
        }
        list.add(temp);
    }
}

参考请注明出处：cnblogs.com/beiyeqingteng