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

• 今日学习的文章链接，或者视频链接

第七章 回溯算法part06

• 自己看到题目的第一想法

• 看完代码随想录之后的想法

332

class Solution {
public:
    // 邻接表形式的图，key 是机场名字，value 是从该机场出发能够到达的机场列表
    unordered_map> graph;
    // 和 graph 对应，记录每张机票是否被使用过
    // 比如 graph["JFK"][2] = true 说明从机场 JFK 出发的第 3 张机票已经用过了
    unordered_map> used;
    vector> tickets;

    // 回溯算法使用的数据结构
    deque track;
    // 回溯算法记录结果
    vector res;
    void backtrack(string airport) {
        if (!res.empty()) {
            // 已经找到答案了，不用再计算了
            return;
        }
        if (track.size() == tickets.size() + 1) {
            // track 里面包含了所有的机票，即得到了一个合法的结果
            // 注意 tickets.size() 要加一，因为 track 里面额外包含了起点 "JFK"
            res = vector(track.begin(), track.end());
            return;
        }
        if (!graph.count(airport)) {
            // 没有从 s 出发的边
            return;
        }

        // 遍历当前机场所有能够到达的机场
        vector& nextAirports = graph[airport];
        for (int i = 0; i < nextAirports.size(); i++) {
            string& nextAirport = nextAirports[i];
            if (used[airport][i]) {
                // 如果这张机票被使用过，跳过
                continue;
            }
            // 做选择
            used[airport][i] = true;
            track.push_back(nextAirport);
            // 递归
            backtrack(nextAirport);
            // 撤销选择
            used[airport][i] = false;
            track.pop_back();
        }
    }
    vector findItinerary(vector>& tickets) {
        this->tickets = tickets;
        // 1. 用机场的名字构建邻接表
        for (vector& ticket : tickets) {
            string from = ticket[0];
            string to = ticket[1];
            if (!graph.count(from)) {
                graph[from] = vector();
            }
            graph[from].push_back(to);
        }
        // 2. 对邻接表的每一行进行排序，保证字典序最小
        for (auto& p : graph) {
            sort(p.second.begin(), p.second.end());
        }
        // 3. 初始化 used 结构，初始值都为 false
        for (auto& p : graph) {
            used[p.first] = vector(p.second.size(), false);
        }
        // 4. 从起点 "JFK" 开始启动 DFS 算法递归遍历
        track.push_back("JFK");
        backtrack("JFK");
        return res;
    }
};

51

class Solution {
public:
    vector> result;
    void backtracking(int n, int row, vector& chessboard) 
    {
        if (row == n){
            result.push_back(chessboard);
        }
        for(int i = 0;i& 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> solveNQueens(int n) {
        vector chessboard(n, string(n, '.'));
        backtracking(n,0,chessboard);
        return result;
    }
};

37:

class Solution {
public:
    bool backtracking(vector>& board){
        for(int i = 0;i>& 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;
    }   
    void solveSudoku(vector>& board) {
        backtracking(board);
    }
};

• 自己实现过程中遇到哪些困难

• 今日收获，记录一下自己的学习时长