数据结构课程设计报告-8皇后问题

合集下载

数据结构与算法专题实验实验报告_八皇后_背包问题的求解_农夫过河

数据结构与算法专题实验实验报告_八皇后_背包问题的求解_农夫过河

数据结构与算法专题实验实验报告_八皇后_背包问题的求解_农夫过河实验报告:数据结构与算法专题实验报告实验题目:八皇后问题的求解与背包问题的求解实验目的:1. 掌握八皇后问题的求解方法,了解回溯算法的应用。

2. 掌握背包问题的求解方法,了解动态规划算法的应用。

3. 进一步理解数据结构与算法的基本概念和应用。

实验内容:1. 八皇后问题的求解八皇后问题是一个经典的递归与回溯算法问题,要求在一个8×8的棋盘上放置8个皇后,使得任意两个皇后不在同一行、同一列或同一斜线上。

具体求解步骤如下:a. 定义一个8×8的二维数组作为棋盘,初始化所有元素为0。

b. 从第一行开始,依次尝试在每一列放置皇后。

c. 对于每一列,判断当前位置是否与已经放置的皇后冲突。

如果冲突,则回溯到上一行,重新选择位置;否则,继续放置下一行的皇后。

d. 当放置完所有皇后时,输出结果。

2. 背包问题的求解背包问题是一个经典的动态规划算法问题,要求在给定的一组物品中选择一些物品放入背包,使得背包的总重量最大,但不能超过背包的承重量。

具体求解步骤如下:a. 定义一个二维数组dp,其中dp[i][j]表示在前i个物品中选择,背包容量为j时的最大重量。

b. 初始化dp数组的第一行和第一列为0,表示背包容量为0时和没有物品可选时的最大重量都为0。

c. 对于每个物品,分两种情况讨论:- 如果当前物品的重量大于背包的容量,则无法选择该物品,直接继承前i-1个物品的最大重量,即dp[i][j] = dp[i-1][j];- 如果当前物品的重量小于等于背包的容量,则可以选择该物品或不选择该物品。

选择该物品时,背包的总重量为dp[i-1][j-w[i]] + v[i],不选择该物品时,背包的总重量为dp[i-1][j]。

取两者中的较大值作为dp[i][j]的值。

d. 最终,dp[n][m]即为所求的最大重量,其中n为物品的个数,m为背包的承重量。

算法设计与分析实验报告—八皇后问题

算法设计与分析实验报告—八皇后问题

算法设计与分析实验报告—八皇后问题-姓名:***学号:********班级:软件83【问题描述】在国际象棋盘上放八个皇后,要求任一皇后吃不到别人,也不受其他皇后的攻击,求出问题的所有解。

【问题分析&算法设计】用8元组x[1: n]表示8后问题。

其中x[ i]表示皇后i放在棋盘的第i行的第x[ i]列。

由于不允许将2个皇后放在一列,所以解向量中的x[ i]互不相同。

2个皇后不能放在同一斜线上是问题的隐约束。

故若2个皇后放置的位置分别是(i,j)和(k,l),且i – j = k – l或i + j = k + l,则说明这2个皇后处于同一斜线上。

这两个方程分别等价于i – k = j – l和i – k = l – j。

由此可知,只要|i - k| = |j - l|成立,就表明2个皇后位于同一条斜线上。

问题的隐约束化成了显约束。

用回溯法解决8皇后问题时,用完全8叉树表示解空间。

【算法实现】#include "stdio.h"#include "math.h"#include "iostream.h"#define N 8 /* 定义棋盘大小*/static int sum; /* 当前已找到解的个数*/static int x[N]; /* 记录皇后的位置,x[i]表示皇后i放在棋盘的第i行的第x[i]列*//* 每找到一个解,打印当前棋盘状态*/void Show(){sum++;cout << "第" << sum << "种情况:" << endl;cout << "坐标为:\t";for(int k = 0; k < N; k++)cout << '(' << k+1 << ',' << x[k] << ") ";cout << endl;cout << "---------------------------------\n";for (int i = 0; i < N; i ++){for (int j = 0; j < N; j ++)if (j == x[i]) //printf("@ ");cout << "* | ";else //printf("* ");cout << " | ";cout << "\n---------------------------------\n";}}/* 确定某一位置皇后放置与否,放置则返回1,反之返回0 */int Judge(int k){// 测试皇后k在第k行第x[k]列时是否与前面已放置好的皇后相攻击。

C++课程设计八皇后问题

C++课程设计八皇后问题

安徽建筑工业学院数据结构设计报告书院系数理系专业信息与计算科学班级11信息专升本学号11207210138姓名李晓光题目八皇后指导教师王鑫1.程序功能介绍答:这个程序是用于解决八皇后问题的。

八皇后问题等于要求八个皇后中的任意两个不能被放在同一行或同一列或同一斜线上。

做这个课题,重要的就是先搞清楚哪个位置是合法的放皇后的位置,哪个不能,要先判断,后放置。

我的程序进入时会让使用者选择程序的功能,选【1】将会通过使用者自己手动输入第一个皇后的坐标后获得答案;选【2】将会让程序自动运算出固定每一个皇后后所有的排列结果。

2.课程设计要求答:(1)增加函数,完成每输入一组解,暂停屏幕,显示“按任意键继续!”。

(2)完善程序,编程计算八皇后问题共有集中排列方案。

(3)增加输入,显示在第一个皇后确定后,共有几组排列。

(4)将每组解的期盼横向排列输出在屏幕上,将五个棋盘并排排列,即一次8行同时输出5个棋盘,同样完成一组解后屏幕暂停,按任意键继续。

(5)求出在什么位置固定一个皇后后,解的数量最多,在什么位置固定皇后后,解的数量最少,最多的解是多少,最少的解是多少,并将最多,最少解的皇后位置及所有的解求出,同样5个一组显示。

3.对课程题目的分析与注释答:众所周知的八皇后问题是一个非常古老的问题,问题要求在一个8*8的棋盘上放上8个皇后,使得每一个皇后既攻击不到另外七个皇后,也不被另外七个皇后所攻击。

按照国际象棋的规则,一个皇后可以攻击与之处在同一行或同一列或同一斜线上的其他任何棋子。

因此,本课程设计的目的也是通过用C++语言平台在一个8*8的棋盘上放上8个皇后,使得每一个皇后既攻击不到另外七个皇后,也不被另外七个皇后所攻击的92种结构予以实现。

使用递归方法最终将其问题变得一目了然,更加易懂。

