代码随想录训练营第三十天打卡|332.重新安排行程 51. N皇后 37. 解数独

332.重新安排行程

1.本题作为hard难度，回溯解法的思路并不难想。关键是找到合适的数据结构存储行程、机场的关系，并把这些关系变化反映到代码上，难度一下子就上来了。

因为要记录出发机场->目的机场，以及这样的路径有几条，所以我们选择如下数据结构：

unordered_map<出发机场, map<到达机场, 航班次数>>

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

路径有就只可能有一条，因为从一个机场到另一个机场只有一条路径，而且最多飞一次。我们用该数据结构里面的int型变量记录路径条数。

for (vector<string>& vec : tickets) {

            //记录两个机场之间的航班次数并按照字典顺序排序

            targets[vec[0]][vec[1]]++;

        }

该循环记录了初始一个机场到另一个机场的路径条数[vec[0]]对应出发机场，[vec[1]]对应到达机场。而且targets作为map结构是有排序功能的，比如A到B,C都有路径,记录结果也是先A->B再A->C,也就是说对于某一机场找下一个他可能到达的机场，我们只需要顺序的遍历它可能的路径就行。

所以对题目行程的模拟就顺利成章地变成了这样：首先记录每个机场到下一个机场的所有路径，之后把出发机场加入结果集。顺序遍历出发机场到下一个机场的所有路径（顺序遍历是符合字典顺序的），找到路径就加入结果集同时该路径标记为0，表示飞过了，防止之后重新飞发生死循环。之后到达的机场作为新的出发机场重复这个过程。如果最后没有找到合法行程，就依次回溯重复该过程。

class Solution {
private:
    // unordered_map<出发机场, map<到达机场, 航班次数>>
    unordered_map<string, map<string, int>> targets;
    //回溯返回类型为bool因为只需要找到一条路径
    bool backtracking(int ticketsNum, vector<string>& result) {
        //终止条件：行程数＝票数+1（因为有出发机场）
        if (result.size() == ticketsNum + 1) {
            return true;
        }
        //遍历当前机场的map<到达机场,
        //航班次数>，字典排序unordered_map已经帮我们完成
        for (pair<const string, int>& target :
             targets[result[result.size() - 1]]) {
            // map<到达机场,
            // 航班次数>，航班次数>0说明这个机场还没有飞过，可以选择
            if (target.second > 0) {
                result.push_back(target.first); //加入路径
                target.second--; //标记该路径已经飞过，下次不能选择
                if (backtracking(ticketsNum, result)) //递归，找到路线则直接返回
                    return true;
                //回溯，说明这条路径是不符合要求的，回到上一步重新选择
                result.pop_back();
                //路径不符合要求，回溯，重新把这个机场标记为没飞过
                target.second++;
            }
        }
        return false;
    }

public:
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        vector<string> result;
        //遍历机票数组
        for (vector<string>& vec : tickets) {
            //记录两个机场之间的航班次数并按照字典顺序排序
            targets[vec[0]][vec[1]]++;
        }
        result.push_back("JFK");              //记录初始出发机场
        backtracking(tickets.size(), result); //传入初始参数
        return result;
    }
};

51. N皇后

1.大名鼎鼎的N皇后，依然是回溯的思想。但相对于上一题的行程安排，少了复杂数据结构的选取去映射关系。这样看下来发现竟然要简单许多，即便是判断位置是否合法的函数也并不复杂。(以上均为看完题解之后的感受，本人并未独立AC，私以为本题注释已足够清晰明白，故不多赘述)

class Solution {
private:
    vector<vector<string>> result; //接收棋盘数组
    void backtracking(int n, int row, vector<string>& chessBoard) {
        if (row == n) { // row从0开始的，row=n说明棋盘n行已经全部放好皇后了
            result.push_back(chessBoard);
        }
        for (int col = 0; col < n; col++) { //从该行的第一列开始查找放皇后的位置
            if (isValid(n, row, col, chessBoard)) { //检查放皇后位置是否合法
                chessBoard[row][col] = 'Q';         //合法才放皇后
                //上一行放好了，递归在下一行找合法的位置放皇后
                backtracking(n, row + 1, chessBoard);
                //后面找不到合法位置放皇后，只能回溯，将位置恢复原样
                chessBoard[row][col] = '.';
            }
        }
    }
    //判断位置合法函数（递归是每次选一行，位置合法则递归进入下一行判断，所以行位置不用判断）
    bool isValid(int n, int row, int col, vector<string>& chessBoard) {
        //判断列是否合法，之前的列是否有皇后
        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;
            }
        }
        //判断135°角位置是否合法
        for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
            if (chessBoard[i][j] == 'Q') {
                return false;
            }
        }
        return true; //都合法才返回true
    }

public:
    vector<vector<string>> solveNQueens(int n) {
        //初始化棋盘全部为'.'
        vector<string> chessBoard(n, string(n, '.'));
        backtracking(n, 0, chessBoard); //传入初始参数
        return result;                  //返回结果
    }
};

37. 解数独

1.有了上题的经验，本人先是尝试独立AC，未果，遂看题解。本题和N皇后还是有所不同的，N皇后是每次递归回溯都是一行一行慢慢递归和回溯的。而数独棋盘作为一个整体，每次递归回溯都是传入棋盘当前状态，树形结构更宽更深，但本质是都还是回溯的思想。具体实现的过程中还是有许多细节要注意的，比如什么时候返回false，九宫格起始位置的寻找。（详情看注释）

class Solution {
private:
    bool backtracking(vector<vector<char>>& board) {
        for (int row = 0; row < 9; row++) { //依次检查每一个位置
            for (int col = 0; col < 9; col++) {
                if (board[row][col] != '.') { //有数字就跳过
                    continue;
                }
                for (char k = '1'; k <= '9'; k++) { //没数字就考虑填充数字
                    if (isValid(row, col, k, board)) { //判断位置是否合法
                        board[row][col] = k;
                        if (backtracking(
                                board)) { //递归判断之后的棋盘是否能解出来
                            return true;
                        }
                        board[row][col] =
                            '.'; //解失败了，回溯到原来的位置重新解
                    }
                }
                //题目数独虽然有解，但是我们求解过程中可能解错，所以要返回false
                return false;
            }
        }
        return true;
    }
    //判断当前要填入的数字是否合法函数
    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 j = 0; j < 9; j++) {
            if (board[j][col] == k) {
                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] == k) {
                    return false;
                }
            }
        }
        return true; //都不重复才返回true
    }

public:
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board); //无返回，直接传入棋盘就行
    }
};

今日总结：hard！