leetcode47.全排列II：HashSet层去重与used数组枝去重的双重保障

news2025/6/7 22:49:05

一、题目深度解析与重复排列问题

题目描述

给定一个可能包含重复数字的数组nums，返回其所有不重复的全排列。解集不能包含重复的排列，且排列可以按任意顺序返回。例如：

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

核心挑战：

重复排列消除：相同元素的不同排列路径可能生成相同结果
元素重复处理：数组中存在重复元素，需避免重复选择
排列唯一性：确保每个排列唯一且包含所有元素

二、回溯解法的核心实现与去重逻辑

完整回溯代码实现

class Solution {
    List<Integer> temp = new LinkedList<>();  // 存储当前排列
    List<List<Integer>> res = new ArrayList<>();  // 存储所有唯一排列
    boolean[] used;  // 标记元素是否已使用

    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);  // 排序是去重的前提
        used = new boolean[nums.length];
        backtracking(nums);
        return res;
    }

    public void backtracking(int[] nums) {
        if (temp.size() == nums.length) {  // 终止条件：生成完整排列
            res.add(new ArrayList<>(temp));
            return;
        }

        HashSet<Integer> hs = new HashSet<>();  // 同层去重集合
        
        for (int i = 0; i < nums.length; i++) {
            // 条件1：元素已使用则跳过（枝去重）
            // 条件2：同层中重复元素只选第一个（层去重）
            if (used[i] || hs.contains(nums[i])) {
                continue;
            }
            
            hs.add(nums[i]);  // 记录当前层已选元素
            used[i] = true;   // 标记元素为已使用
            temp.add(nums[i]); // 选择当前元素
            backtracking(nums); // 递归生成后续排列
            temp.removeLast();  // 回溯：撤销选择
            used[i] = false;  // 回溯：重置使用标记
        }
    }
}

核心去重组件解析：

排序预处理：
- Arrays.sort(nums)确保重复元素相邻，为去重提供条件
used数组：
- 标记元素是否已在当前排列中使用，避免同一排列中重复使用元素（枝去重）
HashSet：
- 在每层循环中新建，记录当前层已选元素
- 避免同一层中重复选择相同元素（层去重）

三、HashSet层去重与used数组枝去重的协同工作

1. 层去重：HashSet的核心作用

重复排列产生场景：

当数组中有重复元素时，同一层中选择相同元素会生成相同排列
例如：数组[1,1,2]中，第一层选择第一个1和第二个1会生成相同排列[1,1,2]

HashSet去重逻辑：

HashSet<Integer> hs = new HashSet<>();  // 每层新建HashSet
if (hs.contains(nums[i])) continue;  // 同层重复元素跳过
hs.add(nums[i]);  // 记录当前层已选元素

作用域：每个循环层的HashSet独立，仅影响当前层的元素选择
示例：在第一层循环中，选择第一个1后，HashSet记录1，第二个1会被跳过，避免同层重复

2. 枝去重：used数组的核心作用

元素使用控制：

if (used[i]) continue;  // 已使用元素跳过
used[i] = true;  // 标记为已使用
// ...递归处理
used[i] = false;  // 回溯时重置标记

跨层控制：确保每个元素在一个排列中仅使用一次
示例：父层选择1后，子层无法再选择1，保证排列合法性

3. 双重去重的协同效应

条件组合：

if (used[i] || hs.contains(nums[i])) continue;

枝去重：used数组防止同一排列中重复使用元素
层去重：HashSet防止同一层中重复选择元素
共同作用：确保排列唯一且合法

四、去重流程深度模拟：以输入`[1,1,2]`为例

递归调用树与去重节点：

