8皇后问题详细过程

最新推荐文章于 2024-06-06 09:15:00 发布
原创 最新推荐文章于 2024-06-06 09:15:00 发布 · 2.7k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#C++ #算法 #回溯 #递归

八皇后问题

在一个8x8的棋盘上，每行每列防止棋子“皇后”，”皇后“不能在同一行，同一列同一条斜线上。
这里写图片描述
对于这个问题通常的做法是：
1. 在一行第一个位置放置一个
2. 遍历第二行，如果找到第一个可放置的位置，则放置，遍历下一行。否则跳转到上一行遍历下一个位置。
3. 一直重复直到所有的位置都被遍历完。
为了便于说明，下面使用4皇后说明。

四皇后坐标
00010203
10111213
20212223
30313233
22坐标的正对角线坐标和
0
2
22
6
22坐标的负对角线坐标差(x-y)
-2
22
2

可以得出：正对角线坐标和范围为0～(n-1)*2(2为皇后数量),总个数为2n-1,负对角线的差范围-(n-1)~(n-1),总个数为2n-1个。.
对于4皇后问题的解的完整处理过程如下：
这里写图片描述
这里写图片描述
这里写图片描述
代码实现：
n=4 副对角线上的元素为-3~3 为了能处理负数，统一给代码加上n-1,详情查看代码rightDiagonal[row-col+norm]

#include <iostream>
using namespace std;
class ChessBoard{
private:
    const bool available;
    const int squares,norm;                     //norm为了将副对角线差变换到非负数
    bool *column,*leftDiagonal,*rightDiagonal;
    int *positionInRow,howMany;
    void putQueen(int);
    ostream & printBoard(ostream &);
    void initializeBoard();
public:
    ChessBoard();
    ChessBoard(int);
    ~ChessBoard();
    void findSolution();
};
ChessBoard::~ChessBoard() {
    delete [] positionInRow;
    delete [] column;
    delete [] leftDiagonal;
}
ChessBoard::ChessBoard():available(true),squares(8),norm(squares-1){
    initializeBoard();
}
ChessBoard::ChessBoard(int n):available(true),squares(n),norm(squares-1) {
    initializeBoard();
}
void ChessBoard::initializeBoard() {
    int i;
    column = new bool[squares];             //放置行
    positionInRow = new int[squares];       //放置位置
    leftDiagonal = new bool[squares*2-1];   //左边斜线
    rightDiagonal = new bool [squares*2-1]; //右边斜线
    for(i = 0;i<squares;i++)
        positionInRow[i] = -1;
    for(i=0;i<squares;i++)
        column[i] = available;
    for(i=0;i<squares*2-1;i++)
        leftDiagonal[i] = rightDiagonal[i] = available;
    howMany = 0;
}
void ChessBoard::putQueen(int row) {
    cout<<"函数开始：当前行为: "<<row<<"行,遍历不同的列col"<<endl;
    for (int col = 0; col < squares; col++){
        cout<<"for循环：循环开始在"<<row<<"行,"<<col<<"列!"<<endl;

        if(column[col] == available &&leftDiagonal [row+col] == available &&rightDiagonal[row-col+norm] == available) {
            cout<<"判断：经判断"<<col<<"列能放,列放置位置: "<<"("<<row<<","<<col<<")"<<"进入下一行:"<<row+1<<endl;
            //放置皇后在row
            positionInRow[row] = col;
            column[col] = !available;
            leftDiagonal[row+col] = !available;
            rightDiagonal[row-col+norm] = !available;
            if (row < squares-1)
                putQueen(row+1);
            else{
                printBoard(cout);
                howMany+=1;
                cout<<"找到第"<<howMany<<"个结果"<<endl;
            }
            column[col] = available;
            leftDiagonal[row+col] = available;
            rightDiagonal[row-col+norm] = available;
        }
        if(col==squares-1)
        {
            if(row-1>=0)
                cout<<"当前行遍历完成！跳到上一行"<<row-1<<endl;
        }

    }
}
ostream & ChessBoard::printBoard(ostream &os) {
//    cout<<"当前行为: "<<col<<"\n";
    return os;
}
void ChessBoard::findSolution() {
    putQueen(0);
    cout<<"\n";
    cout<<howMany<<" Solutions found.\n";
}

