***[Lintcode]Permutations II 带重复元素的排列 递归/非递归解法

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

Example

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

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

分析：可以使用递归。设置一个index，每一次index和index之后的每一个元素位置交换。注意从index自己开始。然后index+1寻找下一个位置的可能的排列方式。

一个问题是哪里放验重的代码。在递归方法里，因为是针对index位置考虑每一种可能性，所以在index与其之后元素交换时，可以进行去重检验。

函数void helper(int[] nums, int index, List<List<Integer>> res)的目的是：对于给定数组的index位置，尝试每一种可能性。

class Solution {
    /**
     * @param nums: A list of integers.
     * @return: A list of unique permutations.
     */
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();

        helper(nums, 0, res);
        return res;
    }
    
    boolean exist(int[] nums, int start, int end, int target) {
        for(int i = start; i < end; i++) {
            if(nums[i] == target) return true;
        }
        return false;
    }
    
    void helper(int[] nums, int index, List<List<Integer>> res) {
        if(index >= nums.length) {
            List<Integer> list = new ArrayList<Integer>();
            for(int i = 0; i < nums.length; i++) list.add(nums[i]);
            res.add(list);
            return;
        }
        for(int i = index; i < nums.length; i++) {
            if(exist(nums, index, i, nums[i])) continue;
            swap(nums, i , index);
            helper(nums, index + 1, res);
            swap(nums, i , index);
            
        }    
    }
    
    void swap(int[] nums, int i, int j) {
        if(i == j) return;
        else {
            int tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
        }
    }

}

<p>
</p>

另外也可以使用boolean数组标记已经选过的数字。注意去重的条件。

class Solution {
    /**
     * @param nums: A list of integers.
     * @return: A list of unique permutations.
     */
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> ret = new ArrayList<>();
        if (nums == null || nums.length == 0) {
            ret.add(new ArrayList<Integer>());
            return ret;
        }
        
        Arrays.sort(nums);
        boolean[] used = new boolean[nums.length];
        
        permuteHelper(nums, 0, ret, used, new ArrayList<Integer>());
        
        return ret;
    }
    
    private void permuteHelper(int[] nums, int len, List<List<Integer>> ret, boolean[] used, List<Integer> curr) {
        if (len == nums.length) {
            ret.add(new ArrayList<Integer>(curr));
            return;
        }
        
        for (int i = 0; i < nums.length; i++) {
            if (!used[i]) {
                if (i > 0 && nums[i] == nums[i - 1] && used[i - 1]) {//重要
                    continue;
                }
                used[i] = true;
                curr.add(nums[i]);
                permuteHelper(nums, len + 1, ret, used, curr);
                curr.remove(curr.size() - 1);
                used[i] = false;
            }
        }
    }

}

另外可以使用一些容器，如HashMap进行去重。<number,appearance>

非递归方法则要使用一个额外的List。对结果list中的每一个list，给定位置i，swap所有可能的i值。新的排列会加入结果list中。

class Solution {
    /**
     * @param nums: A list of integers.
     * @return: A list of unique permutations.
     */
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        List<List<Integer>> next = new ArrayList<List<Integer>>();
        List<Integer> list = new ArrayList<Integer>();
        for(int i = 0; i < nums.length; i++) list.add(nums[i]);//先加入种子序列
        res.add(list);
        
        for(int i = 0; i < nums.length; i++) {
            for(int j = 0; j < res.size(); j++) {
                List<Integer> tmp = res.get(j);
                boolean[] visit = new boolean[nums.length];
                for(int k = i + 1; k < tmp.size(); k++) {//每次从i+1位置开始置换。避免重复
                    if(exist(tmp, visit, tmp.get(k)) || visit[k] || tmp.get(k) == tmp.get(i)) continue;
                    swap(tmp, i, k);
                    next.add(new ArrayList<Integer>(tmp));
                    swap(tmp, i, k);
                    visit[k] = true;
                }
            }
            res.addAll(next);
            next.clear();
        }
        return res;
    }
    
    void swap(List<Integer> list, int i, int j) {
        int tmp = list.get(i);
        list.set(i, list.get(j));
        list.set(j, tmp);
    }
    
    boolean exist(List<Integer> list, boolean[] visit, int target) {
        for(int i = 0; i < list.size(); i++) {
            if(visit[i] && list.get(i) == target) return true;
        }
        return false;
    }

}