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

332.重新安排行程

题目链接/文章讲解：代码随想录

 1.代码展现

   //322.重新安排行程
    unordered_map<string, map<string, int>> targets;
    bool findItineraryBackTracking(vector<string>& result, int ticketsNums) {
        //step1 确定参数
        //step2 确定终止条件
        if (result.size() == ticketsNums + 1) {
            return true;
        }
        //step3 确定单层迭代逻辑
        for (pair<const string, int>& target : targets[result[result.size() - 1]]) {
            if (target.second > 0) {  //还有起飞的机会
                result.push_back(target.first);
                target.second--;
                //找到路径，返回true
                if (findItineraryBackTracking(result, ticketsNums)) {
                    return true;
                }
                result.pop_back();
                target.second++;
            }
        }
        return false;

    }

    vector<string> findItinerary(vector<vector<string>>& tickets) {
        //给targets初始化
        for (int i = 0; i < tickets.size(); i++) {
            vector<string> vec = tickets[i];
            targets[vec[0]][vec[1]]++;//记录映射关系
        }
        vector<string> result;
        result.push_back("JFK");//记录起飞机场
        findItineraryBackTracking(result, tickets.size());
        return result;

    }

2.本题小节

        思考: 本题的解题精髓是unordered_map 和map的应用，map用来排序，并记录次数（同一张票多次），unordered_map用来映射起飞机场与落地机场，画图可以知道终止条件是result.size() == ticketsNums + 1。

        基本思路：这里主要说一下单层递归逻辑，通过找到result最后一个值，也就是下次要起飞的机场来通过unordered_map找到对应的map，其中按照排序记录着可以选择的落地地点和次数，当次数大于零时就可以落下，往result中存入结果，并且下落次数要--，再进行递归，再对result和下落次数进行回溯。

        知识点：对unordered_map<string, map<string, int>> targets的初始化；for (pair<const string, int>& target : targets[result[result.size() - 1]])，遍历targets的second，以上需要掌握。

51. N皇后

题目链接/文章讲解/视频讲解：代码随想录

1.代码展示

  //51.N皇后
    bool isVaild(int row, int col, vector<string> chessBoard, int n) {
        //1.判断列是否满足条件
        for (int i = 0; i < row; i++) {
            if (chessBoard[i][col] == 'Q') {
                return false;
            }
        }
        //2.判断135°是否满足条件
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
            if (chessBoard[i][j] == 'Q') {
                return false;
            }
        }
        //3.判断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>> vvsResult;
    void solveNQueensBackTracking(int n, vector<string>& chessBoard, int row) {
        //step1 确定参数
        //step2 确定终止条件
        if (row == n) {
            vvsResult.push_back(chessBoard);
            return;
        }
        //step3 单层递归逻辑
        for (int col = 0; col < n; col++) {
            if (isVaild(row, col, chessBoard, n)) {
                chessBoard[row][col] = 'Q';
                solveNQueensBackTracking(n, chessBoard, row + 1);
                chessBoard[row][col] = '.';
            }
        }
        return;
    }
    vector<vector<string>> solveNQueens(int n) {
        //创建棋盘
        vector<string> chessBoard(n, string(n, '.'));
        solveNQueensBackTracking(n, chessBoard, 0);
        return vvsResult;
    }   

 2.本题小节

        思考：我觉得N皇后和数独思路是一样的，N皇后也可以像数独一样去直接遍历行和列，但是N皇后没有这样做，而是通过深度递归，每次遍历列，每次递归行+1，最后在满足条件的情况下在终止条件中把所有的情况都存入到结果中。

        基本思路：终止条件是row == n时，即将棋盘都遍历了一遍后，这个时候把满足条件的结果储存起来；单层遍历的思路也很简单，判断在棋盘遍历的位置处，是否满足称为N皇后的条件，满足则插入，并找下一层（这里又和数独不同，数独是找下一个相邻的位置，而不是直接进入下一行，所以N皇后真的适合直接去遍历行列么？我觉得不适合了，因为最后的结果确实不适合N皇后这么做），再回溯。

        知识点：vector<string> chessBoard(n, string(n, '.'));初始化vector<string>

37. 解数独 

题目链接/文章讲解/视频讲解： 代码随想录

1.代码展示

    //37.解数独
    bool solveSudokuIsValid(int row, int col, vector<vector<char>>& board, char val) {
        //1.同一行
        for (int i = 0; i < 9; i++) {
            if (board[row][i] == val) {
                return false;
            }
        }
        //2.同一列
        for (int i = 0; i < 9; i++) {
            if (board[i][col] == val) {
                return false;
            }
        }
        //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;
    }

    bool solveSudokuBackTracking(vector<vector<char>>& board) {
        for (int i = 0; i < board.size(); i++) {
            for (int j = 0; j < board[0].size(); j++) {
                //step1 遍历处不为空，跳过
                if (board[i][j] != '.') {
                    continue;
                }
                //step2 遍历处为空
                for (char k = '1'; k <= '9'; k++) {
                    //检查要插入的数据是否合法
                    if (solveSudokuIsValid(i, j, board, k)) {
                        //合法
                        board[i][j] = k;
                        bool result = solveSudokuBackTracking(board);
                        if (result) {
                            return true;
                        }
                        board[i][j] = '.';
                    }
                }
                //step3 9个数都不行，返回false
                return false;

            }
        }
        return true;
    }
    void solveSudoku(vector<vector<char>>& board) {
        solveSudokuBackTracking(board);
    }

 2.本题小节

        思考：本题用得回溯法，准确来说是二维递归，两个for循环嵌套一个递归（这里我可以想到，计算量很大！！很暴力），可以想象的是，在某个位置找到一个合适的数并插入，让后进行下次递归，可能在上次位置的旁边再插入...，这个样子，对于最顶层来说，一个位置就要递归很多次，这或许就是二维递归的魅力，很暴力，计算量很大。这里与N皇后不同的是，数独只需要找到一个合适的结果就可以返回，因此回溯返回值是bool类型。

        基本思路：由于数独使用的是二维递归，比N皇后多了一个for循环，在判断返回值为true时，直接返回，除此之外，和N皇后思路一样

回溯篇总结:代码随想录