八皇后问题 回溯法 C++ 含迭代器

最新推荐文章于 2024-06-06 09:15:00 发布
最新推荐文章于 2024-06-06 09:15:00 发布
阅读量1.7k 收藏 11
点赞数 4
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yingchunhua365/article/details/16959579
版权
#ifndef POSITION
#define POSITION

class Position
{
    protected:
        int row,column;

    public:
        Position();
        Position (int row, int column);
        int getRow() const;
        int getColumn() const;
int getnum_of_queen() const;
void setPosition(int newRow,int newColumn);
}; // class Position

#endif


#ifndef BACKTRACK
#define BACKTRACK
#include "Application.h";
#include "Position.h";
class BackTrack  
{
    public:
        BackTrack (const Application& app);
        bool tryToSolve (Position pos);
    protected:
        Application app;
}; // class BackTrack
#endif



#ifndef APPLICATION
#define APPLICATION
#include <iostream>
#include "Position.h"
using namespace std;
class Application
{
    friend ostream& operator<<(ostream& stream, Application& app);
    public:
        // Postcondition: the initial state for this Application has been
        //                generated -- from input or assignments -- and
        //                the start position has been returned.
        Position generateInitialState();
        // Postcondition: true has been returned if pos can be on the path
        //                to a goal.  Otherwise, false has been returned.
        bool valid (const Position& pos);

        // Precondition: pos represents a valid position.
        // Postcondition: pos has been recorded as a valid position.

        void record (const Position& pos);

        // Postcondition: true has been returned if pos is the final
        //                position for this application.  Otherwise, false
        //                has been returned.

        bool done () const;

        // Postcondition: pos has been marked as not being on the path to
        //                a goal.
        void undo (const Position& pos);      
    class Iterator
    {
protected:
            void* fieldPtr;
        public:
            // Postcondition: this Iterator has been initialized to
            //                iterate from pos.
            Iterator (const Position& pos);

            // Postcondition: the next position for this Iterator has
            //                been returned.
            Position operator++ (int);

            // Postcondition: this Iterator cannot iterate any further.
            bool atEnd();
    }; // class Iterator
}; // class Application
#endif


///主要部分
#include "Application.h"
#include "Position.h"
#include <iostream>
#include <string>
#include <Math.h>

const short QUEEN= 9;
const short ROWS = 8;
const short COLUMNS = 8;
const short TRIED = 2;
short ChessBoard[8][8];
short NUM_OF_QUEEN=0;

//int newRow=0;


Position start;

using namespace std;

struct itrFields
{
int row,column,direction_x,direction_y;
};//itrFields

Position Application::generateInitialState()
{
for(int i=0;i<8;i++)
{
for(int j=0;j<8;j++)
{
ChessBoard[i][j]=0;
cout<<ChessBoard[i][j]
    <<" ";
if(j==7) cout<<endl;
}
}//初始化棋盘并输出整个棋盘

    const string START_PROMPT =
        "Please enter the start row and start column: ";

    int row,column;
cout<<"请输入第一个皇后的位置(纵坐标1~8，横坐标1~8)：";
cin>>row>>column;
    start.setPosition (row-1, column-1);
cout<<endl<<endl;
    return start;//获取并返回第一个皇后的位置

} // method generateInitialState


bool Application::valid (const Position& pos)
{
bool flag=true;
if(pos.getRow()+1>8||pos.getRow()+1<1||pos.getColumn()+1>8||
pos.getColumn()+1<1)
flag=false;
if(flag)
for(int i=0;i<8;i++)
{
if(i==pos.getColumn()) continue;
if(ChessBoard[pos.getRow()][i]==9)  {flag=false;break;}
}//检查横行是否有皇后
if(flag)
for(int j=0;j<8;j++)
{
if(j==pos.getRow()) continue;
if(ChessBoard[j][pos.getColumn()]==9) {flag=false;break;}
}//检查竖行是否有皇后
if(flag)
for(int r=0;r<8;r++)
{
for(int c=0;c<8;c++)
{
if(r==pos.getRow()&&c==pos.getColumn()) continue;
if(abs(r-pos.getRow())==abs(c-pos.getColumn()))
{
if(ChessBoard[r][c]==9) {flag=false;break;}
}
}
if(!flag) break;
}//检查左斜，右斜有没有皇后

// if(flag) newRow++;
return flag;
}

//标记皇后
void Application::record(const Position& pos)
{
ChessBoard[pos.getRow()][pos.getColumn()]=QUEEN;
NUM_OF_QUEEN++;
}
// 判断八个皇后是否已经都摆上
bool Application::done () const
{
// cout<<NUM_OF_QUEEN;
return NUM_OF_QUEEN==8;
}

