搜索回溯算法—全排列 II（leetcode 47）

题目描述

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

算法分析

方法一：搜索回溯

思路和算法

此题是「46. 全排列」的进阶，序列中包含了重复的数字，要求我们返回不重复的全排列，那么我们依然可以选择使用搜索回溯的方法来做。

我们将这个问题看作有 n个排列成一行的空格，我们需要从左往右依次填入题目给定的 n个数，每个数只能使用一次。那么很直接的可以想到一种穷举的算法，即从左往右每一个位置都依此尝试填入一个数，看能不能填完这 n个空格，在程序中我们可以用「回溯法」来模拟这个过程。

我们定义递归函数 backtrack(idx, perm) 表示当前排列为 perm，下一个待填入的位置是第 idx 个位置（下标从 0开始）。那么整个递归函数分为两个情况：

    如果 idx==n，说明我们已经填完了 n个位置，找到了一个可行的解，我们将 perm放入答案数组中，递归结束。

   如果 idx

但题目解到这里并没有满足「全排列不重复」 的要求，在上述的递归函数中我们会生成大量重复的排列，因为对于第 idx的位置，如果存在重复的数字 iii，我们每次会将重复的数字都重新填上去并继续尝试导致最后答案的重复，因此我们需要处理这个情况。

要解决重复问题，我们只要设定一个规则，保证在填第 idx个数的时候重复数字只会被填入一次即可。而在本题解中，我们选择对原数组排序，保证相同的数字都相邻，然后每次填入的数一定是这个数所在重复数集合中「从左往右第一个未被填过的数字」，即如下的判断条件：

if (i > 0 && nums[i] == nums[i - 1] && !vis[i - 1]) {
    continue;
}

这个判断条件保证了对于重复数的集合，一定是从左往右逐个填入的。

假设我们有 3个重复数排完序后相邻，那么我们一定保证每次都是拿从左往右第一个未被填过的数字，即整个数组的状态其实是保证了 [未填入，未填入，未填入] 到 [填入，未填入，未填入]，再到 [填入，填入，未填入]，最后到 [填入，填入，填入] 的过程的，因此可以达到去重的目标。

代码

class Solution {
private:
    vector<bool> status;
public:
    void backtrack(vector<int> &nums, vector<vector<int>> &res, vector<int> &track, int idx) {
        if(idx == nums.size()) {
            res.emplace_back(track);
            return;
        }
        for(int i = 0; i < nums.size(); ++i) {
            if(status[i] || (i > 0 && nums[i] == nums[i-1] && !status[i-1])) {
                continue;
            }
            track.push_back(nums[i]);
            status[i] = true;
            backtrack(nums, res, track, idx+1);
            status[i] = false;
            track.pop_back();
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<vector<int>> ans;
        vector<int> track;
        status.resize(nums.size(), false);
        sort(nums.begin(), nums.end());
        backtrack(nums, ans, track, 0);
        return ans;
    }
};

时间复杂度分析

时间复杂度：O(n×n!)，其中 n为序列的长度。

空间复杂度：O(n)。我们需要 O(n)的标记数组，同时在递归的时候栈深度会达到 O(n)，因此总空间复杂度为 O(n+n)=O(2n)=O(n)O(n + n)=O(2n)=O(n)。