代码随想录算法训练营Day30 | 332.重新安排行程 51. N皇后 37. 解数独 总结

代码随想录算法训练营Day30 | 332.重新安排行程 51. N皇后 37. 解数独 总结

回溯总结

回溯解决的问题：

组合问题：N个数里面按一定规则找出k个数的集合
排列问题：N个数按一定规则全排列，有几种排列方式
切割问题：一个字符串按一定规则有几种切割方式
子集问题：一个N个数的集合里有多少符合条件的子集
棋盘问题：N皇后，解数独等等

回溯模板

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

LeetCode 332.重新安排行程

题目链接：LeetCode 332.重新安排行程

思路：

1. 用targets存放起点，终点以及次数
2. 依次遍历res的末尾元素的下一个节点

class Solution {
public:

    unordered_map<string, map<string, int>> targets;

    bool backtracking(int ticket_num, vector<string>& res){
        if(ticket_num+1==res.size()) return true;

        for (pair<const string, int>& target:targets[res[res.size()-1]]){
            if(target.second>0) {
                res.push_back(target.first);
                target.second--;
                if(backtracking(ticket_num, res)) return true;
                target.second++;
                res.pop_back();
            }
        }
        return false;
    }
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        targets.clear();
        vector<string> res;
        for(vector<string> vec:tickets){
            targets[vec[0]][vec[1]]++;
        }
        res.push_back("JFK");
        backtracking(tickets.size(), res);
        return res;
    }
};

注意 ：

1. backtracking return的值用于判断是否结束回溯

LeetCode 51. N皇后

题目链接：LeetCode 51. N皇后

思路：

class Solution {
public:
    vector<vector<string>> res;
    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;
    }

    void backtracking (int n, int row, vector<string>& chessboard){
        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(n, row+1, chessboard);
                chessboard[row][col] = '.';
            }
        }
    }
    vector<vector<string>> solveNQueens(int n) {
        res.clear();
        vector<string> chessboard(n, string(n, '.'));
        backtracking(n, 0, chessboard);
        return res;
    }
};

注意 ：
1.
2.
3.
4.

LeetCode 37. 解数独

题目链接：LeetCode 37. 解数独

思路：

class Solution {
public:
    bool isValid(int row, int col, char num, vector<vector<char>>& board){
        int n = board.size();

        //判断列
        for(int i = 0; i<n ; i++){
            if(board[i][col] == num) return false;
        }

        //判断行
        for(int i = 0; i<n ; i++){
            if(board[row][i] == num) return false;
        }

        int startrow = (row/3)*3;
        int startcol = (col/3)*3;

        for(int i = startrow; i< startrow+3; i++){
            for(int j = startcol; j< startcol+3; j++){
                if(board[i][j] == num) return false;
            }
        }
        return true;
    }


    bool backtracking(vector<vector<char>>& board){
        int n = board.size();
        for(int i=0; i<n; i++){
            for(int j=0; j<n; j++){
                if(board[i][j] != '.') continue;
                for(char k = '1'; k <='9'; k++){
                    if(isValid(i, j, k, board)){
                        board[i][j] = k;
                        if(backtracking(board)) return true;
                        board[i][j] = '.';
                    }
                }
                return false;
            }
        }
        return true;
    }
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);
    }
};

注意 ：
1.
2.
3.
4.