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

一、前言

参考文献：代码随想录

转眼见就已经一个月了，训练营已经过了一半了，今天地题目还是关于回溯算法，只是这是四道困难题目，然我们来好好研究一下吧！

二、重新安排行程

1、思路：

这个题目我看完第一眼，我没有任何的头绪。。

我只好看卡哥的题解，思路如下：

（1）返回值和参数为：

bool backtracking(vector<string> &result, int ticketNum)

这里为什么是返回bool类型？

因为需要判断有没有到叶子节点，到达叶子节点就可以直接返回了，因为航线只有一个；

参数result为返回值，他有两个作用1、用于存储航线；2、用于匹配map中下一个机场的名字，以及次数；

这里，我就要引出这个map数据结构了：

unordered_map<string, map<string, int>> targets;

 这个map是可以做增删的，外层的map是无序的，里层的map是按照键的大小进行排序的，这个可以解决题目中的

这个要求，翻译过来就是<出发机场,<到达机场，机票次数>>

（2）终止条件：

        if (result.size() == ticketNum + 1) {
            return true;
        }

这个原理比较好理解（ticketNum是航班次数），当我们画图发现，航班次数等于航线机场数量-1 ，这个模拟一下就会发现了，就不多了说。

里面的逻辑就是返回true，来告诉已经找到叶子节点了，可以返回true了。

（3）单层递归逻辑：

// 去找result里面最后到达的一个机场，然后找他的值，匹配下一个机场
        for (pair<const string, int> &target : targets[result[result.size() - 1]]) {
            if (target.second > 0) { // 机票够
                result.push_back(target.first);
                target.second--;
                if (backtracking(result, ticketNum)) return true; // 找到叶子节点了就可以返回了
                result.pop_back();
                target.second++;
            }
        }

这个其实比较好理解，就是简单的从map数组里面取对应的到达机场，以及查看是否还有次数，就可以解决这个问题了。里面嵌套的就是添加、递归、回溯了。只有在到了叶子节点，才能去回溯，去树层的其他树枝。

2、整体代码如下：

class Solution {
private:
    vector<string> result;
    unordered_map<string, map<string, int>> targets;
    // 返回bool值就是为了判断有没有到达叶子节点，到达了就可以直接返回了
    bool backtracking(vector<string> &result, int ticketNum) {
        if (result.size() == ticketNum + 1) {
            return true;
        }

        // 去找result里面最后到达的一个机场，然后找他的值，匹配下一个机场
        for (pair<const string, int> &target : targets[result[result.size() - 1]]) {
            if (target.second > 0) { // 机票够
                result.push_back(target.first);
                target.second--;
                if (backtracking(result, ticketNum)) return true; // 找到叶子节点了就可以返回了
                result.pop_back();
                target.second++;
            }
        }
        return false;
    }
public:
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        // 初始化map and result
        for (const vector<string> s : tickets) {
            targets[s[0]][s[1]]++;
        }
        result.push_back("JFK");
        backtracking(result, tickets.size());
        return result;
    }
};

 二、N皇后

1、思路：

其实思路并并不难，要是能想到怎么去利用回溯来解决就是比较难的问题了。

2、整体代码：

class Solution {
private:
    vector<vector<string>> result;
    // 1、棋盘
    // 2、大小
    // 3、位于的行
    void backtracking(vector<string> &chessboard, int n, int row) {
        if (row == n) {
            result.push_back(chessboard);
            return;
        }
        for (int i = 0; i < n; i++) {
            // 判断是否复合条件
            if (isValue(chessboard, row, i, n)) {
                // 添加皇后
                chessboard[row][i] = 'Q';
                // 递归
                backtracking(chessboard, n, row + 1);
                // 回溯
                chessboard[row][i] = '.';
            }
        }
    }
    // row ： 行
    // col ： 列
    bool isValue(vector<string> &chessboard, int row, int col ,int n) {
        // 竖直去重
        for (int i = 0; i < row; i++) { //有一个细节剪枝操作，画图就能明白
        // 1、row下方绝对没有Q
        // 2、row同一层不会出现两个Q
            if (chessboard[i][col] == 'Q') {
                return false;
            }
        }
        // 45°去重
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; j--, i--) {
            if (chessboard[i][j] == 'Q') {
                return false; 
            }
        }
        // 135°去重
        for (int i = row - 1, j = col + 1; i >= 0 && j < n; j++, i--) {
            if (chessboard[i][j] == 'Q') {
                return false;
            }
        }
        return true;
    }
public:
    vector<vector<string>> solveNQueens(int n) {
        vector<string> chessboard(n, string(n, '.'));
        backtracking(chessboard, n, 0);
        return result;
    }
};

三、解数独

1、思路：

已经不想写个题解了，先过一遍吧！

2、整体代码：

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++) {
                        if (isValue(i, j, k, board)) {
                            board[i][j] = 'k';
                            if (backtracking(board)) {
                                return true;
                            }
                            board[i][j] = '.';
                        }
                    }
                    return false;                    
                }
            }
        }
        return true;
    }

    bool isValue(int row, int col, char k, vector<vector<char>> board) {
        // 检查行
        for (int i = 0; i < board.size(); i++) {
            if (board[i][col] == k && i != row) {
                return false;
            }
        }
        // 检查列
        for (int j = 0; j < board.size(); j++) {
            if (board[row][j] == k && j != col) {
                return false;
            }
        }
        // 判断9方格是否重复
        int startRow = row / 3 * 3;
        int startCol = col / 3 * 3;
        for (int i = startRow; i < startRow + 3; i++) {
            for (int j = startCol; j < startCol + 3; j++) {
                if (board[i][j] == k) {
                    return false;
                }
            }
        }
        return true;
    }
public:
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);
    }
};

学习时间：3小时；

leave message:

 Death is not the opposite of life, but the part it.

死亡不是生命的对立面，而是它的一部分