首先要用到类,将程序合理化:我编辑了一个盘棋8*8的类:class Board,还有个回溯法的类:class Stack,关键的类好了,然后编辑好类的成员,然后编辑主函数利用好这些类的成员,让其运算出结果。

数据结构 八皇后问题 报告

数据结构 八皇后问题 报告

数据结构实验报告实验名称:实验2 利用栈结构实现八皇后问题学生姓名:廖宁班级:2009211114班内序号:18学号:09210411日期:2010年11月18日1.实验要求八皇后问题是19世纪著名的数学家高斯于1850年提出的。

他的问题是:在8*8的棋盘上放置8个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列、同一斜线上。

请设计算法打印所有可能的摆放方法。

提示:(1)可以使用递归或非递归两种方法实现。

(2)实现一个关键算法,判断任意两个皇后是否在同一行、同一列和同一斜线上。

2. 程序分析程序工程包含一个模板类函数实现定义的源文件forthelove.cpp和测试源文件sbsuowang.cpp。

2.1 存储结构存储结构为栈。

2.2 关键算法分析(1)判断在第row行第column列摆放皇后是否非法,采取定行不定列的方法,列相等的算法为position[i]=colume,对角线相等有两种情况:一是position在上则row-i=colume-position[i];二是position在下,row-i=position[i]-colume.加入能放皇后,列和对角线上值都不能相等。

具体代码如下:int IsIllegal(int row, int column, const int* position){/int i;for (i=1; i < row; ++i){if ((position[i] == column)|| (row - i == column - position[i])|| (row - i == position[i] - column)){return TRUE;}}return FALSE;}(2)我采用定行尝试列的方法来遍历,记录皇后位置的数组可以和栈数组合二为一,而栈顶指针也可以和行坐标合二为一,这样一来栈帧只要一个列坐标就可以了。

1.伪代码:while(栈不空){if ( 行(即栈顶) <= n && 列<= n ){if ( 当前位置不能放皇后){列++;}else{列入栈(隐含着"行++");列= 1;}}else{if ( 行(即栈顶) > n ){输出位置数组(即栈数组);}列退栈(隐含着"行--");列++;}}//end while具体实现代码:void Queens(int n, void (* Visit)(const int* position)) {//position[n]数组:position[0]为棋盘大小,即n//position[1]~position[n]:下标为行坐标,值为列坐标int* stack = NULL; //栈int top; //栈顶int column; //列stack = (int*)malloc((n + 1) * sizeof(int));stack[0] = n;top = column = 1;while(top > 0){if ((top <= n) && (column <= n)){if (IsIllegal(top, column, stack)){++column;}else{stack[top++] = column;column = 1;}}else{if (top > n){(* Visit)(stack);}column = stack[--top];++column;}}//end whilefree(stack);return;}3. 程序运行结果程序实现八皇后问题:经过测试,程序运行良好,无明显错误。

数据结构实验报告八皇后问题

数据结构实验报告八皇后问题

2007级数据结构实验报告实验名称:实验二——栈和队列学生姓名:班级:班内序号:学号:日期:2008年11月18日1.实验要求通过选择下面五个题目之一进行实现,掌握如下内容:➢进一步掌握指针、模板类、异常处理的使用➢掌握栈的操作的实现方法➢掌握队列的操作的实现方法➢学习使用栈解决实际问题的能力➢学习使用队列解决实际问题的能力利用栈结构实现八皇后问题。

八皇后问题19世纪著名的数学家高斯于1850年提出的。

他的问题是:在8*8的棋盘上放置8个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列、同一斜线上。

请设计算法打印所有可能的摆放方法。

提示:1、可以使用递归或非递归两种方法实现2、实现一个关键算法:判断任意两个皇后是否在同一行、同一列和同一斜线上2. 程序分析2.1 存储结构采用栈存储,其结构图如下:2.2 关键算法分析函数原型: bool check(int i);2.2.1.1.1自然语言:检测至第i行所摆放的第i个皇后是否和之前的i-1个皇后发生冲突。

如是,则返回0;反之,则当前布局合法,返回1。

判断两个皇后是否相互攻击的准则是:若两个皇后处于同一行,或处于同一列,或处于同一斜线,就能相互攻击。

基于如上准则,函数check( )的工作原理是:考虑到数组的每个元素分别代表不同行的皇后,即每行只放置了一个皇后,所以不必考虑“同处一行相互攻击”的情形;对于同处一列,则语句:if(queen[s]==queen[t])就能判断出不同行的两个棋子是否同处一列;对于处于同一斜线的这种情况,首先,我们看出国际象棋的棋盘是一个八行八列的正方形。

因此我们可将棋盘想象为数学上的笛卡尔平面坐标系,两颗棋子想象为平面上的两个点,就很容易发现,为保证两颗棋子不处于同一斜线,只要过这两个点的直线斜率不为1或-1,就能达到要求。

由此可使用下列语句:if( abs(t-s) == abs(queen[s]-queen[t]) )其中t和s分别代表不同行的两个皇后,即数组queen[8]里不同下标的两个元素。

(完整word版)数据结构课程设计之_八皇后问题

(完整word版)数据结构课程设计之_八皇后问题

课程设计报告课程名称数据结构课程设计课题名称八皇后问题演示专业通信工程班级通信工程1081学号201013120103姓名刘献文指导教师田娟秀郭芳2012年7 月 6 日湖南工程学院课程设计任务书课程名称数据结构课题八皇后问题演示专业班级通信工程1081学生姓名刘献文学号201013120103指导老师田娟秀郭芳审批任务书下达日期2012 年7 月 1 日任务完成日期2012 年7 月 6 日1设计内容与设计要求1。

1设计内容(4)课题四:八皇后问题演示八皇后问题是一个古老而著名的问题,是回溯算法的典型例题。

该问题是十九世纪著名的数学家高斯1850年提出:在8×8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法。

高斯认为有76种方案。

1854年在柏林的象棋杂志上不同的作者发表了40种不同的解,后来有人用图论的方法解出92种结果。

设计思路: 解决8皇后时,在安放第i行皇后时,需要在列的方向从1到n试探(j =1,…, n):首先在第j列安放一个皇后,如果在列、主对角线、次对角线方向有其它皇后,则出现攻击,撤消在第j列安放的皇后。

如果没有出现攻击,在第j列安放的皇后不动,递归安放第i+1行皇后。

