【c++刷题笔记-回溯】day25：491.递增子序列 、46.全排列 、47.全排列 II、332.重新安排行程、51.N皇后

491. 非递减子序列 - 力扣（LeetCode）

思路：哈希表去重，用set记录已经取了的数

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

46. 全排列 - 力扣（LeetCode）、 47. 全排列 II - 力扣（LeetCode）

思路：用中间数组存储是否有重复值，有就直接跳过

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

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

 

332. 重新安排行程 - 力扣（LeetCode）

思路：使用哈希表映射每个机场能到的机场个数，当机场个数等于航班次数加一时取结果

class Solution {
public:
    unordered_map<string,map<string,int>>hash;
    bool fun(vector<string>& ans,int n){
        if(ans.size()==n+1){//当机场个数等于航班次数叫一时取结果
            return true;
        }
        for(pair<const string,int>& t:hash[ans[ans.size()-1]]){
            if(t.second>0){//当能从该机场出发的次数大于0时才能走这条航线
                ans.push_back(t.first);
                t.second--;
                if(fun(ans,n)){
                    return true;
                }
                t.second++;
                ans.pop_back();
            }
        }
        return false;
    }
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        vector<string>ans;
        for(vector<string>& vec:tickets){
            hash[vec[0]][vec[1]]++;//做机场映射，每个机场能到那里去
        }
        ans.push_back("JFK");//起始机场
        fun(ans,tickets.size());
        return ans;
    }
};

51. N 皇后 - 力扣（LeetCode）

思路：拆成子问题判断是否可以放皇后，行数等于n时表示可以取n皇后

class Solution {
public:
    vector<vector<string>>ans;
    bool isvalid(int row,int col,vector<string>& sheer,int n){
        for(int i=0;i<row;i++){
            if(sheer[i][col]=='Q'){//判断同一列是否有皇后
                return false;
            }
        }
        for(int i=row-1,j=col-1;i>=0&&j>=0;i--,j--){//45度方向
            if(sheer[i][j]=='Q'){
                return false;
            }
        }
        for(int i=row-1,j=col+1;i>=0&&j<n;i--,j++){//135度方向
            if(sheer[i][j]=='Q'){
                return false;
            }
        }
        return true;
    }
    void fun(vector<string>&sheer,int row,int n){
        if(n==row){
            ans.push_back(sheer);
            return;
        }
        for(int col=0;col<n;col++){
            if(isvalid(row,col,sheer,n)){
                sheer[row][col]='Q';//放置皇后
                fun(sheer,row+1,n);
                sheer[row][col]='.';//撤销皇后
            }
        }
    }
    vector<vector<string>> solveNQueens(int n) {
        vector<string>sheer(n,string(n,'.'));//初始化棋盘
        fun(sheer,0,n);
        return ans;
    }
};

 37. 解数独 - 力扣（LeetCode）

思路：回溯算法，遍历尝试数字，判断这个位置能放什么数字

class Solution {
public:
   bool isvalid(int row,int col,char k,vector<vector<char>>& board){
    for(int i=0;i<9;i++){//判断同一行是否有相同的数字
        if(board[row][i]==k){
            return false;
        }
    }
    for(int i=0;i<9;i++){//判断同一列是否有相同数字
        if(board[i][col]==k){
            return false;
        }
    }
    //判断同一个九宫格是否有同一个数字
    int a=(row/3)*3;
    int b=(col/3)*3;
    for(int i=a;i<a+3;i++){
        for(int j=b;j<b+3;j++){
            if(board[i][j]==k){
                return false;
            }
        }
    }
    return true;
   }
   bool fun(vector<vector<char>>& board){
    for(int i=0;i<board.size();i++){
            for(int j=0;j<board[0].size();j++){
               if(board[i][j]=='.'){
                    for(char k='1';k<='9';k++){
                    if(isvalid(i,j,k,board)){
                        board[i][j]=k;
                        if(fun(board)) return true;
                        board[i][j]='.';
                    }
                       
                 }
                 return false;
               }  
            }
    }
    return true;
   };
    void solveSudoku(vector<vector<char>>& board) {
        fun(board);
    }
};

总结

回溯去重逻辑需要记清楚，分解大问题为小问题，然后依次解决。回溯不清楚一定要画图理解