Day32 LeetCode332. 重新安排行程 51. N 皇后 37. 解数独

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

思路：（本题难度属于困难，一刷大概有个印象就行）

        定义一个容器unordered_map<string, map<string, int>> targets用来记录航班的映射关系 ，对应为unordered_map<出发机场，map<到达机场，航班次数>> targets，定义成全局变量。

递归函数参数需要有一个int ticketNum，表示有多少个航班（终止条件会用上），函数的返回值不再是void，而是bool类型，因为不是收集所有的叶子节点，而是寻找一条路径找到了就返回true。

代码：

class Solution {
private:
    // unordered_map<出发机场, map<到达机场, 航班次数>> targets
    unordered_map<string, map<string, int>> targets;
    bool backtracking(int ticketNum, vector<string>& result){
        if(result.size() == ticketNum + 1){
            return true;
        }
    for(pair<const string, int>& target : targets[result[result.size() - 1]]){
        if(target.second > 0){//记录达到的机场是否飞过，如果航班次数大于0，说明达到的机场还未飞过
            result.push_back(target.first);
            target.second--;
            if(backtracking(ticketNum, result)) return true;
            target.second++;
            result.pop_back();
        }
    }
    return false;
    
}
public:
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        targets.clear();
        vector<string> result;
        for (const vector<string>& vec : tickets) {
            targets[vec[0]][vec[1]]++; // 记录映射关系
        }
        result.push_back("JFK");// 起始机场
        backtracking(tickets.size(), result);
        return result;

    }
};

题目：51. N 皇后 - 力扣（LeetCode）

思路： （本题难度属于困难，一刷大概有个印象就行）

递归参数：参数n是棋盘的大小，然后用row来记录当前遍历到棋盘的第几层了，以及vector<string> chessboard棋盘。

终止条件是当遍历到棋盘最底层，row == n时，也就是叶子节点就可以返回了

单层递归逻辑：先要判断皇后放的位置是否合法，如果合法就把棋盘上对应的位置标记成'Q'

递归深度就是row控制棋盘的行，每一层里for循环的col控制棋盘的列，一行一列，确定了放置皇后的位置。

每次都是要从新的一行的起始位置开始搜，所以都是从0开始。

注意判断皇后放的位置是否合法：1.不能同列 2.不能同行 3.不能成斜线（一种情况是放的位置在上一行皇后的右下角45度，另一种情况是放的位置在上一行皇后的左下角45度）

代码：

class Solution {
public:
    vector<vector<string>> result;
    //题目是n * n的棋盘，vector<string> chessboard, 棋盘行row = col = n
    //参数row记录当前遍历到棋盘第几层，n是棋盘的宽度
    void backtracking(vector<string>& chessboard, int row, int n){
        if(row == n){
            result.push_back(chessboard);
            return;
        }
        for(int col = 0; col < n; col++){
            if(isValid(chessboard, row, col, n)){
                chessboard[row][col] = 'Q';
                backtracking(chessboard, row + 1, n);
                chessboard[row][col] = '.';
            }
        }
    }
    //row 行 col 列
    bool isValid(vector<string>& chessboard, int row, int col, int n){
        //检查列(检查当前列中从第0行到当前行 - 1棋盘上是否有皇后，比如当前行row来到了2，当前列来到了2，那就是检查棋盘上[0][2],[1][2]位置上是否有皇后)
        for(int i = 0; i < row; i++){
            if(chessboard[i][col] == 'Q'){
                    return false;
            }
        }
        //检查右下角45度是否可以放皇后
        for(int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--){
            if(chessboard[i][j] == 'Q'){
                return false;
            }
        }
        //检查左下角45度是否可以放皇后
        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) {
        result.clear();
        std::vector<std::string> chessboard(n, std::string(n, '.'));
        backtracking(chessboard, 0, n);
        return result;
    }
};

题目：37. 解数独 - 力扣（LeetCode）​​​​​​

思路：见代码随想录 (programmercarl.com) 

代码：

class Solution {
public:
    bool backtracking(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(backtracking(board)) return true;
                            board[i][j] = '.';
                        }
                    }
                    return false;
                }
            }
        }
        return true;
    }
    bool isValid(int row, int col, char val, vector<vector<char>>& board){
        //判断行是否重复
        for(int i = 0; i < 9; i++){
            if(board[row][i] == val){
                return false;
            }
        }
        //判断列是否重复
        for(int j = 0; j < 9; j++){
            if(board[j][col] == val){
                return false;
            }
        }
        //判断3*3宫内只能出现一次
        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] == val){
                    return false;
                }
            }
        }
        return true;
    }
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);
    }
};