class Solution {
public:
    vector<vector<string>>result;
    int row = 0;
    void backtracking(vector<string> &chessboard,int n,int row) {
        if(n == row) {
            result.push_back(chessboard);
            return ;
        }
        for(int col = 0; col < n; col ++ ) {
            if(isVaild(row,col,n,chessboard)) {
                chessboard[row][col] = 'Q';
                backtracking(chessboard,n,row + 1);
                chessboard[row][col] = '.';
            }
        }
    }
    bool isVaild(int row, int col, int n, vector<string>& chessboard) {
        for(int i = 0 ; i < row; i ++) {
            if(chessboard[i][col] == 'Q') {
                return false;
            }
        }

        for(int i = row - 1, j = col - 1; i >= 0 && j >= 0; i --, j --) {
            if(chessboard[i][j] == 'Q') {
                return false;
            }
        }

        for(int i = row - 1,j = col + 1; i >= 0 && j < n; i--, j++ ) {
            if(chessboard[i][j] == 'Q') {
                return false;
            }
        }
        return true;
    }
    vector<vector<string>> solveNQueens(int n) {
        vector<string> chessboard(n, string(n, '.'));
        backtracking(chessboard,n,row);
        return result;
    }
};

数独：

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

    bool isVaild(vector<vector<char>>& board,int row,int col,char k) {
        for(int i = 0; i < 9; i ++ ) {
            if(board[i][col] == k) {
                return false;
            }
        }
        for(int j = 0; j < 9; j ++ ) {
            if(board[row][j] == k) {
                return false;
            }
        }
        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;
    }
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);
    }
};

利用树的递归遍历思想。

lambda:

值捕获

• C++11~17：[=] 骗了你，它捕获的是 this 指针，不是对象 → detach 后必炸。
• C++17：用 [*this] 手动拷贝对象 → 安全。
• C++20+：[=] 自动变成 [*this] → 终于默认安全了。
• 引用捕获：
• 引用捕获的体积永远是 8 字节（64位机器），不管你捕获的是 int 还是一个 10MB 的大对象。
• 一旦被捕获的变量生命周期结束，lambda 里保存的地址就变成悬垂引用（dangling reference）。
• C++ 标准明确说：使用悬垂引用是未定义行为（Undefined Behavior），可能崩溃、可能打印旧值、可能被别的对象覆盖。