代码随想录Day25 | 491.递增子序列、46.全排列、47.全排列II、51.N皇后

491.递增子序列

不能对集合进行排序，顺序会变！

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    void backtracking(vector<int>& nums,int startIndex){
        if(path.size()>1) res.push_back(path);
        unordered_set<int> uset;
        for(int i=startIndex;i<nums.size();i++){
            if((!path.empty()&&nums[i]<path.back())||(uset.find(nums[i])!=uset.end())) continue;
            uset.insert(nums[i]);
            path.push_back(nums[i]);
            backtracking(nums,i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtracking(nums,0);
        return res;
    }
};

树层去重：本层中重复的元素不可再次选取（每一层都维护一个set来记录本层选取过的元素，如果当前元素在set中已存在，则需要跳过本次循环。因为在每层都声明，只记录本层元素，因此不需要做回溯操作）

树枝剪枝：若当前元素小于path中最后一个元素，则不符合递增条件，需要跳过。

46.全排列

自己AC的代码：

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    void backtracking(vector<int>& nums,int k){
        if(path.size()==k){
            res.push_back(path);
            return;
        }
        for(int i=0;i<nums.size();i++){
            int num=nums[i];
            path.push_back(num);
            nums.erase(nums.begin()+i);
            backtracking(nums,k);
            nums.insert(nums.begin()+i,num);
            path.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        int k=nums.size();
        backtracking(nums,k);
        return res;
    }
};

思路：下一层可以取的元素应该包含除了本层所取得元素之外的所有元素，因此每次取完元素放到path后，把对应的元素在数组里删除掉，保证下一层没有该元素但有其他未取元素，回溯时再加回来。

代码随想录：

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    void backtracking(vector<int>& nums,vector<bool>& used){
        if(path.size()==nums.size()){
            res.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 res;
    }
};

用used数组记录使用过的元素，在回溯中如果发现used[i]==true，则说明树枝上使用过，跳过本次循环。

used数组说明：

在树层去重中，used[i-1]==false说明树层中使用过该元素，不可以再次使用；used[i-1]==true说明树枝上使用过，但本质上是下标不同数值相同的元素，因此可以重复使用

在全排列中，used数组记录树枝上使用过的元素，因此，只要used[i]==true，就说明nums[i]在这个树枝上已经使用过了，全排列每个元素只能使用一次，因此要跳过。

47.全排列II

自己AC的代码：

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    void backtracking(vector<int>& nums,vector<bool>& used){
        if(path.size()==nums.size()){
            res.push_back(path);
            return;
        }
        for(int i=0;i<nums.size();i++){
            if((used[i]==true)||(i>0&&nums[i]==nums[i-1]&&used[i-1]==false)) continue;
            path.push_back(nums[i]);
            cout<<nums[i]<<endl;
            used[i]=true;
            backtracking(nums,used);
            used[i]=false;
            path.pop_back();
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        sort(nums.begin(),nums.end());
        backtracking(nums,used);
        return res;
    }
};

51.N皇后

class Solution {
public:
    vector<vector<string>> res;
    void backtracking(vector<string>& chessboard,int row,int n){
        if(row==n){
            res.push_back(chessboard);
            return;
        }
        for(int col=0;col<n;col++){
            if(isValid(row,col,chessboard,n)){
                chessboard[row][col]='Q';
                backtracking(chessboard,row+1,n);
                chessboard[row][col]='.';
            }
        }
    }
    bool isValid(int row,int col,vector<string>& chessboard,int n){
        for(int i=0;i<row;i++){
            if(chessboard[i][col]=='Q') return false;
        }
        for(int i=row-1,j=col-1;i>=0&&j>=0;i--,j--){
            if(chessboard[i][j]=='Q') return false;
        }
        for(int i=row-1,j=col+1;i>=0&&j<n;i--,j++){
            if(chessboard[i][j]=='Q') return false;
        }
        return true;
    }
    vector<vector<string>> solveNQueens(int n) {
        std::vector<std::string> chessboard(n, std::string(n, '.'));
        backtracking(chessboard,0,n);
        return res;
    }
};