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

332.重新安排行程

思路：

这道题有几个难点：

1.一个行程中，如果航班处理不好容易变成一个圈，成为死循环

因为有些行程是首尾相接的，如果你走过的行程不对其进行标记或者是删除，那么下次可能还会走一遍，变成一个死循环

2。有多种解法，字母序靠前排在前面，让很多同学望而止步，如何记录映射关系？

因为题目描述：我们需要一个映射关系来记录from 和 to ,并且这个to不止一个，可能是多个，然后使用过的我们不能继续使用，不然就会变成死循环。思考到这里我们就可以想到使用两个容器，unordered_map<string,multiset<string>> 和unordered_map<string,map<string,int>>，这两个容器都可以满足上述要求，但是我们要选择后者，为什么呢？因为前者每次遍历push过的元素都要删除掉，但是一旦删除元素迭代器就会失效。后者可以用航班总共次数来统计这个航班是否需要进行，如果小于0，那么说明已经经历过这个航班了。相当于我不删元素，我做一个标记。

3.使用回溯法的话，那么终止条件是什么？

当result.size()==tickets.size()时

4.搜索过程中，如何遍历一个机场对应的所有机场？

for(pair<const string,int>&vec:path[result[result.size()-1]])

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 ) { // 记录到达机场是否飞过了
            result.push_back(target.first);
            target.second--;
            if (backtracking(ticketNum, result)) return true;
            result.pop_back();
            target.second++;
        }
    }
    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皇后

思路：

想要解出这道题，重点在于抽象棋盘，将棋盘抽象成一颗树形结构，for循环遍历棋盘的行，递归遍历棋盘的列。

回溯三部曲：

1.确定参数和返回值：因为这个不是找到一个棋盘就进行返回，而是找出所有的棋盘，所以返回值为void 。因为递归遍历棋盘的高度，for遍历棋盘的宽度，所以要传入棋盘的长宽n，还需要确定当前递归层数的row。还需要传入一个初始化好的棋盘chessboard

2.回溯终止条件：当遍历完棋盘最后一层的时候，就压入棋盘。

3.单层遍历函数：当for遍历到当前位置满足存放Q的条件就赋值为Q.

class Solution {
public:
   bool isQ(int n,int x,int count,vector<string> &chessboard){
        //上边没有左右没有，左上角没有，右上角没有
        for(int i=0;i<count;i++){
            if(chessboard[i][x]=='Q'){
                return false;
            }
        }
        for(int i=x-1,j=count-1;i>=0&&j>=0;i--,j--){
            if(chessboard[j][i]=='Q') return false;
        }
        for(int i=x+1,j=count-1;i<n&&j>=0;i++,j--){
            if(chessboard[j][i]=='Q') return false;
        }
        return true;
    }
    vector<vector<string>> result;
    void backtracking(int n,int count,vector<string> &chessboard){
        if(count==n){
            result.push_back(chessboard);
            return ;
        }
        for(int i=0;i<n;i++){
            //如果满足皇后安插位置
            if(isQ(n,i,count,chessboard)){
                chessboard[count][i]='Q';//count 
                 //cout<<chessboard[count][i]<<" ";
               // count++;
               // cout<<count<<" "<<i<<endl;
                backtracking(n,count+1,chessboard);
               // count--;
                chessboard[count][i]='.';
            }
        }
        //if(count)
       //result.push_back(chessboard);
    }
    vector<vector<string>> solveNQueens(int n) {
        //初始一张全部为.的棋盘，然后将棋盘
        vector<string> chessboard(n);
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                chessboard[i]+=".";
            }
        }

        //递归遍历高，for遍历宽
        backtracking(n,0,chessboard);
        return result;
    }
};

37. 解数独

思路：

想要解出这道题，最主要的就是知道二维递归，棋盘的横向赋值和纵向赋值遍历都是通过递归来实现的，也就是说要写两层递归函数里要写两层for循环来安插数字，如果知道这一点这一题就迎刃而解了

class Solution {
private:
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++) {     // (i, j) 这个位置放k是否合适
                    if (isValid(i, j, k, board)) {
                        board[i][j] = k;                // 放置k
                        if (backtracking(board)) return true; // 如果找到合适一组立刻返回
                        board[i][j] = '.';              // 回溯，撤销k
                    }
                }
                return false;  // 9个数都试完了，都不行，那么就返回false 
            }                
        }
    }
    return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
}
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;
        }
    }
    int startRow = (row / 3) * 3;
    int startCol = (col / 3) * 3;
    for (int i = startRow; i < startRow + 3; i++) { // 判断9方格里是否重复
        for (int j = startCol; j < startCol + 3; j++) {
            if (board[i][j] == val ) {
                return false;
            }
        }
    }
    return true;
}
public:
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);
    }
};