1.回溯法

回溯法可以理解成一种特殊的深度优先算法，比起普通的DFS，多了还原当前节点的一步。

修改当前节点、递归子节点、还原当前节点。

本质是一种试错的思想。

维基百科：

 2.例题

1）

力扣https://leetcode.cn/problems/permutations/修改和还原当前节点放在了dfs函数的开头和结尾，中间遍历未访问的节点，递归访问这些节点。

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        int n = nums.size();
        vector<bool> visit(n,false);
        vector<int> ans;
        for(int i=0;i<n;i++){
            dfs(nums,visit,i,ans);
        }

        return res;
    }

    void dfs(vector<int>& nums, vector<bool>& visit, int k, vector<int>& ans){
        visit[k] = true;
        ans.push_back(nums[k]);
        int n = nums.size();
        if(ans.size()==n){
            res.push_back(ans);
        }else{
            for(int i=0;i<n;i++){
            if(!visit[i]){
                dfs(nums,visit,i,ans);
                }
            }
        }
        visit[k] = false;
        ans.pop_back();
    }

private:
    vector<vector<int>> res;    
};

2)

力扣https://leetcode.cn/problems/combinations/这题与上一题类似，只是停止搜索的条件变为组合长度为k

class Solution {
public:
    vector<vector<int>> combine(int n, int k) {
        vector<int> ans;
        for(int i=1;i<=n;i++){
            dfs(i,n,k,ans);
        }

        return res;
    }

    void dfs(int start, int n, int k, vector<int>& ans){
        ans.push_back(start);
        if(ans.size()==k){
            res.push_back(ans);
        }else{
            for(int i=start+1;i<=n;i++){
                dfs(i,n,k,ans);
            }
        }
        ans.pop_back();
    }

private:
    vector<vector<int>> res;
};

3)

力扣https://leetcode.cn/problems/word-search/这题也是一样的回溯结构，深搜符合条件的路径

class Solution {
public:
    bool exist(vector<vector<char>>& board, string word) {
        int m = board.size();
        int n = board[0].size();
        vector<vector<bool>> visit(m,vector<bool>(n,false));
        bool res;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(board[i][j]==word[0]){
                    res = dfs(board,word,i,j,1,visit);
                    if(res==true){
                        return true;
                    }
                }
            }
        }
        return false;
    }

    bool dfs(vector<vector<char>>& board, string word, int a, int b, int x, vector<vector<bool>>& visit){
        if(word.size()==x) return true;
        visit[a][b] = true;
        int m = board.size();
        int n = board[0].size();
        for(int i=0;i<4;i++){
            int c = a + path[i];
            int d = b + path[i+1];
            if(c>=0 && c<m && d>=0 && d<n && visit[c][d]==false && 
                word[x]==board[c][d]){
                    if(dfs(board,word,c,d,x+1,visit)){
                        return true;
                    }
                }
        }
        visit[a][b] = false;
        return false;
    }
private:
    vector<int> path{-1,0,1,0,-1};
};

4)

力扣https://leetcode.cn/problems/n-queens/N皇后是经典的回溯问题，一行一行地放置皇后，每次放置前，判断一下是否符合每列每斜线只有有一个皇后的约束。放置皇后后，继续深搜下一行可能的放置方式，搜索完毕后，取消放置该行皇后。

class Solution {
public:
    vector<vector<string>> solveNQueens(int n) {
        vector<string> ans(n,string(n,'.'));
        dfs(0,n,ans);
        return res;
    }

    void dfs(int start, int n, vector<string>& ans){
       
        if(start==n){
            res.push_back(ans);
            return;
        }
        for(int i=0;i<n;i++){
             if(judge(ans,start,i)){
                ans[start][i] = 'Q';
                dfs(start+1, n, ans);
                ans[start][i] = '.';
             }
           
        }
    }

    bool judge(vector<string>& ans, int x, int y){
       int n = ans.size();
       for(int i=0;i<n;i++){
           if(ans[i][y]=='Q'){
               return false;
           }
       }
       for(int i=x-1, j=y-1;i>=0&&j>=0;i--,j--){
           if(ans[i][j]=='Q'){
               return false;
           }
       }
       for(int i=x-1,j=y+1;i>=0&&j<n;i--,j++){
           if(ans[i][j]=='Q'){
               return false;
           }
       }
       return true;
    }

private:
    vector<vector<string>> res;
};