对于八皇后问题的实现,如果结合动态的图形演示,则可以使算法的描述更形象、更生动.要求用Turbo C或VC6.0 MFC实现的八皇后问题的图形程序,能够演示全部的92组解.1。

2 选题方案:所选题目根据学号确定,学号模6加1,即(学号%6+1).如你的学号为9,则所选题目号为:9%6+1=(题目4)。

注意,所有的课题都要求用图形方式演示步骤和结果。

同学们可以自己针对数据结构课程中所讲算法来设计一个演示过程的算法。

1.3设计要求:1。

3.1 课程设计报告规范(1)需求分析a.程序的功能。

b.输入输出的要求。

(2)概要设计a.程序由哪些模块组成以及模块之间的层次结构、各模块的调用关系;每个模块的功能。

北邮数据结构实验二八皇后问题

北邮数据结构实验二八皇后问题

数据结构实验报告实验名称:学生姓名:班级:班内序号:学号:日期:一.实验描述: 利用栈结构实现八皇后问题。

二.八皇后问题19世纪著名的数学家高斯于1850年提出的。

他的问题是:在8*8的棋盘上放置8个皇后, 使其不能互相攻击, 即任意两个皇后都不能处于同一行、同一列、同一斜线上。

请设计算法打印所有可能的摆放方法。

三.程序分析1.存储结构: 栈2.关键算法分析:a)比较函数: 比较某两个皇后是否在同一横、竖、斜线上。

行数:a和b。

列数:row[a]和row[b]。

主对角线数:(a+row[a])和(b+row[b])。

副对角线数:(a+7-row[a])和(b+7-row[b])。

b)八皇后实现(非递归):放置每一行的皇后时, 考虑其与已放好的之前行是否存在矛盾, 并作出相应的退栈、进栈或改变位置的反应。

放置完8行后, 计算下一个解。

当最后取得的解与第一个解重复时, 已取得全部解, 结束程序。

3.代码详细分析:#include<iostream>using namespace std;bool CompArray(int a[],int b[],int n)//用来比较两组解是否相等的函数{bool e=1;for(int i=0;i<n;i++){if(a[i]!=b[i])e=0;}return e;}class Stack //栈{public:Stack();void Push(int n);void Pop();bool Compare(int a,int b);void EightQueen();private:int row[8];//row[i]代表第i行皇后的列数是row[i], 因为八皇后不同行, 所以每行都有且只有一个皇后int top;};Stack::Stack() //置空栈{top=-1;}void Stack::Push(int n) //压栈函数{row[++top]=n; //int n进栈, top指针+1}void Stack::Pop() //退栈函数{top-=1; //top指针-1}bool Stack::Compare(int a,int b) //比较函数, 比较某两个皇后是否在同一行、列或对角线上{return row[a]==row[b]||(a+row[a])==(b+row[b])||(a+7-row[a])==(b+7-row[b]);} /*输入的行数a和b本来就不相等比较列数row[a]和row[b]是否相等比较主对角线数(a+row[a])和(b+row[b])是否相等比较副对角线数(a+7-row[a])和(b+7-row[b])是否相等bool输出0表示以上均不相等*/void Stack::EightQueen() //八皇后判断函数{int count=0; //计数量, 计解的个数int a[8]; //存储数组, 存储第一个解以便比较while(1) //控制每次进栈的大循环{Push(0);//为当前指针所指的下一位进栈0, 表示上一行皇后位置判断完成, 进入下一行判断loop:for(int j=0;j<top;j++)//将当前指针所在行与之前每一行进行对比, 以判断本行当前列是否可放置皇后的比较循环{if(Compare(top,j)!=0){row[top]++;//如果有任何一次比较的结论是不可放置, 本行的列数+1while(1)//如果列数+1之后超出8列, 则退栈, 给上一行列数加1, 如再超列再退栈, 以此类推{if(row[top]>7){Pop();row[top]++;}else break;}goto loop;//进行下一次比较循环}}if(top==7)//如果top=7, 说明已经判断完了第8行, 可以输出解{if(count==0)//用a[]记录第一个解{for(int i=0;i<8;i++){a[i]=row[i];}}else{if(CompArray(a,row,8)==1)break;//当再次求出的解与第一个解相同时, 说明已经输出了全部的解, 将不再输出}count++;//解的计数量+1cout<<"第"<<count<<"个解:"<<endl;//输出解for(int i=0;i<8;i++){cout<<"第"<<i+1<<"个皇后在第"<<i+1<<"行, 第"<<row[i]+1<<"列"<<endl;}cout<<endl;row[top]++;//本次求解后, 给第8行列数+1, 以进行下一次求解while(1)//超列则当前位列数置零, 退栈后列数+1{if(row[top]>7){row[top]=0;row[--top]++;}else break;}goto loop;//进入比较循环, 开始下一次求解}}}main(){Stack S1;S1.EightQueen();}a) 4.时间复杂度计算: (皇后数为n,解的个数为m)某一行取某个值时与之前每行比较: O(n)。

北邮信通院数据结构实验二--八皇后问题实验报告(内附源代码完整版)

北邮信通院数据结构实验二--八皇后问题实验报告(内附源代码完整版)
2.程序分析
2.1存储结构
存储结构:栈(递归)
2.2关键算法分析
递归调用摆放皇后
1、关键算法伪代码:
(1).如果输入的row大于皇后的数量,则输出皇后的位置
(2)否则col从0开始递增
(3)检测(row,col)上的点是否符合条件,不符合则col自增,符合则转到下一个皇后的排列
2、代码详细分析:
void SeqStack::PlaceQueen(int row) //摆放皇后
{
for (int col=0;col< n;col++) //遍历0~7,
{
Push(col);
if (Check()) //判断摆放皇后的位置是否合适
{
if (row< n-1) //若还没有放到最后一个,则进行下一个皇后的放置
PlaceQueen(row+1);
else
{
num++; //计数器加1
{
if(top>= m-1) throw "上溢";
top++; //栈顶指针上移
data[top]=x;
}
void SeqStack::Pop() //出栈操作
{
if(Empty()) throw "下溢";
top--; //栈顶指针下移
}
void SeqStack::PlaceQue计放置八皇后,只要修改输入的N,便可显示其他情况的结果。
Print(n); //打印成功的坐标点
}
}
Pop(); //若不符合条件则出栈
}
}
bool SeqStack::Empty()

数据结构实验报告--八皇后

数据结构实验报告--八皇后

数据结构实验报告1.实验要求实验目的:利用栈结构实现八皇后问题八皇后问题如下:八皇后问题是19世纪著名的数学家高斯于1850年提出的。

