写一段cPP代码解决8皇后问题

### 回答1：

#include <iostream>
using namespace std;
const int N = 8;
int q[N], cnt;

bool check(int k) {
    for (int i = 0; i < k; i++) {
        if (q[i] == q[k] || abs(q[i] - q[k]) == abs(i - k)) {
            return false;
        }
    }
    return true;
}

void dfs(int k) {
    if (k == N) {
        cnt++;
        return;
    }
    for (int i = 0; i < N; i++) {
        q[k] = i;
        if (check(k)) {
            dfs(k + 1);
        }
    }
}

int main() {
    dfs(0);
    cout << cnt << endl;
    return 0;
}

该代码使用深度优先搜索 (DFS) 解决 8 皇后问题。数组 q[] 存储每一行皇后的位置，函数 check() 用来检查每一个皇后是否合法，函数 dfs() 递归地枚举所有可能的皇后位置，最终结果存储在 cnt 变量中。

### 回答2：
以下是一个用C++解决8皇后问题的示例代码：

#include <iostream>
#include <vector>

using namespace std;

// 判断当前位置是否可以放置皇后
bool canPlaceQueen(vector<int>& board, int row, int col) {
    // 检查列是否有冲突
    for (int i = 0; i < row; i++) {
        if (board[i] == col)
            return false;
    }

    // 检查左上对角线是否有冲突
    for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
        if (board[i] == j)
            return false;
    }

    // 检查右上对角线是否有冲突
    for (int i = row - 1, j = col + 1; i >= 0 && j < board.size(); i--, j++) {
        if (board[i] == j)
            return false;
    }

    return true;
}

// 回溯法求解8皇后问题
void solveNQueens(vector<int>& board, int row, vector<vector<int>>& solutions) {
    if (row == board.size()) {
        // 找到一个解决方案
        solutions.push_back(board);
        return;
    }

    for (int col = 0; col < board.size(); col++) {
        if (canPlaceQueen(board, row, col)) {
            board[row] = col;
            solveNQueens(board, row + 1, solutions);
        }
    }
}

// 打印解决方案
void printSolution(vector<int>& board) {
    for (int row = 0; row < board.size(); row++) {
        for (int col = 0; col < board.size(); col++) {
            if (board[row] == col)
                cout << "Q ";
            else
                cout << ". ";
        }
        cout << endl;
    }
    cout << endl;
}

int main() {
    vector<int> board(8, 0);
    vector<vector<int>> solutions;
    solveNQueens(board, 0, solutions);

    // 打印所有解决方案
    for (auto& solution : solutions) {
        printSolution(solution);
    }

    return 0;
}

这段代码使用回溯法求解8皇后问题，其中定义了两个函数`canPlaceQueen`和`solveNQueens`。`canPlaceQueen`函数用于判断当前位置是否可以放置皇后，`solveNQueens`函数使用回溯法递归地求解8皇后问题，并将解决方案保存在`solutions`中。最后，通过调用`printSolution`函数打印所有解决方案。

这段代码的运行结果会输出所有的解决方案，每一个解决方案都以棋盘形式进行展示，其中`Q`表示皇后的位置，`.`表示空的位置。

### 回答3：
下面是用C++解决8皇后问题的代码：

#include <iostream>
#include <vector>

using namespace std;

bool isSafe(vector<vector<int>>& board, int row, int col) {
    // 检查列上是否安全
    for (int i = 0; i < row; i++) {
        if (board[i][col] == 1) {
            return false;
        }
    }

    // 检查主对角线上是否安全
    for (int i = row, j = col; i >= 0 && j >= 0; i--, j--) {
        if (board[i][j] == 1) {
            return false;
        }
    }

    // 检查副对角线上是否安全
    for (int i = row, j = col; i >= 0 && j < board.size(); i--, j++) {
        if (board[i][j] == 1) {
            return false;
        }
    }

    return true;
}

bool solveNQueens(vector<vector<int>>& board, int row) {
    int N = board.size();

    // 所有行都放置完毕，打印结果
    if (row == N) {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                cout << board[i][j] << " ";
            }
            cout << endl;
        }
        cout << endl;
        return false;
    }

    // 尝试放置皇后
    for (int col = 0; col < N; col++) {
        if (isSafe(board, row, col)) {
            board[row][col] = 1;

            // 递归尝试下一行
            if (solveNQueens(board, row + 1)) {
                return true;
            }

            // 回溯
            board[row][col] = 0;
        }
    }

    return false;
}

int main() {
    int N = 8; // 8皇后问题
    vector<vector<int>> board(N, vector<int>(N, 0)); // 初始化棋盘

    solveNQueens(board, 0); // 解决8皇后问题

    return 0;
}

该代码使用回溯算法来解决8皇后问题，通过递归地尝试在每一行放置一个皇后，并检查是否安全，一旦找到解决方案，就打印结果。如果某个皇后的放置不安全，就回溯到上一行继续尝试。通过这种方式，我们可以找到所有合法的解决方案。