void Application::undo(const Position& pos)
{
if(ChessBoard[pos.getRow()][pos.getColumn()]==9) 
    NUM_OF_QUEEN--;
ChessBoard[pos.getRow()][pos.getColumn()]=0;
}

ostream& operator<<(ostream& stream, Application& app)
{
cout<<endl;
for(int row=0;row<ROWS;row++)
{
for(int column=0;column<COLUMNS;column++)
cout<<ChessBoard[row][column]<<" ";
cout<<endl;
}//outfor
return stream;
}//operation <<


Application::Iterator::Iterator(const Position& pos)
{
itrFields* itrPtr=new itrFields;
itrPtr->row=pos.getRow();
itrPtr->column=pos.getColumn();
itrPtr->direction_x=pos.getRow();
itrPtr->direction_y=0;
fieldPtr=itrPtr;
}//constructor

Position Application::Iterator::operator ++(int)
{
itrFields* itrPtr=(itrFields*)fieldPtr;
int nextRow = itrPtr -> row,
        nextColumn = itrPtr -> column;
switch(itrPtr->direction_x)
{
case 0:nextRow=0;break;
case 1:nextRow=1;break;
case 2:nextRow=2;break;
case 3:nextRow=3;break;
case 4:nextRow=4;break;
case 5:nextRow=5;break;
case 6:nextRow=6;break;
case 7:nextRow=7;break;
}
    switch(itrPtr -> direction_y++)
{
case 0:nextColumn=0;break;
case 1:nextColumn=1;break;
case 2:nextColumn=2;break;
case 3:nextColumn=3;break;
case 4:nextColumn=4;break;
case 5:nextColumn=5;break;
case 6:nextColumn=6;break;
case 7:nextColumn=7;break;
}
//cout<<nextRow<<nextColumn<<" ";
Position next(nextRow+1,nextColumn);
return next;
}//operator++

bool Application::Iterator::atEnd()
{
if(((itrFields*)fieldPtr)->direction_x>7||
((itrFields*)fieldPtr)->direction_y>7)
     return true;
return false;
}

#include "Position.h"

Position::Position()
{
    row = 0;
    column = 0;
} // default constructor

Position::Position (int row, int column)
{
    this -> row = row;
    this -> column = column;
} // constructor

void Position::setPosition(int newRow,int newColumn)
{
this->row=newRow;
this->column=newColumn;
}


int Position::getRow() const
{
    return row;
} // method getRow()


int Position::getColumn() const
{
    return column;
} // method getColumn()


#include <iostream>
#include <string>
#include "BackTrack.h"
#include "Application.h"
#include "Position.h"

 
using namespace std;

int main()
{
    Application app;

BackTrack b(app);

cout<<"初始化棋盘：\n";
Position start=app.generateInitialState();

if(!app.valid(start))
cout<<"您的输入有误！"<<endl;
else
{
app.record(start);
if(app.done() || b.tryToSolve(start))
cout<<"八个皇后已经正确摆放！"<<endl<<app;
else
{
cout<<app<<endl;
app.undo(start);
cout<<"八个皇后没有正确摆放！"<<endl;
}
}
cout<<endl<<endl;

system("pause");

return 0;
}


#include "BackTrack.h"

BackTrack::BackTrack (const Application& app)
{
    this -> app = app;
} // constructor

bool BackTrack::tryToSolve (Position pos)
{
    bool success = false;
    Application::Iterator itr (pos);
    while (!success && !itr.atEnd())
    {
        pos = itr++;
        if (app.valid (pos))
        {
            app.record (pos);
            if (app.done ())
                success = true;
            else
            {
                success = tryToSolve (pos);
//if(!success) cout<<1;
if (!success)
{   
app.undo(pos); 
}
            } // not done
        }
    } // while
    return success;
} // method tryToSolve

