八皇后问题 回溯法 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
    评论
专栏目录
C++类库与算法 STL 算法与分析 皇后问题回溯法实现程序源代码 回溯法示例代码
06-08
通过学习和理解这个回溯法解决的八皇后问题，你可以掌握如何运用C++类库和算法解决复杂问题，同时加深对回溯法的理解。这种问题解决策略不仅适用于皇后问题，还适用于许多其他约束优化问题，如数独、旅行商问题等。...
八皇后问题汇总（C++版）
小芒果的博客
02-11 1万+
这就是著名的八皇后问题。问题表述为：在8×8格的国际象棋上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。首先，如果每一次都去进行深搜的话一定会出现超时问题，所以最好的办法是先进行一次深搜，然后在深搜的过程中存储每一种方案，这样在进行输出是只需要从保存的方案中拿出来就可以了，时间复杂度为O(1)。8]表示皇后的放置：第i行皇后放在第j列，用a[i]=j来表示，即下标是行数，内容是列数。如果在/斜线上，则行列值之和相同，如果在\斜线上，则行列值之差相同。
[C++实现]八皇后问题
m0_71229255的博客
03-10 3046
所谓递归回溯，本质上是一种枚举法。这种方法从棋盘的第一行开始尝试摆放第一个皇后，摆放成功后，递归一层，再遵循规则在棋盘第二行来摆放第二个皇后。如果当前位置无法摆放，则向右移动一格再次尝试，如果摆放成功，则继续递归一层，摆放第三个皇后...... 　　如果某一层看遍了所有格子，都无法成功摆放，则回溯到上一个皇后，让上一个皇后右移一格，再进行递归。如果八个皇后都摆放完毕且符合规则，那么就得到了其中一种正确的解法。说起来有些抽象，我们来看一看递归回溯的详细过程。
八皇后问题详解（附有C++详细代码）
Weirdo的博客
06-06 1267
八皇后问题是一个经典的回溯算法问题，通过求解该问题，我们可以深入理解回溯算法的基本思想和应用方法。解决八皇后问题的关键在于找到一个有效的算法来搜索所有可能的摆放方式，并在搜索过程中进行剪枝，以避免不必要的搜索。在摆放过程中，需要判断当前位置是否合法，即是否与其他皇后冲突。该问题描述为：在8×8的国际象棋上摆放八个皇后，使其不能互相攻击，即任何两个皇后都不能处于同一行、同一列或同一斜线上。由于八皇后问题有92种不同的摆放方式，因此输出会包含92行，每行8个数字，表示一种摆放方案中每个皇后在棋盘上的列位置。
搜索与回溯算法之八皇后问题
wmoxie的博客
04-22 1417
搜索与回溯算法之八皇后问题 问题 要在国际象棋棋盘中放八个皇后，使任意两个皇后都不能互相吃。（提示：皇后能吃同一行、同一列、同一对角线的任意棋子。） 放置第ｉ个(行)皇后的算法为： int search(i)； 　{ 　　 int j; 　　　for (第i个皇后的位置j=1;j<=8;j++ ) //在本行的8列中去试 　　　if (本行本列允许放置皇后) 　　　　{ 　　　　　放置第i个皇后； 对放置皇后的位置进行标记； 　　　　　if (i==8) 输出
八皇后问题详解（深度优先搜索）C++
Charles_Beiming的博客
08-24 2483
dfs解决八皇后问题
C++八皇后问题
whiteStruggle的博客
12-16 4348
八皇后问题是由国际西洋棋棋手马克斯·贝瑟尔于1848年提出的问题，是回溯算法的典型案例。 问题表述为：在8×8格的国际象棋上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 像这样的棋盘： 对棋盘行和列标号，可以使用 0~7 或 1~8，通过行数与列数进行加减计算，得到如下的内容： 行 - 列 和 行 +列，可以清晰的看到具有很明显的规律 行 - 列 ，红线的方向，从左到右，从上到下的斜线，取值范围 [-7 ， 7],，共15个元素 -7,-6,-5
eight_queen_queen_C++_八皇后_
09-29
总结来说，八皇后问题是计算机科学中一个经典的算法示例，它涉及到逻辑判断、回溯法和递归等核心概念，是学习编程和算法的良好起点。通过C++实现八皇后问题，不仅可以深入理解这些概念，还能锻炼编程技巧和解决问题...
MFC实现n皇后算法(附报告)
06-02
STL（Standard Template Library）是C++标准库的一部分，包含了容器（如map和vector）、迭代器、算法和函数对象等组件。在解决n皇后问题时，`map`常用于存储每一行皇后的位置，键值为行号，值为该行皇后的列号；而`...
0基础学算法C++学习
最新发布
06-19
8. **回溯法和剪枝**：用于解决组合优化问题，如八皇后问题、N皇后问题等。 9. **计算几何**：涉及点、线、圆等几何对象的运算，如最近点对查找、凸包问题等。 通过深入理解和实践这些算法，不仅可以提高编程技能...
牛客校招C++宝典.rar
03-17
- **回溯法与贪心策略**：应用于组合优化问题，如八皇后问题、N皇后问题等。 - **数据结构**：链表、栈、队列、树（二叉树、平衡树如AVL和红黑树）的基础知识。 4. **数据库知识**： - **关系型数据库理论**：...
八皇后问题 ( C++ )
伊特
07-04 5252
    八皇后问题是一个以国际象棋为背景的问题：如何能够在 8×8 的国际象棋棋盘上放置八个皇后，使得任何一个皇后都无法直接吃掉其他的皇后？为了达到此目的，任两个皇后都不能处于同一条横行、纵行或斜线上。八皇后问题可以推广为更一般的n皇后摆放问题：这时棋盘的大小变为n1×n1，而皇后个数也变成n2。而且仅当 n2 = 1 或 n1 ≥ 4 时问题有解。#include&lt;iostream&gt;...
八皇后问题(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++——八皇后问题(涉及C++中类的使用、栈
芋头圆生煎的博客
03-11 1850
题目： 利用栈结构实现八皇后问题。 八皇后问题19世纪著名的数学家高斯于1850年提出的。他的问题是：在8*8的棋盘上放置8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列、同一斜线上。请设计算法打印所有可能的摆放方法。 提示： 1、可以使用递归或非递归两种方法实现 2、实现一个关键算法：判断任意两个皇后是否在同一行、同一列和同一斜线上 需求分析： （1） 输入的形式：为整形，且为大于3的整数。 （2） 输出的形式：为表格，程序结果打印的是在输入值（n）的大小基础上所有可能摆放的n个皇后的棋
【C/C++】回溯经典算法之八皇后问题
sqxhiu
11-06 2230
八皇后问题 八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。 思路：利用回溯法解决
“八皇后问题”之回溯法——C++实现
ling08140814的博客
06-18 6970
程序分析：在8*8的棋盘上安置八个皇后且相互不能攻击。 常见解法有： 蛮力搜索法 一个皇后的攻击范围如下图所示： 其中一种摆法如下：视频教学链接 ：https://www.51zxw.net/Show.aspx?cid=717&id=79065。 C++代码： 在这里插入代码片 ...
C++：八皇后问题
SongXJ的博客
01-13 1247
大体思路 首先定义一个8*8的二维矩阵，所有的元素都为0，然后开始调用回溯函数寻找皇后。 BackTrack函数是一个回溯函数，回溯的终止条件为计数变量n为8，即皇后放到了最后一行。如果n不等于8，则循环放尝试每一列，如果可以放则将这个位置标记为1，然后继续向下一行查找，直到找完所有8行。 找完后回溯依次往回跳出，并把之前找的皇后记录消除抹掉，即将其再次赋值为0，然后再寻找下一位置。 Judge判...
c++实现八皇后问题
oneself的博客
06-06 2212
八皇后问题解释：可参考八皇后问题_百度百科 (baidu.com)总体思路：动态规划，递归，一行一行下棋核心递归函数： 下棋后或撤销时对该位置所在列的操作函数： 下棋后或撤销时对该位置的斜线方向的操作函数： 实现结果：（仅截图了部分）......
八皇后问题回溯法c++
04-28
八皇后问题是一个经典的回溯算法问题，它要求在一个8x8的棋盘上放置8个皇后，使得每个皇后都不会相互攻击（即不在同一行、同一列或同一对角线）。下面是使用C语言实现的八皇后问题回溯算法代码： ``` #include #...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值