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

332. 重新安排行程

使用欧拉回路解法

如果在一张图中，从一个点出发可以走完所有的边，则这个遍历走过的路径就叫欧拉路径。
可以理解为：一张图可以一笔画出来。

题意已知图中存在欧拉路径，你要找出一个欧拉路径，可以用 hierholzer 算法。

任选一个点为起点，遍历它所有邻接的边（设置不同的分支）。
DFS 搜索，访问邻接的点，并且将走过的边（邻接关系）删除。
如果走到的当前点，已经没有相邻边了，则将当前点推入 res。
随着递归的出栈，点不断推入 res ，最后就得到一个和从起点出发的欧拉路径相反的序列。将其反转

没有回溯的过程

class Solution {
public:
    unordered_map<string, vector<string>> graph;
    vector<string> res;
    void dfs(string start) {
        while (!graph[start].empty()) {
            string target = graph[start].back();
            graph[start].pop_back();
            dfs(target);
        }
        res.push_back(start);
    }
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        // 构建邻接表
        for (auto ticket : tickets) {
            graph[ticket[0]].emplace_back(ticket[1]);
        }

        for (auto& pair: graph) {
            sort(pair.second.begin(), pair.second.end(), greater()); // 从大到小排，先选最后的元素
        }

        dfs("JFK");
        reverse(res.begin(), res.end());
        return res;
    }
};

51. N 皇后

只需要判断上方行，同列，左上角，右上角不能有元素

回溯过程，判断当前点是否能放置Q，如果可以则递归进入下一行

class Solution {
public:
    vector<vector<string>> res;
    bool is_valid(int row, int col, vector<string>& board) {
        
        for (int i = 0; i < row; i++) {
            // 判断同列是否有Q
            if (board[i][col] == 'Q') return false;
            // 判断左上角是否有Q
            if (col - (row - i) >= 0 && board[i][col - (row - i)] == 'Q') return false;
            // 判断右上角是否有Q
            if (col + (row - i) < board.size() && board[i][col + (row - i)] == 'Q') return false;            
        }

        return true;
    }

    void dfs(int n, int row, vector<string>& board) {
        if (row == n) {
            res.emplace_back(board);
        }
        for (int j = 0; j < n; j++) {
            if (is_valid(row, j, board)) {
                board[row][j] = 'Q';
                dfs(n, row + 1, board);
                board[row][j] = '.';
            }
        }
    }

    vector<vector<string>> solveNQueens(int n) {
        vector<string> board(n, string(n, '.'));
        dfs(n, 0, board);
        return res;
    }
};

37. 解数独

class Solution {
public:
    bool is_valid(char ch, int row, int col, vector<vector<char>>& board) {
        // 判断同行只出现一次
        for (int j = 0; j < 9; j++) {
            if (board[row][j] == ch) return false;
        }
        // 判断同列
        for (int i = 0; i < 9; i++) {
            if (board[i][col] == ch) return false;
        }
        // 判断3*3方格内
        int nrow = row / 3 * 3;
        int ncol = col / 3 * 3;
        for (int i = 0; i <= 2; i++) {
            for (int j = 0; j <= 2; j++) {
                if (board[nrow + i][ncol +j] == ch) return false;
            }
        }

        return true;
    }

    bool dfs(vector<vector<char>>& board) {
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                if (board[i][j] == '.') {
                    for (int k = 0; k < 9; k++) {
                        char ch = '1' + k;
                        if (is_valid(ch, i, j, board)) {
                            board[i][j] = ch;
                            if (dfs(board)) return true;
                            board[i][j] = '.';
                        }
                    }
                    return false;
                }
            }
        }
        return true;
    }

    void solveSudoku(vector<vector<char>>& board) {
        dfs(board);
    }
};