代码随想录训练营Day30（回溯算法进阶）：Leetcode332、51、37

Leetcode332:

问题描述：

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

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

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

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

代码及注释：

class Solution {
public:
    //key是出发机场，value是该机场可以到达的所有机场和是否到达过的情况
    unordered_map<string, multimap<string, bool>> graph;
    //当前走过的路径
    vector<string>path;
    
    int len = 0;

//当前到达机场
bool dfs(const string& u) {
    path.push_back(u);
    //如果使用完了所有飞机票，成功了
    if (path.size() == len)return true;

    
    //按字典序访问当前机场u能到达的所有机场
    for (auto& v : graph[u]) {
        
        if (v.second)continue;
        //如果没有走过该机场，那就走，并设置已经访问过
        v.second = true;

        //递归搜索，能否成功
        if (dfs(v.first)) {
            return true;
        }
        //回溯
        v.second = false;
    }
        //回溯
        path.pop_back();
        return false;
   
}
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        graph.clear();
        path.clear();
        len = tickets.size() + 1;
        
        for (auto& ticket : tickets) {
            graph[ticket[0]].insert({ ticket[1],false });
        }

        dfs("JFK");
        return path;
    }

};

Leetcode51:

问题描述：

按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。

每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。

代码及注释：

前一篇文章已经讲过n皇后了

class Solution {
public:
    
    vector<vector<string>> solveNQueens(int n) {
        for(int i=0;i<=n;i++){
            umap[1<<i]=i;
        }
        vector<string>path(n,string(n,'.'));
        dfs(1,(1<<(n+1))-2,(1<<2*n)-2,(1<<2*n)-2,n,path);
        return ans;

    }
private:
    unordered_map<int,int>umap;
    vector<vector<string>>ans;

    void dfs(int row,int colKey,int left,int right,int n,vector<string>&path){
        if(row > n){
            ans.push_back(path);
            return;
        }

        for(int t=colKey;t;t-=t&-t){
            int k=t&-t;
            int j=umap[k];

            if((left&(1<<(row+j-1)))&&(right&(1<<(row-j+n)))){
                path[row-1][j-1]='Q';
                dfs(row+1,colKey^k,left^(1<<(row+j-1)),right^(1<<(row-j+n)),n,path);
                path[row-1][j-1]='.';
            }
        }

    }


};

Leetcode37:

问题描述：

编写一个程序，通过填充空格来解决数独问题。

数独的解法需 遵循如下规则：

1. 数字 1-9 在每一行只能出现一次。
2. 数字 1-9 在每一列只能出现一次。
3. 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）

数独部分空格内已填入了数字，空白格用 '.' 表示。

代码及注释：

class Solution {
public:
    void solveSudoku(vector<vector<char>>& board) {
        dfs(board);
    }

    //dfs代表，以行优先，找到第一个需要填写数字的
    //如果填满了则结束dfs
    bool dfs(vector<vector<char>>& board) {
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                //找到第一个需要填数字的
                if (board[i][j] == '.') {
                    //遍历1-9 找到合理可填写的数字
                    for (char k = '1'; k <= '9'; k++) {
                        //如果该数字合理
                        if (isVaild(i, j, k, board)) {
                            //填写数字
                            board[i][j] = k;
                            //递归到下一个空位置
                            if (dfs(board))return true;
                            //回溯
                            board[i][j] = '.';
                        }
                    }
                    return false;
                }
            }
        }
        //结束dfs
        return true;
    }

    //判断该数字是否合理
    bool isVaild(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;
        }

        //该位置所在的9宫格是否使用过该数字
        row = row / 3 * 3;
        col = col / 3 * 3;
        for (int i = row; i < row + 3; i++) {
            for (int j = col; j < col + 3; j++) {
                if (board[i][j] == k)return false;
            }
        }



        return true;
    }
};