代码随想录算法训练营第三十四天 | LeetCode 51、37

---

前言

LeetCode题目：LeetCode 51、37
Takeaway：回溯算法总结，以及什么是二维回溯。

---

一、51

著名的N皇后问题，本质就是回溯迭代每行，for循环遍历当前行的每列，其实本质和普通的回溯没有区别，检查是否合法的时候，需要注意对角线的方向，如果递归到了最后一行+1行，说明没有冲突，将其加入答案。

class Solution {
public:
    vector<vector<string>> result;

    bool isValid(int row, int col, vector<string>& chessboard, int n) {
        //检查列
        for(int i=0; i<row; i++){
            if(chessboard[i][col]=='Q'){
                return false;
            }
        }

        //检查对角线
        int i= row-1;
        int j =col-1;
        while(i>=0 && j>=0){
            if(chessboard[i][j]=='Q'){
                return false;
            }
            i--;
            j--;
        }

        //检查对角线2，角度不一样
        i= row-1;
        j =col+1;
        while(i>=0 && j>=0){
            if(chessboard[i][j]=='Q'){
                return false;
            }
            i--;
            j++;
        }

        return true;
    }

    void traverse(int n, int row, vector<string>& chessboard) {
        // 到最后一行了，一直合法，加入结果，回溯
        if(row == n){
            result.push_back(chessboard);
            return;
        }

        for(int i=0; i<n; i++){
            //当前行，挨个检查每列，不合法就下一个
            if(isValid(row, i, chessboard, n) == false){
                continue;
            }

            //当前行的这个位置不冲突，递归下一行去
            chessboard[row][i] = 'Q';
            traverse(n, row+1, chessboard);
            chessboard[row][i] = '.';
        }
    }

    vector<vector<string>> solveNQueens(int n) {
        vector<string> chessboard(n, string(n, '.'));
        traverse(n, 0, chessboard);
        return(result);
    }
};

---

二、37

解数独问题，在八皇后问题的基础上多了一层嵌套，对于八皇后问题来说：递归迭代的是层，每次递归里面的for循环迭代的是当前层的每一个元素(也就是列)，这是因为八皇后问题每行每列只存放一个元素；对于解数独问题来说，要迭代的层次需要+1，因为每行每列不止存放一个元素了，也就是说我们需要两个for循环来迭代行+列，最后再用递归去迭代每个位置的元素到底是哪个，这就是二维递归。

class Solution {
public:

    bool isValid(vector<vector<char>>& board, int row, int cow, char k){
        //看当前行
        for(int j=0; j<9; j++){
            if(board[row][j] == k){
                return false;
            }
        }

        //看列
        for(int i=0; i<9; i++){
            if(board[i][cow] == k){
                return false;
            }
        }

        //看同组
        int row_num = row/3;
        int cow_num = cow/3;
        for(int i=3*row_num;i<=3*row_num+2;i++){
            for(int j=3*cow_num;j<=3*cow_num+2;j++){
                if(board[i][j] == k){
                    return false;
                }
            }
        }
        return true;
    }

    bool traverse(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(isValid(board, i, j, k)){
                            board[i][j] = k;
                            if(traverse(board)){
                                return true;
                            }
                            board[i][j] = '.';
                        }
                    }
                    // 注意这里return的位置，当前[i][j]放什么K值都不行，说明此时无解，须回溯！
                    return false;
                }
            }
        }
        return true;
    }

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

---

总结

回溯算法总结，以及什么是二维回溯。