【Leetcode排列】46. 全排列(元素各不相同，求全排列) 47. 全排列 II(元素有相同，求不重复全排列---＞排序加去重) 22.括号生成(元素有相同，求不重复全排列---＞排序加去重)

总结46.47区别

• 46题元素各不相同，求全排列，关于去重逻辑只有一层那就是根到叶子节点路径需要去重，其实说白了只需要去重自己本身

for(int i=0;i<nums.size();i++){
    //1.去根到叶子路径重复
    if(used[i]==true) continue;
    
    path.push_back(nums[i]);
    used[i]=true;
    backtracking(nums,used);
    used[i]=false;
    path.pop_back();
}

• 47题元素有重复，求不重复全排列，那就需要两重去重，第一重去重和46一样那就是一条路径通一个元素肯定不能重复，第二重树层去重类似与40. 组合总和 II，就是同一层不能用同一个元素，否则最后的排列是有重复的，我们先对nums进行了排序，然后只要同层前一个元素和当前节点相同那就的跳过

for(int i=0;i<nums.size();i++){
    //1.去同层重复
    if(i!=0&&nums[i]==nums[i-1]&&used[i-1]== false) continue;
    //2.去根到叶子路径重复
    if(used[i]==true) continue;

    path.push_back(nums[i]);
    used[i]=true;
    backtracking(nums,used);
    used[i]=false;
    path.pop_back();
}

//排序
sort(nums.begin(),nums.end());

• 最后总结就是去重逻辑有两种，作用不同
• 第一种：同层去重，这种去重是为了最后结果集唯一，所以无论是组合40. 组合总和 II还是排列，如果元素有重复都需要有这一重去重
• 第二种：同树枝去重，这种去重为了元素本身上一层使用过了，这一层就跳过，由于排列没startindex所以需要这种去重，而组合不用！

Leetcode46

1.问题描述

2.解决方案

总结

1.递归函数参数，由于是排列所以不需要startIndex，但是一个元素也不能用多次，所以需要一个uesd来标记，但是这个也不同于之前的标记，由于这个used是要标记从根到叶子的一条路径，所以要作为递归函数参数传入

void backtracking(vector<int> nums,vector<bool>& used)

2.好好结合回溯图理解这块逻辑，就是每次从0开始遍历但是如果有使用过的代表该节点的父节点爷爷节点使用过那就跳过，回溯used[i]=false好好理解

for(int i=0;i<nums.size();i++){
    if(used[i]==true) continue;
    path.push_back(nums[i]);
    used[i]=true;
    backtracking(nums,used);
    used[i]=false;
    path.pop_back();
}

代码

class Solution {
public:
    vector<vector<int> > ans;
    vector<int> path;
    void backtracking(vector<int> nums,vector<bool>& used){
        if(path.size()==nums.size()){
            ans.push_back(path);
            return;
        }
        for(int i=0;i<nums.size();i++){
            if(used[i]==true) continue;
            path.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,used);
            used[i]=false;
            path.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        backtracking(nums,used);
        return ans;
    }
};

Leetcode47

1.问题描述

2.解决方案

就是46题加上一个排序并同层去重，其他的包括怎么取结果节点，怎么回溯，不需要startIndex等等都一样，老生长谈了属于是

解法一：第二重去重也就是同层去重，用used(效率高)

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;
    void backtracking(vector<int>& nums,vector<bool>& used){
        if(path.size()==nums.size()){
            ans.push_back(path);
            return;
        }
        for(int i=0;i<nums.size();i++){
            //1.去同层重复
            if(i!=0&&nums[i]==nums[i-1]&&used[i-1]== false) continue;
            //2.去根到叶子路径重复
            if(used[i]==true) continue;

            path.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,used);
            used[i]=false;
            path.pop_back();
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<bool> used(nums.size(), false);
        backtracking(nums,used);
        return ans;
    }
};

解法二：第二重去重也就是同层去重，用uSet(效率低)

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;
    void backtracking(vector<int>& nums,vector<bool>& used){
        if(path.size()==nums.size()){
            ans.push_back(path);
            return;
        }

        unordered_set<int> uSet;
        for(int i=0;i<nums.size();i++){
            //1.去同层重复
            if(uSet.find(nums[i])!=uSet.end()) continue;
            //2.去根到叶子路径重复
            if(used[i]==true) continue;
            
            uSet.insert(nums[i]);
            path.push_back(nums[i]);
            used[i]=true;
            backtracking(nums,used);
            used[i]=false;
            path.pop_back();
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        //排序
        sort(nums.begin(),nums.end());
        vector<bool> used(nums.size(), false);
        backtracking(nums,used);
        return ans;
    }
};

Leetcode22

1.问题描述

2.解决方案

a.核心思路

大致思路就是假设n=2，我就求 “(())” ，这个集合的不重复全排列，然后如果满足括号合理性就加入结果集，最重要的是这个集合是有重复元素的，那么首先结果不重复就需要同层去重，其次由于是排列不是组合，所以没有startIndex，所以需要同一树枝去重， 所以最终就和上一题 47. 全排列 II 一样了即，元素有相同，求不重复全排列—＞排序加去重！

b.判断括号合理性

【Leetcode栈与队列】验证括号序列是否合法

c.去重

//同层去重
if(i>0&&str.charAt(i-1)==str.charAt(i)&&used[i-1]==false) continue;
//同一路径去重
if(used[i]==true) continue;

d.代码

class Solution {
    List<String> result=new ArrayList<>();
    boolean judge_balance(String str){
        int balance=0;
        for (int i = 0; i < str.length(); i++) {
            if(str.charAt(i)=='(') balance++;
            else balance--;
            if(balance<0) return false;
        }
        if(balance>0) return false;
        else return true;
    }
    void backtracking(String str,String cur,boolean[] used){
        if(cur.length()==str.length()&&judge_balance(cur)==true){
            result.add(cur);
        }
        for(int i=0;i<str.length();i++){
            //同层去重
            if(i>0&&str.charAt(i-1)==str.charAt(i)&&used[i-1]==false) continue;
            //同一路径去重
            if(used[i]==true) continue;
            used[i]=true;
            backtracking(str,cur+str.charAt(i),used);
            used[i]=false;
        }
    }
    public List<String> generateParenthesis(int n) {
        String str="";
        for (int i = 1; i <=n; i++) {
            str+="(";
        }
        for (int i = 1; i <=n ; i++) {
            str+=")";
        }
        backtracking(str,"",new boolean[str.length()]); //bool数组默认false
        return result;
    }
}