全排列_全排列Ⅱ

全排列Ⅰ

题目描述

来源：leetcode_hot100_46
给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：
输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

示例 2：
输入：nums = [0,1]
输出：[[0,1],[1,0]]

示例 3：
输入：nums = [1]
输出：[[1]]

提示：
1 <= nums.length <= 6
-10 <= nums[i] <= 10
nums 中的所有整数 互不相同

错误示范
思路：利用值传递nums，每次用了什么值到下一层之前就删掉（但每次搞完都忘了还回去，没有执行撤销操作），怎么不算回溯呢✌，具体代码的注释见正解二

class Solution {
public:
    vector<vector<int>> res;
    vector<vector<int>> permute(vector<int>& nums) {
        vector<int> path;
        dfs(nums,path);
        return res;
    }

    void dfs(vector<int> nums,vector<int> path){
        if(nums.empty()){
            res.push_back(path);
            return ;
        }
        for(vector<int>::iterator iter=nums.begin();iter<nums.end();iter++){
            int tmp=*iter;
            nums.erase(iter);
            path.push_back(tmp);
            dfs(nums,path);
        }
    }
};

错误原因：解不全

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

正解一

思路：利用used数组，经典回溯

class Solution {
public:
    vector<vector<int>> res;
    vector<bool> used;//用来记录当前值是否已经在当前path中使用过，与我的思路中直接从nums中删除的思路很相似，这个就是标记他还能不能用，true表示已经被用过不能再用，就相当于删除了
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        this->used=used;
        vector<int> path;
        dfs(nums,path,0);
        return res;
    }

    void dfs(vector<int>& nums,vector<int> path,int depth){
        if(depth==nums.size()){
            res.push_back(path);
            return ;
        }
        for(int i=0;i<nums.size();i++){
            if(used[i]==false){
                path.push_back(nums[i]);
                used[i]=true;
                dfs(nums,path,depth+1);
                path.pop_back();
                used[i]=false;
            }
        }
        return ;
    }
};

tips:
一种初始化成员变量方法

vector<bool> used;//成员变量
vector<vector<int>> permute(vector<int>& nums) 
    {
        vector<bool> used(len,false);
        this->used=used;
    }

直接vector used(len,false);好像会有歧义，分不清是变量还是函数
this->used=used; 是把当前的局部变量 used 赋值给成员变量 used 的意思，这样在 dfs 那个方法里就不用传参数了，this-> 用于区别成员变量和临时变量。

正解二

思路：根据我的错误思路看了正确解法后想出来了怎么改

class Solution {
public:
    vector<vector<int>> res;
    vector<vector<int>> permute(vector<int>& nums) {
        vector<int> path;//当前排序存储的地方
        dfs(nums,path);
        return res;
    }

    void dfs(vector<int> nums,vector<int> path){
        if(nums.empty()){//空了证明所有的nums都已经用了，表示这时候一个排列已经完成
            res.push_back(path);//记录当前排列
            return ;
        }
        for(vector<int>::iterator iter=nums.begin();iter<nums.end();iter++){//遍历当前的nums，因为是删除法，还在nums里的肯定没被排序过
            int tmp=*iter;//记录当前指向的值
            nums.erase(iter);//要用了就先把它删掉，放入path
            path.push_back(tmp);
            dfs(nums,path);//进行下一层
            //下面这两行是区别于错误答案多加的，有这两行就对了
            path.pop_back();//这一条路径走完了，path就会pop出这个值，iter++的值还会和当前iter值以前的值们继续组合成一个新排列
            nums.insert(iter,tmp);//这个值放回去进行以后的for的下面的层还要用，不放回去就没了，不能因为是值传递剩下这一层的for都不管了
        }
    }
};

全排列Ⅱ

题目描述

来源：leetcode_hot100_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

正解

思路：基本的剪枝条件：用过的元素不能再使用；添加了一个新的剪枝条件，也就是我们考虑重复部分思考的结果。新剪枝条件 ：当当前元素和前一个元素值相同（此处隐含这个元素的 index>0 ），并且前一个元素还没有被使用过的时候，我们要剪枝

class Solution {
public:
    vector<vector<int>> res;
    vector<bool> used;
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        if(nums.size()==1){
            res.push_back(nums);
            return res;
        }
        vector<bool> used(nums.size(),false);
        this->used=used;
        sort(nums.begin(),nums.end());
        vector<int> path;
        dfs(nums,path,0);
        return res;
    }

    void dfs(vector<int>& nums,vector<int> path,int depth){
        if(depth==nums.size()){
            res.push_back(path);
            return ;
        }
        for(int i=0;i<nums.size();i++){
            //如果nums[i-1]还没被用，该枝就被剪掉
            if(i>0 && used[i-1]==false && nums[i]==nums[i-1]){
                continue;
            }
            if(used[i]==false){
                used[i]=true;
                path.push_back(nums[i]);
                dfs(nums,path,depth+1);
                path.pop_back();
                used[i]=false;
            }
        }
        return ;
    }

};