[LintCode] Permutations II

Given a list of numbers with duplicate number in it. Find all unique permutations.

Have you met this question in a real interview? 

Yes

Example

For numbers [1,2,2] the unique permutations are:

[
  [1,2,2],
  [2,1,2],
  [2,2,1]
]

Challenge 

Using recursion to do it is acceptable. If you can do it without recursion, that would be great!

 

This problem is a follow up of Permutation with an extra condition: there are duplicated numbers in the given list. 

In order to avoid duplicated permuations, we use a "representative selection" principle.

Take [1, 2, 2, 2, 3] as an example,  when the current permutation needs a 2 and there are more than one 2 left in the 

unused numbers pool, if we use the same algorithm with Permuation(no duplicated numbers), we would have duplicated answers.

This is shown as follows.

Say, we've already picked 1 and 2 for the current permutation. {2, 2, 3} are left for further picks. If we need to pick another 2, we can either 

pick the first or second 2 in {2, 2, 3}, both leaving {2, 3} for further picks. These two picks generate duplicated permutations. To avoid this,

we rule that we only pick the first unpicked 2 and skip the case where we pick the second 2 out of {2, 2, 3}. 

 

To achieve this "representative selection" principle, we need to sort the input array first so that all duplicated numbers are adjacent. This way,

when picking duplicated numbers, we can check if its previous duplicated neighbor has been picked or not. If it has, we know this is not a duplicate 

case; If it hasn't, then we know for the same permutations, we could've picked its previous unpicked neighbor as their representative, skip this case.

 

public class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> results = new ArrayList<>();
        if(nums == null || nums.length == 0) {
            results.add(new ArrayList<Integer>());
            return results;
        }
        boolean[] used = new boolean[nums.length];
        for(int i = 0; i < used.length; i++) {
            used[i] = false;
        }
        Arrays.sort(nums);
        permuteUniqueDfs(results, new ArrayList<Integer>(), nums, used);
        return results;
    }
    private void permuteUniqueDfs(List<List<Integer>> results, List<Integer> list,
                                    int[] nums, boolean[] used) {
        if(list.size() == nums.length) {
            results.add(new ArrayList<Integer>(list));
            return;
        }
        for(int i = 0; i < nums.length; i++) {
            if(used[i] || (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false)) {
                continue;
            }
            list.add(nums[i]);
            used[i] = true;
            permuteUniqueDfs(results, list, nums, used);
            list.remove(list.size() - 1);
            used[i] = false;
        }
    }
}

 

Related Problems

Next Permutation II

Permutation Sequence

Next Permutation

Permutations