LeetCode 46、47 全排列 （c++实现）

46. 全排列（一）

link

题目：

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

示例:

输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]

解法一：

这个方法的思路就是每次选一个出来往后排，
例如，[1,2,3]
第一个位置分别可拿 1、2、3，放到第一位。
1,,
2,,
3,,
第二个位置分别可拿 剩下的其中一个，例如，
对于1,, ，则下一个只能拿2,或者3过来排队。
往下依次递归，知道队伍长度和nums长度一样长，push_back进res。

注意，这里的巧妙之处在于swap，而不是把被选的某个数字删除，对于vector来说删除某个元素复杂度太大了。

常规写法： 先选择再递归。

class Solution {
public:
    vector<vector<int>> res;
    vector<vector<int>> permute(vector<int>& nums) {
        int n = nums.size();
        if(n == 0) return {};
        vector<int> output;
        backtrack(0, output, nums);

        return res;
    }

    void backtrack(int first, vector<int>& output, vector<int>& nums){
        if(first == nums.size()) {
            res.emplace_back(output);
            return;
        }
        
        for(int i = first; i < nums.size(); ++i){
            output.emplace_back(nums[i]);
            swap(nums[i], nums[first]); // 把选出来的nums[i]换到第一位，这样接下来backtrack时，由于传入的是first+1，这样就把选出来的这个数offset掉，从剩下的数字中再进行选择，依次递归，直到都选择出来则推入res数组保存每次的选择结果，这样每次选择的顺序都不同，最终的结果就是全排列
            backtrack(first+1, output, nums);
            output.pop_back();
            swap(nums[i], nums[first]);
        }
    }
};

解法二：

来自这个题解.

这个解法本质上与解法一是一样的，只不过它是从后往前递归。先递归再选择！

作者思路：

以[1, 2, 3]为例子，按照下面的树回溯出整个全排列：
[|1, 2, 3] -> [1|, 2, 3]
[1|, 2, 3] -> [1, 2|, 3], [2, 1|, 3]
[1, 2|, 3] -> [1, 2, 3|], [3, 2, 1|], [1, 3, 2|]
[2, 1|, 3] -> [2, 1, 3|], [3, 1, 2|], [2, 3, 1|]
ps：以[1, 2|, 3] -> [1, 2, 3|], [3, 2, 1|], [1, 3, 2|]为例，’|'往后移动一位，得到[1, 2, 3|]；[1, 2, 3|]中的3和1位置交换，得到[3, 2, 1|]；[1, 2, 3|]中的3和2交换位置，得到[1, 3, 2|]。

什么意思呢？看代码可能更清楚一些，就是先去递归，到头以后，在回来的路上对位置’|'之前的所有元素进行选择交换，这与第一种方法不是真好反过来么。
代码：

class Solution {
private:
    vector<vector<int>> res;

    void trackback(vector<int> &nums, int begin) {
        if (begin == nums.size()) {
            res.push_back(nums);
            return;
        }
        
        trackback(nums, begin + 1);
        
        for (int i = 0; i < begin; i++) {
            swap(nums[i], nums[begin]);
            trackback(nums, begin + 1);
            swap(nums[i], nums[begin]);
        }
    }

public:
    vector<vector<int>> permute(vector<int> &nums) {
        sort(nums.begin(), nums.end());
        trackback(nums, 0);
        return res;
    }
};

47. 全排列（二）

link

题目：

给定一个可包含重复数字的序列，返回所有不重复的全排列。

示例:

输入: [1,1,2]
输出:
[
[1,1,2],
[1,2,1],
[2,1,1]
]

解答：

顺着46题的思路，只需要加一个去重就可以了。

但是对于第一种解法，直接加是有问题的，具体原因我还没想明白，有谁想明白的话，可以给我留个言，让我学习一下。

$对于解法一错误的写法$：

/*class Solution {
public:
    vector<vector<int>> res;
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        int n = nums.size();
        if(n == 0) return {};
        sort(nums.begin(), nums.end());
        vector<int> output;
        backtrack(0, output, nums);
        return res;
    }
    void backtrack(int first, vector<int>& output, vector<int>& nums){
        if(first == nums.size()) {
            res.emplace_back(output);
            return;
        }
        
        for(int i = first; i < nums.size(); ++i){
            if(i > 0 && nums[i] == nums[i-1]) continue;
            output.emplace_back(nums[i]);
            swap(nums[i], nums[first]); 
            backtrack(first+1, output, nums);
            output.pop_back();
            swap(nums[i], nums[first]);
        }
    }
};*/

对于解法一正确写法：

class Solution {
private:
    vector<vector<int>> ans;

public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        int n = nums.size();
        if(n == 0 || n == 1) return {nums};
        vector<int> visted(n, 0);
        vector<int> temp;
        int pos = 0;
        sort(nums.begin(), nums.end());
        trackback(nums, temp, pos, visted);
        return ans;
    }


    void trackback(vector<int>& nums, vector<int>& temp, int pos, vector<int>& visted){
        if(pos == nums.size()){
            ans.push_back(temp);
            return;
        }

        for(int i = 0; i < nums.size(); ++i){
            if(visted[i] || (i > 0 && nums[i] == nums[i-1] && !visted[i-1])) continue;
            temp.push_back(nums[i]);
            visted[i] = 1;
            trackback(nums, temp, pos+1, visted);
            visted[i] = 0;
            temp.pop_back();
        }
    }
};

对于解法二：

class Solution {
private:
    vector<vector<int>> res;

    void trackback(vector<int> &nums, int begin) {
        if (begin == nums.size()) {
            res.push_back(nums);
            return;
        }
        
        trackback(nums, begin + 1);
        
        for (int i = 0; i < begin; i++) {
            if (nums[i] == nums[begin]) { // 去重
                break;
            }
            swap(nums[i], nums[begin]);
            trackback(nums, begin + 1);
            swap(nums[i], nums[begin]);
        }
    }

public:
    vector<vector<int>> permuteUnique(vector<int> &nums) {
        sort(nums.begin(), nums.end());
        trackback(nums, 0);
        return res;
    }
};