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

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

题目描述

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

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

核心挑战：

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

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

完整回溯代码实现

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;  // 回溯：重置使用标记
        }
    }
}

核心去重组件解析：

1. 排序预处理：

   • Arrays.sort(nums)确保重复元素相邻，为去重提供条件

2. used数组：

   • 标记元素是否已在当前排列中使用，避免同一排列中重复使用元素（枝去重）

3. 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]，收集

关键去重步骤：

1. 第一层循环：

   • i=0选1，HashSet={1}
   • i=1选1时，HashSet.contains(1)为true，跳过
   • i=2选2，正常处理

2. 第二层循环（temp=[1]）：

   • i=0的1已使用，跳过
   • i=1的1未使用，但HashSet空，选择1（因为是新层的HashSet）
   • i=2的2未使用，选择2

3. 第三层循环（temp=[1,1]）：

   • 只能选2，生成[1,1,2]

五、去重条件的数学证明

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

证明步骤：

1. 排序保证相邻重复：排序后重复元素相邻，便于同层检测
2. used数组保证枝唯一：每个元素在排列中仅使用一次
3. HashSet保证层唯一：
   • 同层中相同元素仅选第一个
   • 不同层中相同元素允许选择（属于不同路径）
4. 排列唯一性：
   • 同层重复被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;
        }
        // ...
    }
}

• 优势：无需HashSet，直接通过索引和used数组判断
• 原理：排序后，同层中前一个相同元素未使用时，当前元素跳过

九、总结：层去重与枝去重的协同设计

本算法通过排序、HashSet层去重和used数组枝去重的三重保障，高效解决了含重复元素的全排列问题，核心在于：

1. 排序预处理：为同层去重提供基础，使重复元素相邻
2. HashSet层控制：确保同一层中相同元素仅选第一个，避免重复排列
3. used数组枝控制：跨层跟踪元素使用状态，保证排列合法性

理解这种解法的关键是区分层去重与枝去重的不同作用范围：层去重避免同一层中的重复选择，枝去重避免同一排列中的重复使用。两者结合排序策略，形成了完整的去重体系，是处理含重复元素排列问题的经典方案。