代码随想录Day27-回溯：力扣第51h、37h题

51h. N皇后

题目链接
代码随想录文章讲解链接

方法一：回溯搜索（自己想的）

用时：30m12s

思路

每次递归确定一个皇后的坐标，当所有皇后的坐标都确定了，就将棋盘记录并终止递归。
每个皇后肯定不会在同一行中，所以用一个数组queens来记录n个皇后的纵坐标，坐标(i, queens[i])表示第i个皇后的位置。
对于当前皇后，从0-n遍历纵坐标的值，判断纵坐标的值是否满足要求，即与已放置的皇后不在同一列上也不在同一斜线上，如果满足要求则继续递归。

• 时间复杂度：$O((n!{)}^2)$。每一层递归的时间复杂度是$O((n-i{)}^2)$，有两层for循环，一是遍历纵坐标值，二是判断纵坐标的值是否满足要求。
• 空间复杂度：$O(n)$，递归的深度。

C++代码

class Solution {
private:
    vector<vector<string>> res;  // 存放结果的数组
    vector<int> queens;  // n个皇后的纵坐标，坐标(i, queens[i])表示第i个皇后的位置
    int num;  // 皇后的数量以及棋盘的边长

    void backTracking(int row) {
        if (row == num) {
            // 当所有皇后都找到位置，将皇后的坐标转换成棋盘保存至结果数组中，终止递归
            vector<string> checkerboard(num, string(num, '.'));
            for (int i = 0; i < num; ++i) checkerboard[i][queens[i]] = 'Q';
            res.push_back(checkerboard);
            return;
        }
        for (int column = 0; column < num; ++column) {
            if (isQualified(row, column)) {  // 如果当前皇后的坐标符合要求
                queens[row] = column;
                backTracking(row + 1);  // 递归下一个皇后
                queens[row] = -1;  // 回溯
            }
        }
    }

    bool isQualified(int row, int column) {
        // 判断在(row, column)位置添加皇后，棋盘是否符合要求
        for (int i = 0; queens[i] != -1; ++i) {
            // 遍历每一个已放置的皇后，若与新皇后在同一列或者同一斜线上，则不符合要求，返回false
            if (column == queens[i] || column == queens[i] + row - i || column == queens[i] - row + i) return false;
        }
        return true;
    }

public:
    vector<vector<string>> solveNQueens(int n) {
        num = n;
        queens = vector<int>(n, -1);
        backTracking(0);
        return res;
    }
};

方法二：回溯搜索

用时：

思路

方法一中判断纵坐标的值是否满足要求时，每次都需要重新遍历一次queens，时间复杂度为$O(n-i)$，可以用哈希集合优化，

• 时间复杂度：$O(n!)$。
• 空间复杂度：$O(n)$。

C++代码

class Solution {
private:
    vector<vector<string>> res;  // 存放结果的数组
    vector<int> queens;  // n个皇后的纵坐标，坐标(i, queens[i])表示第i个皇后的位置
    unordered_set<int> columnSet;
    unordered_set<int> diaSet1;
    unordered_set<int> diaSet2;
    int num;  // 皇后的数量以及棋盘的边长

    void backTracking(int row) {
        if (row == num) {
            // 当所有皇后都找到位置，将皇后的坐标转换成棋盘保存至结果数组中，终止递归
            vector<string> checkerboard(num, string(num, '.'));
            for (int i = 0; i < num; ++i) checkerboard[i][queens[i]] = 'Q';
            res.push_back(checkerboard);
            return;
        }
        for (int column = 0; column < num; ++column) {
            if (columnSet.find(column) == columnSet.end() && diaSet1.find(column - row) == diaSet1.end() && diaSet2.find(column + row) == diaSet2.end()) {  // 如果当前皇后的坐标符合要求
                queens[row] = column;
                columnSet.insert(column);
                diaSet1.insert(column - row);
                diaSet2.insert(column + row);
                backTracking(row + 1);  // 递归下一个皇后
                columnSet.erase(column);  // 回溯
                diaSet1.erase(column - row);
                diaSet2.erase(column + row);
                queens[row] = -1;
            }
        }
    }

public:
    vector<vector<string>> solveNQueens(int n) {
        num = n;
        queens = vector<int>(n, -1);
        backTracking(0);
        return res;
    }
};

看完讲解的思考

无。

代码实现遇到的问题

无。

---

37h. 解数独

题目链接
代码随想录文章讲解链接

方法一：回溯搜索（自己想的）

用时：1h19m53s

思路

• 时间复杂度：$O(n!)$，n是格子数量。
• 空间复杂度：$O(n)$。

C++代码

class Solution {
private:
    vector<unordered_set<char>> rowSet = vector<unordered_set<char>>(9, unordered_set<char>());
    vector<unordered_set<char>> columnSet = vector<unordered_set<char>>(9, unordered_set<char>());
    vector<unordered_set<char>> blockSet = vector<unordered_set<char>>(9, unordered_set<char>());

    bool backTracking(vector<vector<char>>& board, int row, int column) {
        // 如果column等于9，则进入下一行
        if (column == 9) row += 1, column = 0;
        // 如果row等于9，则说明全部空格都已填上数字，找到了数独的解
        if (row == 9) return true;
        // 如果当前格已经有数字，则直接递归下一个
        char cur = board[row][column];
        if (cur != '.') return backTracking(board, row, column + 1);

        for (int i = 1; i <= 9; ++i) {
            cur = '0' + i;
            // 如果填入的数字符合要求，则递归下一个格子
            if (rowSet[row].find(cur) == rowSet[row].end() && columnSet[column].find(cur) == columnSet[column].end() && blockSet[row / 3 * 3 + column / 3].find(cur) == blockSet[row / 3 * 3 + column / 3].end()) {
                // 更新哈希集合以及数独
                if (row == 2 && column == 1) cout << cur << endl;
                rowSet[row].insert(cur);
                columnSet[column].insert(cur);
                blockSet[row / 3 * 3 + column / 3].insert(cur);
                board[row][column] = cur;
                // 递归下一个格子，如果当前填法找到了数独解，则结束搜索
                if (backTracking(board, row, column + 1)) return true;
                // 如果当前格子填1-9都无法找到数独解，则回溯
                rowSet[row].erase(cur);
                columnSet[column].erase(cur);
                blockSet[row / 3 * 3 + column / 3].erase(cur);
                board[row][column] = '.';
            }
        }
        return false;  // 当前格子填1-9都无法找到数独解，返回false
    }

public:
    void solveSudoku(vector<vector<char>>& board) {
        // 初始化哈希集合
        for (int i = 0; i < 9; ++i) {
            for (int j = 0; j < 9; ++j) {
                char cur = board[i][j];
                if (cur != '.') {
                    rowSet[i].insert(cur);
                    columnSet[j].insert(cur);
                    blockSet[i / 3 * 3 + j / 3].insert(cur);
                }
            }
        }
        // 回溯搜索
        backTracking(board, 0, 0);
    }
};

看完讲解的思考

官方题解看不懂…自己想的方法能ac的话那就酱吧…

代码实现遇到的问题

代码细节老是出错啊，整体回溯代码逻辑不到半个钟时已经想出来了，但是改bug改了大半个钟=_=！

---

最后的碎碎念

回溯章节完结撒花~~！比预期的时间晚了一天，因为前两天跟朋友过生日轰趴去了，后面得赶一下进度。
今天最后这两道hard真的是让人满头大汗呢，不过感觉用回溯来解的话也没有特别难，自己做都能AC😊。