他的问题是,在8*8的棋盘上放置8个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行,同一列,同一斜线上。

实验内容:利用所学的栈结构用递归或非递归解决八皇后问题。

2. 程序分析程序使用程序最主要只是在主函数用了一个递归函数Queen。

Queen函数使用了三个参数m,flag[][],chess[][]。

其中m是行数,flag[][]是判断二维数组何处可以放置皇后,chess[][]是存储字符串的二维数组。

主函数中对Queen函数中的形参数组flag[][],chess[][]进行初始化,在Queen函数中再进行各种操作。

Queen函数执行代码,首先行数m为0,当m小于7时,通过if…else…语句,利用Queen(m+1,f,c)重新执行递归函数到下一行。

2.1 存储结构存储结构:数组存储。

flag[][]数组存储数字判断输出和储能放置皇后,chess[][]数组存储字符串即皇后和非皇后的形状。

2.2 关键算法分析1、关键算法:a.for(i=0;i<8;i++)for(j=0;j<8;j++){f[i][j]=0;c[i][j]='*';说明:对棋盘进行初始化未放置皇后的为“*”b.for(i=0;i<8;i++)for(j=0;j<8;j++){c[i][j]=chess[i][j];f[i][j]=flag[i][j];}说明:对c[][],f[][]进行初始化。

c.for(i=0;i<8;i++)for(j=0;j<8;j++){i f(f[i][j]==0 && (i+j==m+k || m==i || k==j || m-k==i-j))f[i][j]=-1;}c[m][k]='#';说明:已放置皇后的行、列以及对角线都不能再放置皇后。

数据结构课程设计八皇后问题

数据结构课程设计八皇后问题
第一章 八皇后问题概述
1.1 课题的描
八皇后问题是一个古老而著名的问题,该问题是十九世纪著名的数学家高斯1850年提出的。八皇后问题是在8*8的国际象棋棋盘上,安放8皇后,要求没有一个皇后能够“吃掉”任何其他一个皇后,即没有两个或两个以上的皇后占据棋盘上的同一行、 同一列、或同一对角线。
到了现代,随着计算机技术的飞速发展,这一古老而有趣的数学游戏问题也自然而然的被搬到了计算机上。运用所学计算机知识来试着解决这个问题是个锻炼和提高我自己编程能力和独立解决问题能力的好机会,可以使我增强信心,为我以后的编程开个好头,故我选择了这个有趣的课题。
在编写代码时,我希望能随机选择一数 X(1~92)后,能输出该种情况所对应的八个皇后的摆放方式和每个皇后所在的位置,但想了好久,就是无法实现。而且,当92种情况都输出时,前面的几十种情况无法看到,要想让摆放皇后的图形和所在具体的位置一起输出,就得修改程序让使她们一个一个地输出,这样显然比较麻烦。倘若有一种既能把八皇后的所在位置和把皇后所有情况连续输出,我感觉就应该算是一个完美的程序了,这还需要我一致的探索发掘下去才行。
cout<<" "<<"-------------------------------------"<<endl;
Queen(0); //!从第0行开始递归试探。
getch();//!按任意键返回。
}
void Queen(int n) /*-----------------Queen:递归放置第n个皇后,程序的核心!----------------*/
但若输入数字0时,操作结束,退出程序。
使用多维数组输出魔方阵,分别用3个子函数实现相应的功能。

c八皇后问题 课 程 设 计 报 告

c八皇后问题 课 程 设 计 报 告
八皇后问题
一、设计任务与目标
在8行8列的棋盘上放置8个皇后,皇后可吃掉与她处于同行或同列或同一对角线上的其他棋子,要使任一个皇后都不能吃掉其他的7个皇后,则需要同时控制同行,同列,同一条对角线的情况,然后当行,列,以及对角线都无皇后时,记录该点。并用“Q”表示皇后的位置,“+”表示其它位置。
二、方案设计与论证
Int i=1
i>8
否是
Int j=1;

