解决LeetCode 47. 全排列 II 问题的正确姿势：深入分析剪枝与状态跟踪-CSDN博客

本文链接：https://blog.csdn.net/weixin_44435110/article/details/148014685

文章目录

问题描述

给定一个可能包含重复元素的整数数组 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);
        }
    }
}

错误分析

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

关键修正点

引入 boolean[] used 数组
通过索引精确记录元素是否被使用，区分相同值的不同位置。
完善剪枝条件
使用 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)（平均情况）
空间复杂度	固定空间	动态扩展
适用问题类型	排列、组合、子集（含重复元素）	去重、存在性判断（如两数之和）