读书与远方
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
搜索与回溯算法之八皇后问题
wmoxie的博客
04-22 1430
搜索与回溯算法之八皇后问题 问题 要在国际象棋棋盘中放八个皇后，使任意两个皇后都不能互相吃。（提示：皇后能吃同一行、同一列、同一对角线的任意棋子。） 放置第ｉ个(行)皇后的算法为： int search(i)； 　{ 　　 int j; 　　　for (第i个皇后的位置j=1;j<=8;j++ ) //在本行的8列中去试 　　　if (本行本列允许放置皇后) 　　　　{ 　　　　　放置第i个皇后； 对放置皇后的位置进行标记； 　　　　　if (i==8) 输出
【算法】回溯法解决八皇后问题C/C++实现
weixin_44022583的博客
04-28 1023
八皇后问题，一个古老而著名的问题，是回溯算法的典型案例。该问题由国际西洋棋棋手马克斯·贝瑟尔于 1848 年提出：在 8×8 格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 共有92种解法，代码如下： #include<iostream> using namespace std; int count = 0; int...
八皇后问题汇总（C++版）
小芒果的博客
02-11 1万+
这就是著名的八皇后问题。问题表述为：在8×8格的国际象棋上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。首先，如果每一次都去进行深搜的话一定会出现超时问题，所以最好的办法是先进行一次深搜，然后在深搜的过程中存储每一种方案，这样在进行输出是只需要从保存的方案中拿出来就可以了，时间复杂度为O(1)。8]表示皇后的放置：第i行皇后放在第j列，用a[i]=j来表示，即下标是行数，内容是列数。如果在/斜线上，则行列值之和相同，如果在\斜线上，则行列值之差相同。
[C++实现]八皇后问题
m0_71229255的博客
03-10 3087
所谓递归回溯，本质上是一种枚举法。这种方法从棋盘的第一行开始尝试摆放第一个皇后，摆放成功后，递归一层，再遵循规则在棋盘第二行来摆放第二个皇后。如果当前位置无法摆放，则向右移动一格再次尝试，如果摆放成功，则继续递归一层，摆放第三个皇后...... 　　如果某一层看遍了所有格子，都无法成功摆放，则回溯到上一个皇后，让上一个皇后右移一格，再进行递归。如果八个皇后都摆放完毕且符合规则，那么就得到了其中一种正确的解法。说起来有些抽象，我们来看一看递归回溯的详细过程。
八皇后问题详解（附有C++详细代码）
Weirdo的博客
06-06 1403
八皇后问题是一个经典的回溯算法问题，通过求解该问题，我们可以深入理解回溯算法的基本思想和应用方法。解决八皇后问题的关键在于找到一个有效的算法来搜索所有可能的摆放方式，并在搜索过程中进行剪枝，以避免不必要的搜索。在摆放过程中，需要判断当前位置是否合法，即是否与其他皇后冲突。该问题描述为：在8×8的国际象棋上摆放八个皇后，使其不能互相攻击，即任何两个皇后都不能处于同一行、同一列或同一斜线上。由于八皇后问题有92种不同的摆放方式，因此输出会包含92行，每行8个数字，表示一种摆放方案中每个皇后在棋盘上的列位置。
八皇后问题详解（深度优先搜索）C++
Charles_Beiming的博客
08-24 2564
dfs解决八皇后问题
八皇后问题 ( C++ )
伊特
07-04 5264
    八皇后问题是一个以国际象棋为背景的问题：如何能够在 8×8 的国际象棋棋盘上放置八个皇后，使得任何一个皇后都无法直接吃掉其他的皇后？为了达到此目的，任两个皇后都不能处于同一条横行、纵行或斜线上。八皇后问题可以推广为更一般的n皇后摆放问题：这时棋盘的大小变为n1×n1，而皇后个数也变成n2。而且仅当 n2 = 1 或 n1 ≥ 4 时问题有解。#include&lt;iostream&gt;...