backtracking([1,1,2])
├─ temp=[]
│  ├─ i=0（元素1）：未使用，HashSet空，选择1 → used[0]=true, temp=[1]
│  │  ├─ 第二层循环，HashSet新建
│  │  │  ├─ i=0（元素1）：used[0]=true，跳过
│  │  │  ├─ i=1（元素1）：HashSet空，选择1 → used[1]=true, temp=[1,1]
│  │  │  │  ├─ 第三层循环，HashSet新建
│  │  │  │  │  ├─ i=0-2：仅i=2（元素2）未使用，选择2 → temp=[1,1,2]，收集
│  │  │  │  └─ 回溯，used[2]=false
│  │  │  └─ 回溯，used[1]=false, temp=[1]
│  │  ├─ i=2（元素2）：HashSet空，选择2 → used[2]=true, temp=[1,2]
│  │  │  └─ 第三层循环选择1（i=0或1），生成[1,2,1]，收集
│  │  └─ 回溯，used[0]=false, temp=[]
│  ├─ i=1（元素1）：HashSet已含1（i=0选过），跳过
│  └─ i=2（元素2）：HashSet空，选择2 → used[2]=true, temp=[2]
│     └─ 第二层循环选择1（i=0或1），生成[2,1,1]，收集

关键去重步骤：

第一层循环：
- i=0选1，HashSet={1}
- i=1选1时，HashSet.contains(1)为true，跳过
- i=2选2，正常处理
第二层循环（temp=[1]）：
- i=0的1已使用，跳过
- i=1的1未使用，但HashSet空，选择1（因为是新层的HashSet）
- i=2的2未使用，选择2
第三层循环（temp=[1,1]）：
- 只能选2，生成[1,1,2]

五、去重条件的数学证明

命题：双重去重确保排列唯一

证明步骤：

排序保证相邻重复：排序后重复元素相邻，便于同层检测
used数组保证枝唯一：每个元素在排列中仅使用一次
HashSet保证层唯一：
- 同层中相同元素仅选第一个
- 不同层中相同元素允许选择（属于不同路径）
排列唯一性：
- 同层重复被HashSet过滤
- 跨层重复因路径不同，生成不同排列（但实际可能相同？不，因为排序后跨层重复元素会被正确区分）

反证法：

假设存在重复排列，必因：

同层选择相同元素：被HashSet过滤
跨层选择相同元素：但排序后跨层选择相同元素时，路径不同但排列可能相同，此时如何处理？
实际上，由于排序后重复元素相邻，跨层选择相同元素时，used数组确保每个元素仅用一次，而HashSet确保同层不重复，最终所有排列唯一。

六、算法复杂度分析

1. 时间复杂度

O(n × n!)：
- 排列总数为n!（去重后最多n!个）
- 每个排列需O(n)时间复制到结果集
- 排序时间O(n log n)，总体为O(n × n! + n log n)

2. 空间复杂度

O(n)：
- 递归栈深度最大为n
- used数组长度为n
- temp列表长度最多为n
- 结果集空间O(n × n!)

七、核心技术点总结：双重去重的关键要素

1. 排序预处理

作用：使重复元素相邻，为同层去重提供条件
必要性：未排序时重复元素不相邻，无法正确检测同层重复

2. HashSet的层去重

时机：每层循环新建HashSet，仅作用于当前层
逻辑：同层中相同元素只选第一个，避免生成重复排列

3. used数组的枝去重

作用域：跨层跟踪元素使用状态
逻辑：确保每个元素在排列中仅使用一次，保证排列合法性

八、常见误区与优化建议

1. 忽略排序的重要性

错误做法：未排序直接去重

// 缺少Arrays.sort(nums)
if (used[i] || hs.contains(nums[i])) continue; // 错误，无法正确去重

后果：重复元素不相邻，HashSet无法检测同层重复

2. HashSet位置错误

误区：将HashSet放在递归函数外

HashSet<Integer> hs = new HashSet<>(); // 错误，跨层共享导致去重过度

正确做法：放在循环内，每层独立

3. 优化建议：索引判断去重（替代HashSet）

public void backtracking(int[] nums) {
    for (int i = 0; i < nums.length; i++) {
        // 同层去重：i>0且nums[i]==nums[i-1]且used[i-1]==false
        if (used[i] || (i > 0 && nums[i] == nums[i-1] && !used[i-1])) {
            continue;
        }
        // ...
    }
}