【玩转回溯算法专题】47. 全排列 II 【中等】

【玩转回溯算法专题】47. 全排列 II 【中等】

1、力扣链接

https://leetcode.cn/problems/permutations-ii/description/

2、题目描述

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
[1,2,1],
[2,1,1]]
示例 2：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

提示：

1 <= nums.length <= 8
-10 <= nums[i] <= 10

3、题目分析

包含重复数字，返回不重复的全排列

回溯三部曲

1、递归函数参数
//used 确保不对同一个元素使用多次（注意：不是去重逻辑）
int[] nums,boolean[] uesd
2、递归终止条件
当path.size()==nums.length时，符合条件保存返回

3、单层搜索逻辑

for(int i=0;i<nums.length;i++){
            //去重 当与前一个元素相等，且前一个元素未被使用，去重
            if(i > 0 && nums[i] == nums[i-1] && uesd[i-1] == false  ){
                continue;
            }
            if(uesd[i] == false){
            uesd[i] = true;
            path.add(nums[i]);
            //递归
            backTracking(nums,uesd);
            //回溯
            path.removeLast();
            uesd[i]= false;
            }

4、代码实现

1、Java

class Solution {
    //定义返回值
    List<List<Integer>> res = new ArrayList();
    List<Integer> path = new ArrayList();

    public List<List<Integer>> permuteUnique(int[] nums) {
        //对数组进行排序，方便去重
        Arrays.sort(nums);
        //全部设置为false，初始化未被使用
            //确保不对同一个元素使用多次（注意：不是去重逻辑）
        boolean[] uesd = new boolean[nums.length];
        Arrays.fill(uesd,false);
        //调用
        backTracking(nums,uesd);
        return res;
        

    }

    public void backTracking(int[] nums,boolean[] uesd){
        if(path.size() == nums.length){
            res.add(new ArrayList(path));
            return;
        }
        for(int i=0;i<nums.length;i++){
            //去重
            if(i > 0 && nums[i] == nums[i-1] && uesd[i-1] == false  ){
                continue;
            }
            if(uesd[i] == false){
            uesd[i] = true;
            path.add(nums[i]);
            //递归
            backTracking(nums,uesd);
            //回溯
            path.removeLast();
            uesd[i]= false;
            }
           
        }
    }
}