C++数据结构--回溯算法--八皇后问题
piniheaven的专栏
08-12 6883
1.回溯算法：       回溯算法也叫试探法，它是一种系统地搜索问题的解的方法 Example：八皇后问题 在8X8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、 同一列或同一斜线上，问有多少种摆法。 对于方格（ROWi,COLj)内的皇后，可对其攻击的皇后位置坐标（row,col)满足 上对角线：       col+row
C++类库与算法 STL 算法与分析 皇后问题回溯法实现程序源代码 回溯法示例代码
06-08
通过学习和理解这个回溯法解决的八皇后问题，你可以掌握如何运用C++类库和算法解决复杂问题，同时加深对回溯法的理解。这种问题解决策略不仅适用于皇后问题，还适用于许多其他约束优化问题，如数独、旅行商问题等。...
eight_queen_queen_C++_八皇后_
09-29
总结来说，八皇后问题是计算机科学中一个经典的算法示例，它涉及到逻辑判断、回溯法和递归等核心概念，是学习编程和算法的良好起点。通过C++实现八皇后问题，不仅可以深入理解这些概念，还能锻炼编程技巧和解决问题...
MFC实现n皇后算法(附报告)
06-02
STL（Standard Template Library）是C++标准库的一部分，包含了容器（如map和vector）、迭代器、算法和函数对象等组件。在解决n皇后问题时，`map`常用于存储每一行皇后的位置，键值为行号，值为该行皇后的列号；而`...
八皇后问题C++简单实现
03-21
重新使用c++简单地实现了回溯算法经典例子——八皇后问题，希望对大家有帮助
0基础学算法C++学习
最新发布
06-19
8. **回溯法和剪枝**：用于解决组合优化问题，如八皇后问题、N皇后问题等。 9. **计算几何**：涉及点、线、圆等几何对象的运算，如最近点对查找、凸包问题等。 通过深入理解和实践这些算法，不仅可以提高编程技能...
牛客校招C++宝典.rar
03-17
- **回溯法与贪心策略**：应用于组合优化问题，如八皇后问题、N皇后问题等。 - **数据结构**：链表、栈、队列、树（二叉树、平衡树如AVL和红黑树）的基础知识。 4. **数据库知识**： - **关系型数据库理论**：...
C++八皇后问题
whiteStruggle的博客
12-16 4356
八皇后问题是由国际西洋棋棋手马克斯·贝瑟尔于1848年提出的问题，是回溯算法的典型案例。 问题表述为：在8×8格的国际象棋上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 像这样的棋盘： 对棋盘行和列标号，可以使用 0~7 或 1~8，通过行数与列数进行加减计算，得到如下的内容： 行 - 列 和 行 +列，可以清晰的看到具有很明显的规律 行 - 列 ，红线的方向，从左到右，从上到下的斜线，取值范围 [-7 ， 7],，共15个元素 -7,-6,-5
C++知识精讲1——八个皇后（搜索与回溯）
Yu仙笙的博客
07-28 1656
C++知识精讲的第1篇，八个皇后。把知识点带入到实战，免费阅读，注释精讲知识点，希望大家前来阅读。如果喜欢此专栏请订阅持续关注。
八皇后问题(C++)
MJN
04-04 2万+
1、问题描述：在一个8*8的棋盘上放置8个皇后，不允许任何两个皇后在棋盘的同一行、同一列和同一对角线上。2、关键字：递归、上溯3、技巧：1）、经观察发现，对8 x 8的二维数组上的某点a[i][j](0其主对角线（即左上至右下）上的每个点的i-j+7的值（范围在(0,14)）均相等；其从对角线（即右上至左下）上的每个点的i+j的值（范围在(0,14)）均相等；且每个
【C/C++】回溯经典算法之-->八皇后问题
热门推荐
皓皓松的博客
07-09 5万+
一、八皇后问题 八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。
八皇后问题回溯法c++
04-28
八皇后问题是一个经典的回溯算法问题，它要求在一个8x8的棋盘上放置8个皇后，使得每个皇后都不会相互攻击（即不在同一行、同一列或同一对角线）。下面是使用C语言实现的八皇后问题回溯算法代码： ``` #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define N 8 int count = 0; // 统计解的个数 // 判断是否可以在第row行第col列放置皇后 bool canPlace(int row, int col, int board[N][N]) { // 检查列是否有皇后 for (int i = 0; i < row; i++) { if (board[i][col] == 1) { return false; } } // 检查左上对角线是否有皇后 for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) { if (board[i][j] == 1) { return false; } } // 检查右上对角线是否有皇后 for (int i = row - 1, j = col + 1; i >= 0 && j < N; i--, j++) { if (board[i][j] == 1) { return false; } } // 没有冲突 return true; } // 递归回溯放置皇后 void placeQueen(int row, int board[N][N]) { // 找到一个解 if (row == N) { count++; printf("Solution %d:\n", count); for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { printf("%d ", board[i][j]); } printf("\n"); } printf("\n"); return; } // 在当前行的每一列尝试放置皇后 for (int col = 0; col < N; col++) { if (canPlace(row, col, board)) { board[row][col] = 1; // 放置皇后 placeQueen(row + 1, board); // 递归放置下一行 board[row][col] = 0; // 回溯，撤回皇后 } } } int main() { int board[N][N] = {0}; // 初始化棋盘 placeQueen(0, board); // 从第0行开始放置皇后 printf("Total solutions: %d\n", count); return 0; } ``` 在上面的代码中，canPlace函数用于判断是否可以在第row行第col列放置皇后，placeQueen函数用于递归回溯放置皇后，count变量用于统计解的个数。在主函数中，初始化棋盘并从第0行开始放置皇后，最后输出解的个数。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值