LeetCode题练习与总结：全排列Ⅱ

一、题目描述

给定一个可包含重复数字的序列 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

二、解题思路

1. 对数组nums进行排序，这样相同的数字会相邻。
2. 使用回溯算法生成所有可能的排列。
3. 在选择数字时，如果当前数字与前一个数字相同，并且当前数字尚未被使用（used[i]为false），则跳过这个数字，以避免重复。
4. 使用一个布尔数组used来跟踪每个数字是否已经被选择过。

三、具体代码

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

public class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> results = new ArrayList<>();
        if (nums == null || nums.length == 0) {
            return results;
        }
        
        // 对数组进行排序，以便相同的数字相邻
        Arrays.sort(nums);
        
        boolean[] used = new boolean[nums.length]; // 用于跟踪数字是否已选择
        backtrack(new ArrayList<>(), nums, used, results);
        
        return results;
    }
    
    private void backtrack(List<Integer> current, int[] nums, boolean[] used, List<List<Integer>> results) {
        if (current.size() == nums.length) {
            // 当前排列长度等于nums长度时，表示找到了一个完整的排列
            results.add(new ArrayList<>(current));
            return;
        }
        
        for (int i = 0; i < nums.length; i++) {
            if (used[i] || (i > 0 && nums[i] == nums[i - 1] && !used[i - 1])) {
                // 如果当前数字已使用，或者当前数字与前一个数字相同且前一个数字未被使用，则跳过
                continue;
            }
            
            // 选择当前数字，并将其标记为已使用
            current.add(nums[i]);
            used[i] = true;
            
            // 递归地构建下一个排列
            backtrack(current, nums, used, results);
            
            // 回溯，移除最后一个元素，并将其标记为未使用
            current.remove(current.size() - 1);
            used[i] = false;
        }
    }
}

四、时间复杂度和空间复杂度

1. 时间复杂度

• 首先，我们需要生成所有可能的排列。对于一个包含n个元素的数组，全排列的数量是n的阶乘（n!）。因此，最坏情况下，我们需要生成n!个排列。
• 然而，由于数组中可能存在重复的元素，实际上生成的排列数量会少于n!。但是，我们无法精确地计算节省了多少时间，因为这取决于数组中重复元素的数量和分布。
• 对于每个排列，我们需要遍历数组来选择下一个元素，这需要O(n)的时间。
• 由于我们使用了回溯算法，每次递归调用都会生成一个新的数组来存储当前的排列，这意味着我们需要O(n)的空间来存储当前排列。
• 综合考虑，时间复杂度为O(n * n!)，这是因为我们需要对每个排列进行O(n)的操作。但是，由于重复元素的存在，实际的时间复杂度可能会低于这个理论值。

2. 空间复杂度

• 我们使用了一个数组used来跟踪每个元素是否已经被使用，这个数组的大小与输入数组nums的大小相同，因此是O(n)。
• 在递归过程中，我们需要额外的空间来存储当前的排列。在最坏的情况下，我们可能需要存储n个元素的排列，因此这部分的空间复杂度也是O(n)。
• 由于递归调用的深度最多是n，因此总的空间复杂度是O(n)。

五、总结知识点

1. 数组排序 (Arrays.sort(nums)):

• 使用Java标准库中的Arrays.sort方法对输入数组进行排序。这有助于将相同的元素放在一起，从而在生成排列时避免重复。

2. 回溯算法:

• 回溯算法是一种通过递归来遍历所有可能情况的算法。在这个问题中，它用于生成所有可能的排列。
• 回溯算法的关键是在适当的时机返回，以避免走进无效的路径（即生成重复的排列）。

3. 位掩码 (使用boolean[] used数组):

• 位掩码是一种使用数组来跟踪状态的技术。在这个例子中，used数组用于跟踪哪些数字已经被添加到当前的排列中。
• 通过检查used[i]的值，我们可以知道是否应该选择数组中索引为i的元素。

4. 递归:

• 递归是一种通过函数自己调用自己来重复执行代码的方式。在这个例子中，backtrack方法递归地调用自己来构建新的排列。

5. 剪枝优化 (跳过重复元素):

• 为了提高效率，我们在选择下一个元素时会检查当前元素是否与前一个已选择的元素相同，并且前一个元素是否已经被使用。如果这两个条件都满足，我们就跳过当前元素，这被称为剪枝优化。

6. List的操作 (ArrayList):

• 使用ArrayList来存储当前的排列和最终的结果。ArrayList提供了动态数组的功能，允许我们在运行时添加和删除元素。

7. 深拷贝 (new ArrayList<>(current)):

• 当我们将当前排列添加到结果列表时，我们使用深拷贝的方式创建一个新的ArrayList实例，以避免修改原始current列表时影响到结果。

以上就是解决这个问题的详细步骤，希望能够为各位提供启发和帮助。