问题描述

给定一个可能包含重复元素的整数数组 nums，返回所有可能的唯一全排列。例如，输入 nums = [1,1,2]，期望输出为：
[[1,1,2], [1,2,1], [2,1,1]]。

---

常见错误代码与问题分析

错误代码示例

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        backTrack(result, new ArrayList<>(), nums);
        return result;
    }

    public void backTrack(List<List<Integer>> result, List<Integer> path, int[] nums) {
        if (path.size() == nums.length) {
            result.add(new ArrayList(path));
            return;
        }
        HashSet<Integer> used = new HashSet<>();
        for (int i = 0; i < nums.length; i++) {
            if (i > 0 && nums[i] == nums[i - 1] || used.contains(nums[i])) {
                continue;
            }
            path.add(nums[i]);
            used.add(nums[i]);
            backTrack(result, path, nums);
            path.remove(path.size() - 1);
        }
    }
}

错误分析

1. 错误使用 HashSet 跟踪元素
   HashSet 仅通过值去重，无法区分相同值的不同索引。例如，在 nums = [1,1,2] 中，两个 1 会被视为重复，导致合法排列 [1,1,2] 被错误跳过。

2. 剪枝条件不完整
   原代码的剪枝条件 i > 0 && nums[i] == nums[i - 1] 未考虑元素的使用状态，无法正确避免同一层递归中的重复分支。

---

正确解决方案

修正后的代码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        if (nums == null || nums.length == 0) return result;
        Arrays.sort(nums);
        backtrack(result, new ArrayList<>(), nums, new boolean[nums.length]);
        return result;
    }

    private void backtrack(List<List<Integer>> result, List<Integer> path, int[] nums, boolean[] used) {
        if (path.size() == nums.length) {
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (used[i]) continue;
            if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) continue;
            
            used[i] = true;
            path.add(nums[i]);
            backtrack(result, path, nums, used);
            path.remove(path.size() - 1);
            used[i] = false;
        }
    }
}

关键修正点

1. 引入 boolean[] used 数组
   通过索引精确记录元素是否被使用，区分相同值的不同位置。

2. 完善剪枝条件
   使用 i > 0 && nums[i] == nums[i - 1] && !used[i - 1] 确保仅在相同值的元素未被使用时剪枝，避免重复分支。

---

核心逻辑详解

1. 为何使用 boolean[] used 而非 HashSet？

• 区分相同值的不同索引
  例如 nums = [1,1,2]，通过 used 数组可明确标记第一个 1（索引0）和第二个 1（索引1）的使用状态。
• 时间复杂度与空间效率
  数组的索引访问为 O(1)，且内存连续，无哈希表动态扩容的开销。

2. 剪枝条件 !used[i - 1] 的作用

• 避免同一层递归的重复分支
  当 nums[i] == nums[i-1] 且前一个元素未被使用时（!used[i-1]），说明已存在以该值开头的分支，需跳过当前元素。
• 允许深层递归使用相同值
  若前一个元素已被使用（used[i-1] = true），则当前处于深层递归，允许生成 [1,1,2] 等合法排列。

---

场景对比：何时用数组？何时用哈希表？

场景	数组（boolean[]）	哈希表（HashSet）
是否需要区分相同值的不同位置	✔️（如全排列问题）	❌（仅判断值是否存在）
数据范围	小且连续（如 n ≤ 1e6）	大或不连续
时间复杂度	O(1)（直接索引访问）	O(1)（平均情况）
空间复杂度	固定空间	动态扩展
适用问题类型	排列、组合、子集（含重复元素）	去重、存在性判断（如两数之和）

---

实例分析

以 nums = [1,1,2] 为例：

1. 排序后数组：[1,1,2]。
2. 第一层递归：选择第一个 1（索引0），标记 used[0] = true。
3. 第二层递归：允许选择第二个 1（索引1），标记 used[1] = true。
4. 第三层递归：选择 2，生成排列 [1,1,2]。
5. 回溯后剪枝：若尝试在第一层选择第二个 1，触发 !used[0] 剪枝条件，避免重复。

---

总结

• 优先使用数组：当需要区分相同值的不同位置或数据范围较小时。
• 灵活选择哈希表：当仅需判断值的存在性且数据稀疏时。
• 剪枝条件是处理重复元素的关键，需结合元素值和索引状态综合判断。

通过合理选择数据结构和剪枝策略，可高效解决全排列 II 及其他回溯问题。