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

@代码随想录算法训练营第30天 | LeetCode332.重新安排行程，51. N皇后，37. 解数独

332.重新安排行程

题目描述

给你一份航线列表 tickets ，其中 tickets[i] = [fromi, toi] 表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。

所有这些机票都属于一个从 JFK（肯尼迪国际机场）出发的先生，所以该行程必须从 JFK 开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。

例如，行程 ["JFK", "LGA"] 与 ["JFK", "LGB"] 相比就更小，排序更靠前。

假定所有机票至少存在一种合理的行程。且所有的机票 必须都用一次 且 只能用一次。

第一遍读题思考

这是我第一次把题目描述拿出来放在blog里，因为这个题目描述太**有歧义了，我看了例子才看懂他要什么样的答案。
总结下来就是说有一个哥们他未来一个月内要去几个地方，然后我现在告诉你他都买了哪些机票，然后你给我总结一下未来这一个月这哥们出现在这些个地方的顺序。听起来就是个规划问题，为什么会有最优解？
因为题目限制了条件：说是按字母优先级排序。。。
行，那就找呗。
那么会存在以下几个问题：

1. 怎么遍历到所有的城市比如现在给你四张机票，a-b, b-a, b-a, c-b，正确的思路应该是a-b-c-b-a，但是现在有可能发现a-b-a然后没有路可以走了，怎么办？那这种遍历直接删除掉
2. 怎么确保遍历到的行程是最优的行程。

代码随想录解法思路

carl的思路非常清晰。主要就是确定两个关键点，一个是你遍历的数据结构是什么？之前的回溯算法遍历的数据结构就是非常简单的vector容器，但是这里需要考虑遍历的机场是否会重复，遍历的机场是否是按照优先级高低排序的，以及遍历的是出发机场，但是要查看到达机场。这里卡哥介绍了一个非常好的数据结构：unordered_map<出发机场, map<到达机场, 航班次数>> targets。
这样可以通过unordered_map进行出发机场对应的到达机场的查询，并且出发机场所对应的多个到达机场是根据字母顺序进行排序的，并且利用了航班次数记录是否之前已经用过这个机票，以避免重复和死循环。
第二个问题就是这里的回溯函数的返回值应该是什么？之前的回溯问题都不设置返回值，是因为要记录所有的叶子节点或者记录所有的节点，但是这里的回溯函数只有一个叶子节点是正确答案，所以只要遇到这个叶子节点就可以返回结果了，所以返回值应该是bool类型的。

c++代码具体实现注意事项

还要注意回溯函数的传入参数，其实result可以不用传进去，遍历的时候注意每个出发站是一层，所以层遍历是遍历每个出发站所有的终点站。而后面用了map自动排序所以得到的最终的序列一定是最优的。
最后为什么for循环外面给的return false因为说明这条路径不行，要么是站点数目不够，要么是之前把站点去重复了。

(递归版本)

class Solution {
public:
    unordered_map<string, map<string, int>> targets;
    vector<string> result;
    bool backtracking(int ticketNum){
        if(result.size() == ticketNum + 1){
            return true;
        }
        for(pair<string, int> dest : targets[result[result.size()-1]]){
            if(targets[result[result.size()-1]][dest.first]>0){
                targets[result[result.size()-1]][dest.first]--;
                result.push_back(dest.first);
                if(backtracking(ticketNum)) return true;
                result.pop_back();
                targets[result[result.size()-1]][dest.first]++;
            }
        }
        return false;
    }

    vector<string> findItinerary(vector<vector<string>>& tickets) {
        result.push_back("JFK");
        for(auto vec:tickets){
            targets[vec[0]][vec[1]]++;
        }
        backtracking(tickets.size());
        return result;
    }
};

51.N皇后

第一遍读题思考

这居然是回溯的题目，之前只学过用遗传算法定义这个问题。
感觉是通过回溯来查找是否会冲突，而不是直接用回溯来构建solution

代码随想录解法思路

原来可以直接把矩阵看作树的高度和每一层的宽度

c++代码具体实现注意事项

主要注意在回溯中是检查了要放入的这个row和col的交点是合规的才可以进行回溯。
然后在检查是否合规的时候需要检查同列，左上和右上而不需要检查同行的，因为是按行来下棋的。

(递归版本)
class Solution {
public:
    vector<vector<string>> result;
    void backtracking(int n, int row, vector<string> chessboard){
        if(row==n){
            result.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]='.';
            }
        }
    }
    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;
            }
        }
        // 检查 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;
    }
    vector<vector<string>> solveNQueens(int n) {
        vector<string> chessboard(n, string(n, '.'));
        backtracking(n, 0, chessboard);
        return result;
    }
};

37. 解数独

第一遍读题思考

难点在于isValid函数。

代码随想录解法思路

时间来换题目复杂度，直接二重循环遍历每个元素，然后里面还要嵌套一层循环来“试数”。
还需要注意的是，这个解数独只需要一个解！说明这个回溯函数需要有一个bool类型的返回值！

再有就是isValid的难点了，需要检查行和列，以及所在的9宫格内是否有重复。

c++代码具体实现注意事项

(递归版本)
class Solution {
public:
    bool backtracking(vector<vector<char>>& board){
        for(int row=0;row<board.size();row++)
            for(int col=0;col<board[0].size();col++){
                if(board[row][col]=='.'){
                    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] = '.';
                        }
                    }
                    return false;
                }
            }
        return true;
    }
    bool isValid(int row, int col, char k, vector<vector<char>> board){
        // check row
        for(int i=0;i<board.size();i++){
            if(i!=row && board[i][col]==k) return false;
        }
        // check col
        for(int i=0;i<board[0].size();i++){
            if(i!=col && board[row][i]==k) return false;
        }     
        // check the nine-square grid
        for(int i=(row/3)*3;i<(row/3)*3+3;i++)
            for(int j=(col/3)*3;j<(col/3)*3+3;j++){
                if(i!=row && j!=col && board[i][j]==k) return false;
            }
        return true;
    }
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);
    }
};