Leetcode 47. Permutations II

原创于 2021-01-21 02:23:23 发布 · 119 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#dfs #backtrack #recursion

Leetcode 专栏收录该内容

278 篇文章

订阅专栏

该博客探讨了两种解决整数数组独特全排列问题的方法。方法1基于回溯，通过排序输入数组并跳过重复元素来避免重复。方法2同样采用回溯，但通过设置集合来跟踪已使用的元素。这两种方法都是对经典全排列问题的优化，适用于需要排除重复排列的情况。

在这里插入图片描述
方法1: 和46题方法2一样，就是多加一个判断条件。

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        if(nums.length == 1){
            List<Integer> ans = new ArrayList<>();
            ans.add(nums[0]);
            res.add(ans);
            return res;
        }
        Arrays.sort(nums);
        for(int i = 0; i < nums.length; i++){
            if(i != 0 && nums[i] == nums[i-1]) continue;
            int curr = nums[i];
            List<List<Integer>> list = permuteUnique(reconstruct(nums, i));
            for(List<Integer> l : list) {
                l.add(0, curr);
                res.add(l);
            } 
        }
        return res;
    }
    
    public int[] reconstruct(int[] nums, int i){
        int[] res = new int[nums.length-1];
        boolean flag = true;
        for(int j = 0; j < res.length; j++){
            if(j != i && flag){
                res[j] = nums[j];
            }else{
                flag = false;
                res[j] = nums[j + 1];
            }
        }
        return res;
    }
}

方法2: 46题的方法1的修改，加了一个set。这个set是相对于recursive level的而不是全局的。

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> nums_list = new ArrayList<>();
        Arrays.sort(nums);
        for(int num : nums) nums_list.add(num);
        int len = nums.length;
        backtrack(len, 0, nums_list, res);
        return res;
    }
    
    public void backtrack(int len, int start, List<Integer> path, List<List<Integer>> res){
        if(start == len){
            res.add(new ArrayList<>(path));
            return;
        }
        Set<Integer> set = new HashSet<>();
        for(int i = start; i < len; i++){
             if(set.add(path.get(i))){
                Collections.swap(path, start, i);
            	backtrack(len, start+1, path, res);
            	Collections.swap(path,start, i);
             } 
        }
    }
}

总结：