int main() {
    ChessBoard c1(4);
    c1.findSolution();
    return 0;
}

输出如下：

函数开始：当前行为: 0行,遍历不同的列col
for循环：循环开始在0行,0列!
判断：经判断0列能放,列放置位置: (0,0)进入下一行:1
函数开始：当前行为: 1行,遍历不同的列col
for循环：循环开始在1行,0列!
for循环：循环开始在1行,1列!
for循环：循环开始在1行,2列!
判断：经判断2列能放,列放置位置: (1,2)进入下一行:2
函数开始：当前行为: 2行,遍历不同的列col
for循环：循环开始在2行,0列!
for循环：循环开始在2行,1列!
for循环：循环开始在2行,2列!
for循环：循环开始在2行,3列!
当前行遍历完成！跳到上一行1
for循环：循环开始在1行,3列!
判断：经判断3列能放,列放置位置: (1,3)进入下一行:2
函数开始：当前行为: 2行,遍历不同的列col
for循环：循环开始在2行,0列!
for循环：循环开始在2行,1列!
判断：经判断1列能放,列放置位置: (2,1)进入下一行:3
函数开始：当前行为: 3行,遍历不同的列col
for循环：循环开始在3行,0列!
for循环：循环开始在3行,1列!
for循环：循环开始在3行,2列!
for循环：循环开始在3行,3列!
当前行遍历完成！跳到上一行2
for循环：循环开始在2行,2列!
for循环：循环开始在2行,3列!
当前行遍历完成！跳到上一行1
当前行遍历完成！跳到上一行0
for循环：循环开始在0行,1列!
判断：经判断1列能放,列放置位置: (0,1)进入下一行:1
函数开始：当前行为: 1行,遍历不同的列col
for循环：循环开始在1行,0列!
for循环：循环开始在1行,1列!
for循环：循环开始在1行,2列!
for循环：循环开始在1行,3列!
判断：经判断3列能放,列放置位置: (1,3)进入下一行:2
函数开始：当前行为: 2行,遍历不同的列col
for循环：循环开始在2行,0列!
判断：经判断0列能放,列放置位置: (2,0)进入下一行:3
函数开始：当前行为: 3行,遍历不同的列col
for循环：循环开始在3行,0列!
for循环：循环开始在3行,1列!
for循环：循环开始在3行,2列!
判断：经判断2列能放,列放置位置: (3,2)进入下一行:4
找到第1个结果
for循环：循环开始在3行,3列!
当前行遍历完成！跳到上一行2
for循环：循环开始在2行,1列!
for循环：循环开始在2行,2列!
for循环：循环开始在2行,3列!
当前行遍历完成！跳到上一行1
当前行遍历完成！跳到上一行0
for循环：循环开始在0行,2列!
判断：经判断2列能放,列放置位置: (0,2)进入下一行:1
函数开始：当前行为: 1行,遍历不同的列col
for循环：循环开始在1行,0列!
判断：经判断0列能放,列放置位置: (1,0)进入下一行:2
函数开始：当前行为: 2行,遍历不同的列col
for循环：循环开始在2行,0列!
for循环：循环开始在2行,1列!
for循环：循环开始在2行,2列!
for循环：循环开始在2行,3列!
判断：经判断3列能放,列放置位置: (2,3)进入下一行:3
函数开始：当前行为: 3行,遍历不同的列col
for循环：循环开始在3行,0列!
for循环：循环开始在3行,1列!
判断：经判断1列能放,列放置位置: (3,1)进入下一行:4
找到第2个结果
for循环：循环开始在3行,2列!
for循环：循环开始在3行,3列!
当前行遍历完成！跳到上一行2
当前行遍历完成！跳到上一行1
for循环：循环开始在1行,1列!
for循环：循环开始在1行,2列!
for循环：循环开始在1行,3列!
当前行遍历完成！跳到上一行0
for循环：循环开始在0行,3列!
判断：经判断3列能放,列放置位置: (0,3)进入下一行:1
函数开始：当前行为: 1行,遍历不同的列col
for循环：循环开始在1行,0列!
判断：经判断0列能放,列放置位置: (1,0)进入下一行:2
函数开始：当前行为: 2行,遍历不同的列col
for循环：循环开始在2行,0列!
for循环：循环开始在2行,1列!
for循环：循环开始在2行,2列!
判断：经判断2列能放,列放置位置: (2,2)进入下一行:3
函数开始：当前行为: 3行,遍历不同的列col
for循环：循环开始在3行,0列!
for循环：循环开始在3行,1列!
for循环：循环开始在3行,2列!
for循环：循环开始在3行,3列!
当前行遍历完成！跳到上一行2
for循环：循环开始在2行,3列!
当前行遍历完成！跳到上一行1
for循环：循环开始在1行,1列!
判断：经判断1列能放,列放置位置: (1,1)进入下一行:2
函数开始：当前行为: 2行,遍历不同的列col
for循环：循环开始在2行,0列!
for循环：循环开始在2行,1列!
for循环：循环开始在2行,2列!
for循环：循环开始在2行,3列!
当前行遍历完成！跳到上一行1
for循环：循环开始在1行,2列!
for循环：循环开始在1行,3列!
当前行遍历完成！跳到上一行0
codeup-------八皇后问题
qq_42499471的博客
11-23 384
问题 D: 八皇后 [命题人 :外部导入] 时间限制 :1.000sec内存限制 :32 MB 解决: 1160提交: 2092统计 题目描述 会下国际象棋的人都很清楚：皇后可以在横、竖、斜线上不限步数地吃掉其他棋子。如何将8个皇后放在棋盘上（有8 * 8个方格），使它们谁也不能被吃掉！这就是著名的八皇后问题。 对于某个满足要求的8皇后的摆放方法，定义一个皇后串a与之对应，即a=b1b2...b8，其中bi为相应摆法中第i行皇后所处的列数。已经知道8皇后问题一共有92组解（即92...
数据结构与算法 — 八皇后问题(回溯算法)
我会二进制
08-15 5965
问题描述 在8×8格的国际象棋上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 假设上图中红点为一个皇后的位置，那么他的同行，列，斜线上都不能再放置其他皇后(也就是红线覆盖的位置) 此图为八皇后问题的其中一种解法，目前已经有人用图论的方法解出92种结果。 思路分析 一、如何实现 这就和我们人做这种题的时候一样，所有放置皇后的过程都是一行一行来的，首先将第一行的皇后放在第一个位置，然后再看第二行。最开始也是将第二行的皇后放在第二行的第一个位置，发现冲突
八皇后问题 (25分)
黄大仙
10-06 3982
在国际象棋中，皇后是最厉害的棋子，可以横走、直走，还可以斜走。棋手马克斯·贝瑟尔 1848 年提出著名的八皇后问题：即在 8 × 8 的棋盘上摆放八个皇后，使其不能互相攻击 —— 即任意两个皇后都不能处于同一行、同一列或同一条斜线上。例如： 题图.jpg 现在我们把棋盘扩展到 n×n 的棋盘上摆放 n 个皇后，请问该怎么摆？ 请编写程序，输入正整数 n，输出全部摆法（棋盘格子空白处显示句点“.”，皇后处显示字母“Q”，每两个字符之间空一格）。 输入格式 正整数 n(n>0) 输出格式 若问题有解，则
八皇后问题解法
tylong2012的专栏
04-08 1520
8皇后是个经典的问题，如果使用暴力法，每个格子都去考虑放皇后与否，一共有264 种可能。所以暴力法并不是个好办法。由于皇后们是不能放在同一行的， 所以我们可以去掉“行”这个因素，即我第1次考虑把皇后放在第1行的某个位置， 第2次放的时候就不用去放在第一行了，因为这样放皇后间是可以互相攻击的。 第2次我就考虑把皇后放在第2行的某个位置，第3次我考虑把皇后放在第3行的某个位置， 这样依次去递归。每
八皇后问题
R的博客
08-13 148
注意主对角线和副对角线的判断 #include <stdio.h> int pat[8][8] = {0}; int count = 0; void findQueen(int row); void printQueen(); bool check(int row,int column); void findQueen(int row) { if(row > 7) {...
八皇后问题详细的解法-23页 PPT PDF版.pdf
06-10
- 八皇后问题的非递归回溯算法：使用栈等数据结构代替递归来实现回溯过程，这种方法更加灵活，但在实际应用中不如递归方法常见。 通过以上分析可以看出，八皇后问题的不同解法各有特点，从简单的枚举算法到高效的...
精选资源
python+pygame实现可视化8皇后问题/N皇后问题.zip
11-18
本项目名为“python+pygame实现可视化8皇后问题/N皇后问题”，其中包含的文件如下： 1. **结果演示.mp4**：这是一个视频文件，展示了使用Python和Pygame实现的N皇后问题的运行效果。通过动态演示，用户可以看到皇后...
八皇后问题详细的解法PPT课件.ppt
11-03
八皇后问题是一个经典的组合数学问题，起源于19世纪中期的国际象棋，目的是在8×8的棋盘上放置八个皇后，使得它们互不攻击。即，任两个皇后都不能处在同一行、同一列或同一对角线上。问题可表述为：如何放置八个皇后...
C++递归法解决八皇后问题详细教程
八皇后问题是一个经典的计算机科学问题，它要求在一个8×8的棋盘上放置八个皇后，使得它们互不攻击。所谓“互不攻击”，是指任意两个皇后都不在同一行、同一列或同一对角线上。八皇后问题可以推广到N皇后问题，即在...
八皇后问题详解（附有C++详细代码）
Weirdo的博客
06-06 7147
八皇后问题是一个经典的回溯算法问题，通过求解该问题，我们可以深入理解回溯算法的基本思想和应用方法。解决八皇后问题的关键在于找到一个有效的算法来搜索所有可能的摆放方式，并在搜索过程中进行剪枝，以避免不必要的搜索。在摆放过程中，需要判断当前位置是否合法，即是否与其他皇后冲突。该问题描述为：在8×8的国际象棋上摆放八个皇后，使其不能互相攻击，即任何两个皇后都不能处于同一行、同一列或同一斜线上。由于八皇后问题有92种不同的摆放方式，因此输出会包含92行，每行8个数字，表示一种摆放方案中每个皇后在棋盘上的列位置。
四皇后问题
一飞冲天的小天地
10-07 5982
#include #include #include int k=1;int queen[4]; //四个皇后的列的坐标void Queen();void PrintQueen(); //输出当前四个皇后的位置bool CheckSafe(); //检查当前已经放置的皇后的位置是否安全void main(){ Queen();}void Queen(){ if(k>4) //四个皇后的
zufeoj_八皇后
Mongo_girl
07-03 809
题目链接：http://acm.ocrosoft.com/problem.php?cid=1172&amp;pid=41题目描述会下国际象棋的人都很清楚：皇后可以在横、竖、斜线上不限步数地吃掉其他棋子。如何将8个皇后放在棋盘上（有8 × 8个方格），使它们谁也不能被吃掉！这就是著名的八皇后问题。对于某个满足要求的8皇后的摆放方法，定义一个皇后串a与之对应，即a=b1b2...b8a=b1b2......
8皇后
weixin_40488730的博客
10-25 241
首先设置一个数组vis[i]表示第i行vis[i]列有皇后，然后通过对每一行的皇后进行尝试 未完待续 #include &amp;amp;lt;iostream&amp;amp;gt; #include &amp;amp;lt;stdio.h&amp;amp;gt; #include &amp;amp;lt;csting&amp;amp;gt; #include &amp;amp;lt;algorithm&amp;amp;gt; u
八皇后
huskyui
09-11 554
终于写完了，听说有92种排序方式，看了不少博客，看到这句话，看别人代码百遍，不如自己写一遍，然后看别人代码，太简洁，没看懂，还是自己写 写了好久，终于成功了，记得加油，下面这个图很魔性，写卡了的时候，可以看看图，继续写
Java尚硅谷数据结构与算法学习记录(7)-递归问题
qq_38715538的博客
06-21 399
递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂的问题,同时 可以让代码变得简洁。 递归需要遵守的重要规则： 执行一个方法时，就创建一个新的受保护的独立空间(栈空间) 方法的局部变量是独立的，不会相互影响, 比如n变量 如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据. 递归必须向退出递归的条件逼近，否则就是无限递归,出现StackOverflowError，死龟了:) 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当
非递归实现皇后问题
最新发布
04-03
<think>好的，用户想了解如何用非递归方式解决八皇后问题，尤其是算法或代码实现。首先，我需要回顾一下八皇后问题的基本要求和递归解法，然后思考如何将其转换为非递归形式。 八皇后问题要求在8x8的棋盘上放置八个皇后，使得它们互不攻击。这意味着每行、每列、每条主对角线和次对角线上都只有一个皇后。递归解法通常使用回溯，逐行尝试放置皇后，并在冲突时回溯到上一行调整位置。 用户需要非递归的实现，这通常需要手动模拟递归的栈结构。递归中的栈保存了函数调用的状态，包括当前行、列的位置以及已放置皇后的信息。非递归算法需要用显式的栈来保存这些状态，并在循环中处理回溯逻辑。 接下来，我需要参考用户提供的引用资料。引用[3]提到非递归算法使用栈结构模拟递归，且需要注意记录下一次迭代的起点。引用[4]提到使用数组来记录列、主对角线和次对角线的占用情况。这些信息对设计非递归算法非常重要。 设计步骤可能包括： 1. 初始化栈，从第0行开始尝试放置皇后。 2. 对于每一行，从当前列开始寻找可放置的位置。 3. 如果找到合法位置，记录列、对角线状态，并将下一行压入栈。 4. 如果无法找到，弹出栈顶，回溯到上一行，继续尝试下一个列。 5. 当栈顶的行数达到8时，表示找到解，记录并继续寻找其他解。 需要注意的是，每次回溯时需要恢复列、对角线等状态变量的值，确保下一次尝试的正确性。同时，非递归实现的效率可能略高于递归，因为减少了函数调用的开销。 现在，需要编写代码示例。根据引用中的C语言实现，可能使用数组来跟踪列、主对角线和次对角线的占用情况。每次放置皇后时标记这些位置，回溯时取消标记。栈中保存当前行和列的位置，以便回溯时继续搜索。 最后，验证算法是否正确，是否能够找到所有可能的解，并确保没有遗漏或重复的情况。此外，代码的可读性和效率也需要考虑，比如合理使用循环和条件判断来优化搜索过程。</think>### 非递归方式解决八皇后问题的算法实现 #### 核心思路 非递归算法通过**手动维护栈结构**模拟递归的回溯过程，具体步骤为： 1. 用栈保存当前处理的行号`row`和列号`col`； 2. 用数组标记列、主对角线、次对角线是否被占用； 3. 通过循环逐行尝试放置皇后，冲突时回溯到上一行。 #### 算法步骤 1. **初始化**：栈中压入初始状态`(row=0, col=0)`； 2. **循环处理栈顶**： - 若当前行`row=8`，说明找到解，记录并回溯； - 否则在当前行中寻找可放置的列： - 若找到合法列，标记占用状态，压入下一行的初始列`(row+1, 0)`； - 若未找到，弹出栈顶回溯到上一行，恢复状态并尝试下一列。 --- #### C语言代码实现 ```c #include <stdio.h> #define N 8 int col[N] = {0}; // 列占用标记 int md[2*N-1] = {0}; // 主对角线标记（row - col + N-1） int sd[2*N-1] = {0}; // 次对角线标记（row + col） int stack[N][2]; // 模拟栈，保存(row, col) int top = -1; // 栈顶指针 void push(int row, int c) { top++; stack[top][0] = row; stack[top][1] = c; } void pop() { top--; } // 检查当前位置(row, c)是否合法 int is_valid(int row, int c) { return !col[c] && !md[row - c + N - 1] && !sd[row + c]; } void solve() { int row = 0, c = 0; push(row, c); while (top >= 0) { row = stack[top][0]; c = stack[top][1]; pop(); // 恢复状态（若之前已放置） if (row > 0) { int prev_c = stack[top][1]; col[prev_c] = md[row-1 - prev_c + N-1] = sd[row-1 + prev_c] = 0; } while (c < N) { if (is_valid(row, c)) { col[c] = md[row - c + N-1] = sd[row + c] = 1; push(row, c); if (row == N-1) { // 找到解 print_solution(); } else { // 处理下一行 push(row+1, 0); break; } } c++; } } } ``` --- #### 关键点说明 1. **状态恢复**：每次回溯时需要撤销当前行对列、对角线的占用标记[^3][^4]； 2. **栈操作**：通过`push`和`pop`模拟递归调用栈，保存搜索路径； 3. **时间复杂度**：与递归算法相同，均为$O(N!)$，但减少了函数调用开销[^3]。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值