j<9
是j++
输出并显示八皇后摆放情况a[j]&&b[i+j-
2]&&c[i-j+7]
是否跳出递归j++
LineNum[i]=j;
a[j]=false;
b[i+j-2]=false;
c[i-j+7]=false;
i++;i--a[j]=true;b[i+j-2]=true;
{
LineNum[i]=j; //记录皇后位置
a[j]=false;
b[i+j-2]=false;
c[i-j+7]=false;
solve(i+1);
a[j]=true;
b[i+j-2]=true;
c[i-j+7]=true;
}
if(i>8) //摆放皇后之后,若i=8即已放满时则递归出口;否则通过solve(i+1);进行递归调用。
{பைடு நூலகம்
a[i]=true;
}
for(i=0;i<15;i++)
{
b[i]=true;

数据结构八皇后问题实验报告

数据结构八皇后问题实验报告

八皇后问题一.八皇后问题简述:在8*8的国际象棋棋盘上放置8个皇后,使任意两个皇后不能互相攻击,即任何行任何列或对角线(与水平轴的夹角为45°或135°的斜线)上不得有两个或两个以上的皇后,这样的一个格局称为问题的一个解。

请求八皇后问题的算法。

二.解决思路:先声明我们根据条件可以知道皇后肯定是每行都有且只有一个所以我们创建一个数组x[t]让数组角标表示八皇后的行,用这个角标对应的数组值来确定这个皇后在这行的那一列。

我们用递归来做:这问题要求皇后所在的位置必须和其他皇后的位置不在同一行、列还有把两个皇后看成点其|斜率|=1;所以我们就要写这个限定条件用一个函数来实现:函数内对每一个已经放好的皇后的位置进行判断,所以就要有个循环。

我们既然是用递归来解决问题那就要把这个问题分成一个个相同的小问题来实现。

不难发现我们要在8*8的方格里放好8个皇后那我们就要知道在8(列)*7(行)是怎么放的在有我们事先写好的判断函数放好最后行就搞定了;以此类推我们要知道8*7的怎么方的我们就要知道8*6是怎么样的就好了,所以我们是以一行怎么放作为一个单元。

我们就去建一个可以放好一行的函数backtrack(int t)里面的t表示是第几行,在main函数调用的时候第一次传进来的是0也就是从第一行开始判断。

我们就开始写函数体了:每一行有8个位置可以放,每一个位置我们都要去判断一下所以我们就用循环来搞定。

在这个循环里面我们让x[t]=i也就是从这一行的第一个开始判断。

放好后就要去判断是否符合条件。

如果符合条件我们就在调用这个函数本身backtrack 不过传进去的参数是t+1也就是下一行的意思。

在进行判断下一行之前我们要判断一下t是不是等于8也就是已经是最后一行了,如果是最后一行了我们就可以将其进行输出。

打印8*8的矩阵(提示在写一个函数)皇后的位置用1表示出来没有的用0表示。

三.代码与注解:#include <math.h>#include <stdio.h>#include <time.h>#include<string.h>#include<conio.h> //用getch()要调用的头文件#include <stdlib.h> //要用system函数要调用的头文件int SUM=0; //统计有多少种可能int shezhi(){ //设置为N皇后问题int N;printf("这是一个N皇后问题...\n请输入N=");scanf("%d",&N);return N;}void Print(int N,int x[]) //印出結果{int MAX=N;for(int i=0;i<MAX;i++){for(int j=0;j<MAX;j++)if(j==x[i])printf("@");elseprintf("*");printf("\n");}SUM++; //打印一种情况统计一次printf("\n");}int Judge(int k,int x[]) //判断是否在同一直、橫、斜线上有其它棋子{int i;for(i=0;i<k;i++)if( abs(k-i)==abs(x[i]-x[k]) || x[i]==x[k] ) //函数名: abs; 功能: 求整数的绝对值 ;return 0;return 1;}void backtrack(int t,int N,int x[]) // 把棋子放到棋盘上{ int MAX=N;int i;for(i=0;i<MAX;i++){x[t]=i;if(Judge(t,x)){if(t==MAX-1){Print(MAX,x); // 找到其中一种放法,印出結果}else backtrack(t+1,N,x);}}}void Introduce(){printf("1.设置为N皇后问题。

八皇后问题课程设计报告

八皇后问题课程设计报告

课程设计题目:名称:八皇后问题内容:设计程序完成如下要求:在8× 8的国际象棋棋盘上,放置8 个皇后,使得这8个棋子不能互相被对方吃掉。

要求:(1) 依次输出各种成功的放置方法。

(2) 最好能画出棋盘的图形形式,并在其上动态地标注行走的过程。

(3) 程序能方便地移植到其他规格的棋盘上。

一、问题分析和任务定义八皇后问题是一个古老而著名的问题,是回溯算法的典型例题。

该问题是十九世纪著名的数学家高斯1850 年提出:在8X8 格的国际象棋上摆放八个皇后,使其不能互相攻击,根据国际象棋的规定,皇后可以攻击与它在同一行、同一列或者同一斜线上的棋子,即任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法。

在8!=40320 种排列中共有92 种解决方案。

本程序需要解决的问题有:1、建立合适的数据类型表示皇后在棋盘上所处的位置。

2、成功的输出全部正确的放置方法。

3、画出棋盘形式,在上面动态的标注其行走的过程。

二、数据结构的选择和概要设计1、为了简单易行的表示皇后在棋盘所处的位置,在此建立一个整型数组queen[i] 来表示,若queen[3]=2 则表示皇后处在8× 8 棋盘的第三行和第二列。

2、表示好皇后以后,设计judge( )和check( )函数来检测第一个皇后的同列和同斜线上有没有其他皇后(程序以行为基础,逐行试探每列和斜线上是否有皇后) 。

然后设计输出函数show( ) 和print( ) 分别输出正确解法的排列形式和棋盘摆放形式。

在输出棋盘的步骤中,设计一个递归函数go( )实现棋盘的输出。

3、程序的流程图如下图所示:图1 程序流程图for(queen[++j]=0;queen[j]<8;queen[j]++) if(judge(queen,j))三、详细设计和编码1、首先定义整型数组 queen[i]表示皇后的位置, i 的取值由 0到 7表示八个皇后。

然后 定义一个整型变量 count 来统计所有正确解法的个数。

数据结构八皇后问题

数据结构八皇后问题

目录一需求分析 (1)1.1程序的功能: (1)1.2程序的输入输出要求: (1)二概要设计 (3)2.1程序的主要模块: (3)2.2程序涉及: (3)三详细设计 (3)3.1相关代码及算法 (4)3.1.1 定义相关的数据类型如下:....................... 错误!未定义书签。

3.1.2 主模块类C码算法: (4)3.1.3 画棋盘模块类C码算法 (5)3.1.4 画皇后模块类C码算法: (5)3.1.5 八皇后摆法模块(递归法): (6)3.1.6 初始化模块 (7)3.1.7 输出摆放好的八皇后图形(动态演示): (7)3.2相关流程图 (9)四调试分析 (12)五设计体会 (13)六附录 (13)七参考文献 (17)一需求分析1.1 程序功能:八皇后问题是一个古老而著名的问题。

该问题是十九世纪著名的数学家高斯1850年提出的。

八皇后问题要求在一个8*8的棋盘上放上8个皇后,使得每一个皇后既攻击不到另外七个皇后,也不被另外七个皇后所攻击.按照国际象棋的规则,一个皇后可以攻击与之处在同一行或同一列或同一斜线上的其他任何棋子,问有多少种不同的摆法?并找出所有的摆法。

因此,八皇后问题等于要求八个皇后中的任意两个不能被放在同一行或同一列或同一斜线上。

本程序通过对子函数void qu(int i)的调用,将八皇后的问题关键通过数据结构的思想予以了实现。

虽然题目以及演算看起来都比较复杂,繁琐,但在实际中,只要当一只皇后放入棋盘后,在横与列、斜线上没有另外一只皇后与其冲突,再对皇后的定位进行相关的判断。

即可完成。

如果在这个程序中,我们运用的是非递归的思想,那么将大量使用if等语句,并通过不断的判断,去推出答案,而且这种非递归的思想,大大的增加了程序的时间复杂度。

如果我们使用了数据结构中的算法后,那么程序的时间复杂度,以及相关的代码简化都能取得不错的改进。

这个程序,我运用到了数据结构中的栈、数组,以及树和回溯的方法。

八皇后 实验报告

八皇后 实验报告

八皇后实验报告八皇后实验报告导言:八皇后问题是一个经典的数学问题,最早由西班牙的数学家马克斯·贝恩在1848年提出。

问题的目标是在一个8×8的棋盘上,放置8个皇后,使得它们互相之间无法攻击到对方。

本次实验旨在通过编程的方式求解八皇后问题,并分析解的个数和解的特点。

一、问题描述八皇后问题可以简化为在一个8×8的棋盘上放置8个皇后,使得任意两个皇后都不在同一行、同一列或同一斜线上。

这意味着每一行和每一列最多只能有一个皇后。

二、算法设计为了求解八皇后问题,我们采用了回溯算法。

回溯算法是一种通过逐步试错的方式来寻找问题解的方法。

具体的算法步骤如下:1. 从棋盘的第一行开始,依次尝试在每一列放置一个皇后。

2. 在放置一个皇后后,检查是否满足任意两个皇后都不在同一行、同一列或同一斜线上的条件。

3. 如果满足条件,则继续到下一行放置皇后;如果不满足条件,则回溯到上一行重新选择位置。

4. 当最后一行的皇后放置完毕后,即找到了一个解,记录下来。

5. 继续回溯,寻找下一个解,直到所有解都找到为止。

三、实验结果通过编程实现了八皇后问题的求解算法,并运行了多组实验。

实验结果如下:1. 解的个数在8×8的棋盘上,共有92个不同的解。

每个解都代表了一种放置皇后的方式,使得它们互不攻击到对方。

2. 解的特点(1) 对称性:在所有的解中,有一半解是对称的。

即如果一个解是对称的,那么它的镜像解也是一个合法解。

(2) 旋转性:每个解可以通过旋转得到其他的合法解。

例如,一个解可以通过将整个棋盘顺时针旋转90度得到另一个解。

(3) 反射性:每个解可以通过水平或垂直翻转得到其他的合法解。

例如,一个解可以通过将整个棋盘水平翻转得到另一个解。

(4) 解的数量:解的数量随着棋盘大小的增加而急剧增加。

在8×8的棋盘上有92个解,而在9×9的棋盘上有352个解。

四、讨论与总结八皇后问题是一个非常经典的数学问题,通过本次实验我们可以得出以下结论:1. 回溯算法是求解八皇后问题的有效方法,可以找到所有的解。

(2023)八皇后问题实验报告(一)

(2023)八皇后问题实验报告(一)

(2023)八皇后问题实验报告(一)实验背景八皇后问题,是一道经典的数学问题,简要地说:在一个 8x8 的国际象棋棋盘上摆放 8 个皇后,使其不能互相攻击。

即任意两个皇后都不能处于同一行、同一列或同一斜线上。

实验目的1.理解并掌握八皇后问题的基础算法;2.利用Python编写程序,解决八皇后问题;3.掌握递归算法与回溯算法的基本思想;4.分析算法时间复杂度,理解优化算法的重要性。

实验步骤1.利用递归算法,枚举每一行中皇后的位置;2.每一行都有8个候选位置,依次尝试每个位置是否可行;3.如果某个位置可行,继续对下一行进行递归;4.如果都不可行,则回溯到上一行,重新选择位置;5.直到第8行所有位置都选择完成,输出结果。

程序实现及结果def conflict(pos, i):for j in range(i):if abs(pos[i] - pos[j]) in (0, i - j):return Truereturn Falsedef queen(num =8, pos = ()):for i in range(num):if not conflict(pos, i):if len(pos) == num -1:yield (i, )else:for result in queen(num, pos + (i, )):yield (i, ) + resultfor solution in list(queen(8)):print(solution)程序输出结果为所有可能的八皇后问题解决方案,共计92种:(0, 4, 7, 5, 2, 6, 1, 3)(0, 5, 7, 2, 6, 3, 1, 4)…(7, 3, 0, 2, 5, 1, 6, 4)(7, 4, 2, 0, 6, 1, 3, 5)结论与分析1.通过本实验,我们深入地理解了递归算法与回溯算法的基本思想,并将其应用到八皇后问题的解决中;2.程序的输出结果表明:八皇后问题有92种可能的解决方案;3.根据算法的时间复杂度分析,当八皇后问题的规模更大时,应该采用更高效的算法进行优化;4.进一步研究表明,通过基因算法等优化算法可以提高八皇后问题的解决效率。

约瑟夫环与八皇后问题--数据结构课程设计实验报告

约瑟夫环与八皇后问题--数据结构课程设计实验报告
目 一、 二、 三、 四、 五、 六、 七、
录 问题描述 1 问题分析 1 数据结构描述 算法设计 2 详细程序清单 程序运行结果 心得体会 12
1 4 11
一、 问题描述 1. 约瑟夫问题描述 编号为1,2... n的n个人按顺时针方向围坐一圈,每人持有一个密码(正整数)。一 开始任选一个正整数作为报数的上限值m,从第一个人开始按顺时针方向自1开始顺序报 数,报到m时停止报数,报m的人出列,将他的密码作为新的m值,从他的顺时针方向上的 下一个开始重新从1报数,如此下去,直至所有人全部出列为止,设计一个程序求出出列 顺序。 2. 八皇后问题描述 在一个8×8的棋盘里放置8个皇后,要求每个皇后两两之间不相"冲"(在每一横 列竖列斜列只有一个皇后)。 3、界面设计模块问题描述 设计一个菜单式界面,让用户可以选择要解决的问题,同时可以退出程序。界面要 简洁明了,大方得体,便于用户的使用,同时,对于用户的错误选择可以进行有效的处 理。 二、 问题分析 在整个课程设计中,我主要负责的是约瑟夫问题中链表中的出列的操作算法的设计。 用循环单链表表示编号为1,2... n的n个人按顺时针方向围坐一圈,每人持有一个密码 (正整数)。一开始输入一个正整数作为报数的上限值turn,从第一个人开始按顺时针方 向自1开始顺序报数(即从第一个结点开始指针向后移动),报到turn-1时(即指针指向 turn-1个结点时)停止,他的下一位出列,将他的下一位密码作为新的turn值,从出列的 人的的顺时针方向上的下一个开始重新从1报数,如此下去,直至链表中只剩一位(即一 个结点)退出循环,并所有人的编号按出列顺序输出。在实现的过程中定义i表示报数的
int code; struct LNode *next; }node,*linklist; linklist creatstart(linklist L,int number) { int m,i; linklist s,p; s=L; for(i=1;i<=number;i++) { p=(linklist)malloc(sizeof(node)); if(!p) exit(0); p->data=i; printf("please input the code of number %d:",i); scanf("%d",&p->code); p->next=NULL; s->next=p; s=p; } s->next=L->next; return s; } void chulie(linklist L,int number) { int turn,i,j; linklist p,s; printf("please input the start code:"); scanf("%d",&turn); p=L; printf("the turn out of the circle is:"); for(i=1;i<=number-1;i++) { for(j=1;j<=turn-1;j++) p=p->next; printf("%d ",p->next->data); turn=p->next->code; s=p->next; p->next=s->next; free(s); } printf("%d ",p->next->data); printf("\n"); } void lianbiao() { int number; linklist L; L=(linklist)malloc(sizeof(node));

八皇后问题数据结构课程设计报告

八皇后问题数据结构课程设计报告

数据结构课程设计报告八皇后问题设计任务书课题名称八皇后设计目的1.调研并熟悉八皇后的基本功能、数据流程与工作规程;2.学习八皇后相关的算法和基于VC++集成环境的编程技术;3.通过实际编程加深对基础知识的理解,提高实践能力;4.学习开发资料的收集与整理,学会撰写课程设计报告。

实验环境1.微型电子计算机(PC);2.安装Windows 2000以上操作系统,Visual C++6.0开发工具。

任务要求1.利用课余时间去图书馆或上网查阅课题相关资料,深入理解课题含义及设计要求,注意材料收集与整理;2.在第16周末之前完成预设计,并请指导教师审查,通过后方可进行下一步工作;3.本课题要求至少用三种方法解决八皇后问题,输入棋盘的阶层,然后显示共有多少种布局方案,并显示每一种方案的具体情况。

4.结束后,及时提交设计报告(含纸质稿、电子稿),要求格式规范、内容完整、结论正确,正文字数不少于3000字(不含代码)。

工作进度计划序号起止日期工作内容1 2009.06.7~2009.06.7 在预设计的基础上,进一步查阅资料,完善设计方案,形成书面材料。

22009.06.7~2009.06.10设计总体方案,构建、绘制流程框图,编写代码,上机调试。

3 2009.06.11~2009.06.12测试程序,优化代码,增强功能,撰写设计报告。

4 2009.06.12~2009.06.13提交软件代码、设计报告,参加答辩,根据教师反馈意见,修改、完善设计报告。

指导教师(签章):2013 年 5 月 15 日摘要:众所周知的八皇后问题是一个非常古老的问题,具体如下:在8*8的国际象棋棋盘上放置了八个皇后,要求没有一个皇后能吃掉另一个皇后,即任意两个皇后都不处于棋盘的同一行、同一列或同一对角线上,这是做出这个课题的基础。

要求编写实现八皇后问题的递归解法或非递归解法,对于任意给定的一个初始位置,输出八皇后问题的一个布局。

本次设计旨在学习各种算法,训练对基础知识和基本方法的综合运用及变通能力,增强对算法的理解能力,提高软件设计能力。

数据结构课程设计 回溯法解决8皇后n皇后问题

数据结构课程设计 回溯法解决8皇后n皇后问题

数据结构课程设计学院:信息科学技术学院专业:电子信息工程(1)姓名:谢后乐学号:20101601310015N皇后问题N皇后问题:在n×n格的棋盘上放置彼此不受攻击的n个皇后。

按照国际象棋的规则,皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。

n后问题等价于再n×n的棋盘上放置n个皇后,任何2个皇后不妨在同一行或同一列或同一斜线上。

回溯法简介:回溯法(探索与回溯法)是一种选优搜索法,按选优条件向前搜索,以达到目标。

但当探索到某一步时,发现原先选择并不优或达不到目标,就退回一步重新选择,这种走不通就退回再走的技术为回溯法,而满足回溯条件的某个状态的点称为“回溯点”。

我们发现,对于许多问题,所给定的约束集D具有完备性,即i元祖(x1,x2,…,xi)满足D中仅涉及到x1,x2,…,xi的所有约束意味着j(j<=i)元组(x1,x2,…)一定也满足D中仅涉及到x1,x2,…,的所有约束,i=1,2,…,n。

换句话说,只要存在0≤j≤n-1,使得(x1,x2,…,)违反D中仅涉及到x1,x2,…,的约束之一,则以(x1,x2,…,)为前缀的任何n元组(x1,x2,…,j+1,…,)一定也违反D中仅涉及到x1,x2,…,xi的一个约束,n≥i≥j。

因此,对于约束集D具有完备性的问题P,一旦检测断定某个j元组(x1,x2,…)违反D中仅涉及x1,x2,…,的一个约束,就可以肯定,以(x1,x2,…)为前缀的任何n元组(x1,x2,…,)都不会是问题P的解,因而就不必去搜索它们、检测它们。

回溯法正是针对这类问题,利用这类问题的上述性质而提出来的比枚举法效率更高的算法。

空间树回溯法首先将问题P的n元组的状态空间E表示成一棵高为n的带权有序树T,把在E中求问题P的所有解转化为在T中搜索问题P的所有解。

树T类似于检索树,它可以这样构造:设Si中的元素可排成xi(1) ,xi(2) ,...,xi(mi-1) ,|Si| =mi,i=1,2,...,n。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

数据结构课程设计姓名:学号:指导老师:目录一.选题概述---------------------------------------3二.设计要求与分析--------------------------------3三.数据结构与定义--------------------------------41.结构体定义2.函数定义3.函数之间的定义四.程序段与分析----------------------------------5五.完整程序代码及运行结果截图------------------7六.心得体会--------------------------------------10七.参考文献--------------------------------------10一.选题概述:在实际应用中,有相当一类问题需要找出它的解集合,或者要求找出某些约束条件下的最优解。

求解时经常使用一种称为回溯的方法来解决。

所谓回溯就是走回头路,该方法是在一定的约束条件下试探地搜索前进,若前进中受阻,则回头另择通路继续搜索。

为了能够沿着原路逆序回退,需用栈来保存曾经到达的每一个状态,栈顶的状态即为回退的第一站,因此回溯法均可利用栈来实现。

而解决八皇后问题就是利用回溯法和栈来实现的。

二.设计要求与分析八皇后问题是在8x8的国际象棋棋盘上,安放8个皇后,要求没有一个皇后能够“吃掉”任何其他一个皇后,即没有两个或两个以上的皇后占据棋盘上的同一行、同一列或同一条对角线。

八皇后在棋盘上分布的各种可能的格局,其数目非常大,约等于232种,但是,可以将一些明显不满足问题要求的格局排除掉。

由于任意两个皇后不能同行,即每一行只能放置一个皇后,因此将第i个皇后放置在第i行上。

这样在放置第i个皇后时,只要考虑它与前i 一1个皇后处于不同列和不同对角线位置上即可。

因此,其算法基本思想如下:从第1行起逐行放置皇后,每放置一个皇后均需要依次对第1,2,…,8列进行试探,并尽可能取小的列数。

若当前试探的列位置是安全的,即不与已放置的其他皇后冲突,则将该行的列位置保存在栈中,然后继续在下一行上寻找安全位置;若当前试探的列位置不安全,则用下一列进行试探,当8列位置试探完毕都未找到安全位置时,就退栈回溯到上一行,修改栈顶保存的皇后位置,然后继续试探。

该算法抽象描述如下:(1)置当前行当前列均为1;(2)while(当前行号《8)(3){检查当前行,从当前列起逐列试探,寻找安全列号;(4)if(找到安全列号)(5)放置皇后,将列号记入栈中,并将下一行置成当前行,第1列置为当前列;(6)else(7)退栈回溯到上一行,移去该行已放置的皇后,以该皇后所在列的下一列作为当前列;(8)}结束程序。

三.数据结构与定义1.结构体定义typedef struct{int col[MaxSize]; //col[i]存放第i个皇后的列号int top; //栈顶指针}Type;2.函数定义bool place(Type st,int i,int j) //测试(i,j)是否与1~i-1皇后有冲突void queen(int n) //求解皇后问题void main() //主函数3.函数之间的调用关系main queen place四.程序块与分析bool place(Type st,int i,int j)//测试(i,j)是否与1~i-1皇后有冲突{int k=1;if(i==1) return true;//存放第一个皇后时没有冲突while(k<=i-1)//j=1到k-1是已经放置了皇后的列{if((st.col[k]==j)||(abs(j-st.col[k])==abs(k-i)))return false;k++;}return true;}(k,st.col[k])(k,st.col[k])j-st.col[k] j-st.col[k](i,j) i-k i-k (i,j)//测试(i,j)位置是否与已经放好的第1个到第i~1皇后有冲突。

已经放置好的第1个到第1~i-1 个皇后已放置在st栈中。

St栈用的是顺序栈,栈顶指针从1开始,st.col[k]用于存放第k(1<=i<=k-1)个皇后的列号,即皇后的位置是(k,st.col[k])。

对于(i,j)位置上的皇后与已经放置的皇后(k,st.col[k])发生冲突的情况时,则有:st.col[k]==j;对角线的冲突情况是:|j-st.col[k]|==|k-i|。

void queen(int n)//求解n皇后问题{int i,j,k;bool find;Type st;//定义栈stst.top=0;//初始化栈顶指针st.top++;//将(1,1)放进栈st.col[st.top]=1;while(st.top>0)//栈不空时循环{i=st.top;//当前皇后为第i个皇后if(st.top==n)//所有皇后都放置好了,输出一个解{printf("第%d个解:",++count);for(k=1;k<=st.top;k++)printf("(%d,%d)",k,st.col[k]);printf("\n");}find=false;for(j=1;j<=n;j++){if(place(st,i+1,j))//在i+1行找到一个放置皇后的位置(i+1,j){st.top++;st.col[st.top]=j;find=true;break;}}if(find==false)//在i+1行找不到放皇后的位置,回溯{while(st.top>0){if(st.col[st.top]==n)//本行也没有可放的位置,则退栈st.top--;for(j=st.col[st.top]+1;j<=n;j++)//在本行的下一个位置找if(place(st,st.top,j)){st.col[st.top]=j;break;}if(j>n)//当前皇后在本行没有可放的位置st.top--;//退栈else//本行找到一个位置后,推出回溯break;}}}}void main() //主函数{int n;printf("请输入皇后个数n=");scanf("%d",&n);printf("%d皇后问题求解如下:\n",n);queen(n);printf("\n");}五.完整程序代码及运行结果截图#include <stdio.h>#include <stdlib.h>#define MaxSize 100typedef struct{int col[MaxSize];//col[i]存放第i个皇后的列号int top;//栈顶指针}StType;//定义顺序栈类型int count=0;bool place(StType st,int i,int j)//测试(i,j)是否与1~i-1皇后有冲突{int k=1;if(i==1) return true;//存放第一个皇后时没有冲突while(k<=i-1)//j=1到k-1是已经放置了皇后的列{if((st.col[k]==j)||(abs(j-st.col[k])==abs(k-i)))return false;k++;}return true;}void queen(int n)//求解n皇后问题{int i,j,k;bool find;StType st;//定义栈stst.top=0;//初始化栈顶指针st.top++;//将(1,1)放进栈st.col[st.top]=1;while(st.top>0)//栈不空时循环{i=st.top;//当前皇后为第i个皇后if(st.top==n)//所有皇后都放置好了,输出一个解{printf("第%d个解:",++count);for(k=1;k<=st.top;k++)printf("(%d,%d)",k,st.col[k]);printf("\n");}find=false;for(j=1;j<=n;j++)if(place(st,i+1,j))//在i+1行找到一个放置皇后的位置(i+1,j){st.top++;st.col[st.top]=j;find=true;break;}if(find==false)//在i+1行找不到放皇后的位置,回溯{while(st.top>0){if(st.col[st.top]==n)//本行也没有可放的位置,则退栈st.top--;for(j=st.col[st.top]+1;j<=n;j++)//在本行的下一个位置找if(place(st,st.top,j)){st.col[st.top]=j;break;}if(j>n)//当前皇后在本行没有可放的位置st.top--;//退栈else//本行找到一个位置后,推出回溯break;}}}}void main(){int n;printf("请输入皇后个数n=");scanf("%d",&n);printf("%d皇后问题求解如下:\n",n);queen(n);printf("\n");}六.心得体会1.善于学习别人,多请教牛人,才会更快提高自己。

有些问题也许就是自己在某一点想不通,想法转不过来,这就消耗了很多时间。

而经过牛人的点拨问题就解决了,牛人们也会更直接,更清晰的教导一些技术,通过向他们学习,才会更快的提高自己的技能。

2.多找一些题目来练习,多敲代码,才会更有感觉。

在练习的过程中找出规则,形成编程思想。

3.小组合作形成共同进步。

小组成员的讨论过程中,将各自的想法提出来,分析优缺点,这过程中每个成员也可以学习到其他成员的解题思想,也可以审视自己的解题思想,获得提升。

七.参考文献1.数据结构(C语言版)严蔚敏,吴伟民清华大学出版社2.C语言程序设计何钦铭,颜晖高等教育出版社3.数据结构教程李春葆清华大学出版社。

相关文档
最新文档