八皇后实验报告

合集下载

人工智能实验报告

人工智能实验报告

八皇后问题八皇后问题是一个古老而著名的问题,是回溯算法的典型例题。

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

基本思想:在open表中保留已生成而未考察的结点,并用启发函数h(x)对它们全部进行估价,从中选出最优结点进行扩展,而不管这个结点出现在搜索树的什么地方。

(1)把初始结点SO放入open表中,计算h(SO);(2)若open 表为空,则搜索失败,EXIT;(3)移出open表中第一个结点N放入closed表中,并冠以序号n(4)若目标结点Sg=N则搜索成功,EXIT(5)若N 不可扩展,则转步骤(2);(6)扩展N,计算每个子结点x的函数值h(x),并将所有子结点配以指向N 的返回指针后放入open 表中,再对open 表中的所有子结点按其函数值大小以升序排序,转步骤2;//采用启发式修补解N皇后问题#include<time.h>#include <iostream>// 采用启发式修补解N 皇后问题#include<time.h>#include <iostream>using space std;void shuffle(int Queen[],const int n)• ••{//随机取得各行的初始皇后位置,以Queen[i]表示第i行的皇后位置for(i nt i=0;i< n;i )Queen[i]=abs(rand())%n;}int collision(int Queen[],const int row,const int column,const int n). . . {//计算每个位置的冲突值int bug=0;for(int i=0;i<n;i )...{if ((i!=row)&&(Queen[i]==column||(Queen[i]-column)==(i-row)||(Queen[i]-column)==(row-i)))// 同列,同对角线的情况bug ;}return bug;}void show(int Queen[],const int n)...{//打印皇后图cout«"厂";for(int k=0;k<n-1;k )cout«" 丁";cout«"「"<<endl;for(int i=0;i<n-1;i )...{cout«" ";for(int j=0;j<n;j )cout<<((j==Queen[i])? "凤" :"")<<"丨有/皇后的位置用"凤"cout<<endl;coutvv"卜";for(j=0;j<n-1;j )coutvv"十";coutvv"十"vvendl;}cout<<" I ";for(int j=0;jvn;j )coutvv((j==Queen[n-1])? "凤" :"")vv" I "有;//皇后的位置用,没有的用_coutvvendl; coutvv" J"; for(k=0;kvn-1;k )coutvv"丄";coutvv" 厶"vvendl;coutvvendl;}int repair(int Queen[],const int n)...{ //启发式修补int max=-1;〃标志行行之间冲突数int minbug=n;int count=0;while(max!=0&&countv=100)...{max=0;for(int i=0;i<n;i )...{minbug=collision(Queen,i,Queen[i],n);// 取得当前的冲突数,不断优化int temp=Queen[i];for(int j=0;j<n;j )...{int bug=collision(Queen,i,j,n);if(bug<=minbug&&j!=temp)...{ // 保持皇后在等冲突的情况下不断变更位置,有利于后面行的优化minbug=bug;Queen[i]=j;}}if (minbug>max) max=minbug;}show(Queen,n);count ;}return count;}void main()...{int n=-1;int step=0;cout<<"Input N (you would better input a interge minor to 15): "<<endl; cin>>n;if(n<=0)...{cout<<"Illegal Input!"<<endl; return;}int* Queen=new int[n]; sra nd(time(NULL));〃取得随机种子shuffle(Queen,n);cout<<"The oringinal state:"<<endl;show(Queen,n);step=repair(Queen,n);if(step>100)...{cout<<"Could find solution within 100 steps,Try again!"<<endl; return;}cout<<"After "<<step 1<<" steps"<<endl;cout<<"The goal state arrives!"<<endl;}。

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

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

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]里不同下标的两个元素。

国际象棋中的八皇后问题解决实验报告

国际象棋中的八皇后问题解决实验报告

八皇后一、作业题目:在国际象棋的棋盘上摆上八个皇后,使得任何两个皇后不在一行,不在一列,同时也不在一条斜线上。

要求找出所有的解。

二、作业目的:(1)训练C语言编程能力和数据结构中一些方法的运用。

(2)体会数据结构中的方法对简化编程的好处。

三、作业要求:在国际象棋的棋盘上摆上八个皇后,使得任何两个皇后不在一行,不在一列,同时也不在一条斜线上。

要求找出所有可行的方法,并输出所有方法的数目和每种方法如何排列。

四、算法思想:先将所有的点全部置为有可能有皇后,选择第一行的一个点为起点后,进行修剪,当某个点所在的行列斜边都有可能皇后时,则该点有皇后,同时将该点所在的直线斜线上除此点外的所有点都标记为不可能有皇后。

用递归法遍历下面的行。

即前面行的皇后确定后看后面行所有的可能情况。

当递归依次跳出,跳到第一次调用的的子函数时,则该起点对应的方法都找完了。

找出该起点所对应的所有方法后,起点在第一行向后移,再递归遍历。

当遍历完同一行八个起点后,就可以得出所有方法。

用一个子函数输出结果,其中有皇后的地方用“Q”表示,没有的用“.”表示。

五、数据结构:用数组存储六、程序:#include <stdio.h>#include <stdlib.h>#define N 8int column[N+1]; // 同栏是否有皇后,1表示有int rup[2*N+1]; // 右上至左下是否有皇后int lup[2*N+1]; // 左上至右下是否有皇后int queen[N+1] = {0};int num; // 解答编号void backtrack(int i); // 递归求解int main(void) {int i;num = 0;for(i = 1; i <= N; i++)column[i] = 1;for(i = 1; i <= 2*N; i++)rup[i] = lup[i] = 1;backtrack(1);return 0;}void showAnswer() {int x, y;printf("\n解答%d\n", ++num);for(y = 1; y <= N; y++) {for(x = 1; x <= N; x++) {if(queen[y] == x) {printf(" Q");}else {printf(" .");}}printf("\n");}}void backtrack(int i) {int j;if(i > N) {showAnswer();}else {for(j = 1; j <= N; j++) {if(column[j] == 1 &&rup[i+j] == 1 && lup[i-j+N] == 1) { queen[i] = j;// 设定为占用column[j] = rup[i+j] = lup[i-j+N] = 0;backtrack(i+1);column[j] = rup[i+j] = lup[i-j+N] = 1;}}}}七、运行结果:八、操作界面:九、结论:一共有92种遍历方法十、参考文献:[1]廖明宏郭福顺张岩李秀坤.数据结构与算法(第四版),高等教育出版社,2007.[2]苏小红陈惠鹏孙志刚.C语言大学实用教程(第二版),电子工业出版社,2010.。

八皇后问题课程设计报告

八皇后问题课程设计报告

数据结构课程设计报告设计题目:八皇后问题系(院):数学学院专业:信息与计算科学班级:02班学生姓名王天宇学号:指导教师:设计任务书1. 课题综述1. 1课题的来源及意义八皇后问题是一个古老而着名的问题,该问题是十九世纪着名的数学家高斯1850年提出的。

在国际象棋中,皇后是最有权利的一个棋子;只要别的棋子在它的同一行或同一列或同一斜线(正斜线或反斜线)上时,它就能把对方棋子吃掉。

所以高斯提出了一个问题:在8*8的格的国际象棋上摆放八个皇后,使其不能相互攻击,即任意两个皇后都不能处于同一列、同一行、或同一条斜线上面,问共有多少种解法。

到了现代,随着计算机技术的飞速发展,这一古老而有趣的数学游戏问题也自然而然的被搬到了计算机上。

运用所学计算机知识来试着解决这个问题是个锻炼和提高我自己编程能力和独立解决问题能力的好机会,可以使我增强信心,为我以后的编程开个好头,故我选择了这个有趣的课题。

1. 2 面对的问题1)解决冲突问题:这个问题包括了行,列,两条对角线;列:规定每一列放一个皇后,不会造成列上的冲突;行:当第I行被某个皇后占领后,则同一行上的所有空格都不能再放皇后,要把以I为下标的标记置为被占领状态;2)使用数据结构的知识,用递归法解决问题。

2概要设计本课件学生是用循环递归循环来实现的,分别一一测试了每一种摆法,并把它拥有的92种变化表现出来。

在这个程序中,我的主要思路以及思想是这样的:1)解决冲突问题:这个问题包括了行,列,两条对角线;列:规定每一列放一个皇后,不会造成列上的冲突;行:当第I行被某个皇后占领后,则同一行上的所有空格都不能再放皇后,要把以I为下标的标记置为被占领状态;对角线:对角线有两个方向。

在这我把这两条对角线称为:主对角线和从对角线。

在同一对角线上的所有点(设下标为(i,j)),要么(i+j)是常数,要么(i-j)是常数。

因此,当第I个皇后占领了第J列后,要同时把以(i+j)、(i-j)为下标的标记置为被占领状态。

回溯算法实验报告

回溯算法实验报告

回溯算法实验报告实验目的:回溯算法是一种递归算法,通常用于解决有限集合的组合问题。

本实验旨在通过实现回溯算法来解决一个具体的问题,并对算法的性能进行评估。

实验内容:本实验将以八皇后问题为例,展示回溯算法的应用。

八皇后问题是一个经典的问题,要求在一个8x8的棋盘上放置8个皇后,使得任意两个皇后不能在同一行、同一列或同一对角线上。

算法步骤:1. 创建一个二维数组,表示棋盘。

初始化所有元素为0,表示棋盘上无皇后。

2. 逐行进行操作,尝试在每一列放置皇后。

在每一列,从上到下逐个位置进行尝试,找到一个合适的位置放置皇后。

3. 如果找到合适的位置,则将该位置标记为1,并向下一行进行递归操作。

4. 如果当前位置无法放置皇后,则回溯到上一行,尝试放置皇后的下一个位置。

5. 当所有皇后都放置好后,得到一个解。

将该解加入结果集中。

6. 继续回溯,尝试寻找下一个解。

7. 当所有解都找到后,算法终止。

实验结果:在本实验中,我们实现了八皇后问题的回溯算法,并进行了性能测试。

根据实验结果可以看出,回溯算法在解决八皇后问题上表现出较好的性能。

实验中,我们使用的是普通的回溯算法,没有进行优化。

对于八皇后问题来说,回溯算法可以找到所有解,但是随着问题规模的增加,算法的执行时间也会大大增加。

回溯算法是一种非常灵活的算法,可以用于解决各种组合问题。

对于规模较大的问题,回溯算法的时间复杂度很高,需要考虑优化算法以提高性能。

在实际应用中,可以结合其他算法,如剪枝等技巧,来改进回溯算法的性能。

回溯算法是一种非常有价值的算法,值得进一步研究和应用。

回溯法解决8皇后问题实验报告

回溯法解决8皇后问题实验报告

算法设计与分析实验报告实验名称:用回溯法解决八皇后问题姓名:学号:江苏科技大学一、实验名称:回溯法求解8皇后问题二、学习知识:回溯算法的基本思想是:从一条路往前走,能进则进,不能进则退回来,换一条路再试。

回溯法是一个既带有系统性又带有跳跃性的搜索算法。

它在包含问题的所有解的解空间树中,按照深度优先的策略,从根结点出发搜索解的空间树。

算法搜索至解的空间树的任一结点时,总是先判断该结点是否肯定不包含问题的解。

如果肯定不包含,则跳过对以该结点为根的子树的系统搜索,逐层向其祖先结点回溯。

否则,进入该子树,继续按深度优先的策略进行搜索。

回溯法在用来求问题的所有解时,要回溯到根,且根结点的所有子树都已被搜索遍才结束。

而回溯法在用来求问题的任一解时,只要搜索到问题的一个解就可以结束。

这种以深度优先的方式系统地搜索问题的解的算法称为回溯法,它适用于解一些组合数较大的问题。

三、问题描述(1)使用回溯法解决八皇后问题。

8皇后问题:在8*8格的棋盘上放置彼此不受攻击的8个皇后。

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

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

(2)用高级程序设计语言实现四、求解思路Procedure PLACE(k)//如果一个皇后能放在第k行和X(k)列,则返回true,否则返回false。

X是一个全程数组,进入此过程时已置入了k个值。

ABS(r)过程返回r的绝对值//global X(1:k); integer i,k;i←1while i<k doif X(i)=X(k) or ABS(X(i)-X(k))=ABS(i-k) thenreturn (false)end ifi←i+1repeatreturn (true)End PLACEProcedure NQUEENS(n)//此过程使用回溯法求出一个n*n棋盘上放置n个皇后,使其不能互相攻击的所有可能位置//integer k,n,X(1:n)X(1)←0 ; k←1 // k是当前行;X(k)是当前列 //while k>0 do // 对所有的行,执行以下语句 //X(k)←X(k)+1 //移到下一列//while X(k)<=n and Not PLACE(k) do //此处能放这个皇后吗//X(k)←X(k)+1 //不能放则转到下一列//repeatif X(k)<=n then //找到一个位置//if k=n then print (X) //是一个完整的解则打印这个数组// else k←k+1;X(k)←0 //否则转到下一行//end ifelse k←k-1 //回溯//end ifrepeatEnd NQUEENS五、算法实现本实验程序是使用C#编写,算法实现如下:1.queen类—实现8皇后问题的计算,将结果存入数组。

人工智能实验报告,包括八数码问题八皇后问题和tsp问题

人工智能实验报告,包括八数码问题八皇后问题和tsp问题

八数码问题(一)问题描述在一个3*3的方棋盘上放置着1,2,3,4,5,6,7,8八个数码,每个数码占一格,且有一个空格。

这些数码可以在棋盘上移动,其移动规则是:与空格相邻的数码方格可以移入空格。

现在的问题是:对于指定的初始棋局和目标棋局,给出数码的移动序列。

该问题称八数码难题或者重排九宫问题。

(二)问题分析八数码问题是个典型的状态图搜索问题。

搜索方式有两种基本的方式,即树式搜索和线式搜索。

搜索策略大体有盲目搜索和启发式搜索两大类。

盲目搜索就是无“向导”的搜索,启发式搜索就是有“向导”的搜索。

1、启发式搜索由于时间和空间资源的限制,穷举法只能解决一些状态空间很小的简单问题,而对于那些大状态空间的问题,穷举法就不能胜任,往往会导致“组合爆炸”。

所以引入启发式搜索策略。

启发式搜索就是利用启发性信息进行制导的搜索。

它有利于快速找到问题的解。

由八数码问题的部分状态图可以看出,从初始节点开始,在通向目标节点的路径上,各节点的数码格局同目标节点相比较,其数码不同的位置个数在逐渐减少,最后为零。

所以,这个数码不同的位置个数便是标志一个节点到目标节点距离远近的一个启发性信息,利用这个信息就可以指导搜索。

即可以利用启发信息来扩展节点的选择,减少搜索范围,提高搜索速度。

启发函数设定。

对于八数码问题,可以利用棋局差距作为一个度量。

搜索过程中,差距会逐渐减少,最终为零,为零即搜索完成,得到目标棋局。

(三)数据结构与算法设计该搜索为一个搜索树。

为了简化问题,搜索树节点设计如下:struct Chess//棋盘{int cell[N][N];//数码数组int Value;//评估值Direction BelockDirec;//所屏蔽方向struct Chess * Parent;//父节点};int cell[N][N]; 数码数组:记录棋局数码摆放状态。

int Value; 评估值:记录与目标棋局差距的度量值。

Direction BelockDirec; 所屏蔽方向:一个屏蔽方向,防止回推。

八皇后问题实验报告

八皇后问题实验报告

实验报告——八皇后问题求解(递归和非递归)学号:专业年级:姓名:一、需求分析(要实现的功能描述)1.问题描述八皇后问题是一个以国际象棋为背景的问题:如何能够在8×8的国际象棋棋盘上放置八个皇后,使得任何一个皇后都无法直接吃掉其他的皇后?为了达到此目的,任两个皇后都不能处于同一条横行、纵行或斜线上。

八皇后问题可以推广为更一般的n皇后摆放问题:这时棋盘的大小变为n×n,而皇后个数也变成n。

当且仅当n=1或n≥4时问题有解。

八皇后问题最早是由国际国际象棋棋手马克斯·贝瑟尔于1848年提出。

诺克也是首先将问题推广到更一般的n皇后摆放问题的人之一。

2.实现功能八皇后问题实现了在棋盘上摆放八个皇后的功能,这八个皇后任意两个皇后都不能处于同一条横行、纵行或斜线上。

3.测试数据测试数据可以通过手工寻找三组满足需要的值,测试数组(M,N),其中M代表皇后所在的行,N代表皇后所在的列。

例如,第一组测试数据:(1,4)、(2,7)、(3,3)、(4、8)、(5,2)、(6,5)、(7,1)、(8,6);第二组测试数据(1,4)、(2,2)、(3,7)、(4,3)、(5,6)、(6,8)、(7,5)、(8,1)。

最后与编程求得的结果进行比较。

如果这三组数据在最后编程求得的结果中,说明程序的编写基本没有什么问题。

二、概要设计在进行概要设计的过程中,要清楚整个程序包含的功能模块及模块间的调用关系。

对于八皇后问题,整个程序中应该包括主函数模块,摆放皇后的函数模块,以及判断皇后的位置是否摆放正确的判断模块。

对于模块间的关系,在运行主函数的过程中会调用摆放皇后的函数模块,在摆放皇后的函数模块中,又会调用判断皇后位置是否摆放正确的判断模块。

三、详细设计抽象数据类型中定义的各种操作算法实现(用N-S图描述)对于求解八皇后问题的非递归算法,N-S图如下:对于八皇后问题求解的递归算法,N-S图如下:四、调试分析1.程序在调式过程中出现的问题及解决方法由于对于C语言编程问题掌握的并非十分熟练,因而在程序的调试过程中出现了一些问题。

八皇后问题实验报告

八皇后问题实验报告

软件工程上机报告实验名称:八皇后问题图形界面求解姓名:郭恂学号:2011011435班级:11级数学班中国石油大学(北京)计算机科学与技术系一、试验程序截图:点击显示下一组解即可显示下一组解:同样的,如果点击上一组解即可显示上一组解。

若在第1组解时点击显示上一组解会弹出报错提示框。

同样,若在第92组解点击显示下一组解也会弹出报错提示框:二、程序代码程序使用Java语言编写,编写环境为jdk1.6.0_18。

使用编程开发环境eclipse.exe编写。

本程序创建了两个类,两个类在同一个工程中。

其中Queen类的作用仅仅用来保存八皇后问题计算结果的数据,便于画图时使用。

本程序大概由两部分组成,第一部分是解八皇后问题,第二部分是画图。

程序源代码为:类1:public class Queen{public int[] x=new int[8];public int[] y=new int[8];public String name;}类2:import javax.swing.*;import java.awt.event.*;import java.awt.*;import javax.swing.JOptionPane;public class bahuanghou extends JFrame implements ActionListener {//JLabel[] l;int number=0; //当前显示的解的编号int sum=0; //所有解得数量JLabel l2;JButton b1,b2; //b1为显示下一组解得按钮,b2为显示上一组解得按钮。

Queen[] q=new Queen[128]; //得到的解储存在Queen类的数组里面。

private Image bomb1=Toolkit.getDefaultToolkit().getImage("D:\\qizi1.JPG"); //黑格棋子为bomb1private Image bomb2=Toolkit.getDefaultToolkit().getImage("D:\\qizi2.JPG"); //白格棋子为bomb2public bahuanghou() //构造方法,初始化窗口。

八皇后课程设计实验报告_C++

八皇后课程设计实验报告_C++

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

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

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

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

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

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

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

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

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

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

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

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

八皇后问题一.八皇后问题简述:在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皇后问题。

回溯算法应用实验报告

回溯算法应用实验报告

一、实验目的通过本次实验,旨在掌握回溯算法的基本原理和应用方法,加深对回溯算法的理解,并学会运用回溯算法解决实际问题。

实验内容包括:设计回溯算法解决八皇后问题、0-1背包问题以及TSP问题,并对算法进行时间复杂度和空间复杂度的分析。

二、实验内容1. 八皇后问题问题描述:在8x8的国际象棋棋盘上,放置8个皇后,使得它们互不攻击。

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

算法设计:使用回溯算法,通过递归尝试在棋盘上放置皇后,当出现冲突时回溯到上一步,重新尝试。

代码实现:```pythondef is_valid(board, row, col):for i in range(row):if board[i] == col or abs(board[i] - col) == abs(i - row):return Falsereturn Truedef solve_n_queens(n):def backtrack(row):if row == n:result.append(board[:])returnfor col in range(n):if is_valid(board, row, col):board[row] = colbacktrack(row + 1)board[row] = -1board = [-1] nresult = []backtrack(0)return result```2. 0-1背包问题问题描述:给定n个物品,每个物品有一个价值v[i]和重量w[i],以及一个背包容量W,如何选择物品使得背包中的物品总价值最大且不超过背包容量。

算法设计:使用回溯算法,递归尝试选择每个物品,当背包容量不足或物品价值超过剩余容量时回溯到上一步。

代码实现:```pythondef knapsack(weights, values, capacity):def backtrack(i, cw, cv):if cw > capacity or i == len(weights):return cvif not backtrack(i + 1, cw, cv):return cvif cw + weights[i] <= capacity:return max(backtrack(i + 1, cw, cv), backtrack(i + 1, cw + weights[i], cv + values[i]))else:return cvreturn backtrack(0, 0, 0)```3. TSP问题问题描述:给定n个城市,以及每对城市之间的距离,求出一条最短路径,使得路径上的城市互不相同,并且最终回到起点。

八皇后实验报告心得

八皇后实验报告心得

八皇后实验报告心得引言八皇后问题是一个经典的回溯算法问题,它的目标是在一个8x8的棋盘上放置8个皇后,使得任意两个皇后都不在同一行、同一列或同一对角线上。

这个问题看似简单,但实际上非常复杂,需要用到回溯算法来进行求解。

在本次实验中,我们使用Python语言实现了八皇后问题的解法,并进行了一系列的实验。

实验目的本实验旨在通过实现八皇后问题的解法,加深对回溯算法思想的理解,同时掌握Python语言的基本语法和列表操作。

实验方法我们采用了递归的回溯算法来解决八皇后问题。

具体步骤如下:1. 创建一个空的棋盘列表,并初始化为全0。

2. 从第一行开始,从左至右遍历每一个格子。

3. 对于每个格子,如果该格子满足放置皇后的条件(不与已放置的皇后冲突),则在该位置标记为1,并递归地进入下一行。

4. 如果在某一行找不到合适的位置放置皇后,则回溯到上一行,尝试放置在下一个位置。

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

实验结果经过多次实验,我们成功地获得了一共92个不同的解决方案。

每个解决方案都是一个8x8的矩阵,其中1表示放置了皇后的位置,0表示空位置。

以下是其中一种解决方案的示意图:0 0 0 0 1 0 0 00 0 0 0 0 0 1 00 1 0 0 0 0 0 00 0 0 0 0 1 0 00 0 0 0 0 0 0 11 0 0 0 0 0 0 00 0 0 1 0 0 0 00 0 1 0 0 0 0 0实验分析与讨论通过实验,我们发现八皇后问题的解法非常依赖于回溯算法。

回溯算法通过不断地试错、回溯的方式,能够高效地找到所有解决方案。

在本次实验中,我们并未采用剪枝优化的策略,仅仅用递归来实现,所以算法的时间复杂度较高。

然而,由于八皇后问题的规模较小(仅有8个皇后),所以运行时间仍然可以接受。

实验总结通过本次实验,我们不仅掌握了回溯算法的基本思想,还熟悉了Python语言的基本语法和列表操作。

同时,我们深刻认识到八皇后问题的复杂性,以及回溯算法在解决复杂问题上的作用。

回溯法实验报告

回溯法实验报告

一、实验目的1. 理解回溯法的概念和基本原理。

2. 掌握回溯法的应用场景和实现方法。

3. 通过具体实例,验证回溯法在解决实际问题中的有效性。

二、实验内容本次实验主要围绕回溯法进行,通过以下实例来验证回溯法在解决实际问题中的有效性:1. 八皇后问题2. 0/1背包问题3. 数独游戏三、实验步骤1. 八皇后问题(1)定义问题:在8×8的国际象棋棋盘上,放置8个皇后,使得它们不能相互攻击。

(2)设计回溯算法:① 初始化棋盘为全空状态。

② 从第一行开始,尝试将皇后放置在每一列。

③ 如果某一列放置皇后后,不会与已放置的皇后发生冲突,则继续在下一行尝试放置。

④ 如果某一列放置皇后后,与已放置的皇后发生冲突,则回溯至上一个放置皇后的行,尝试在下一列放置。

⑤ 当所有行都放置了皇后,则找到一个解。

(3)实现代码:```pythondef is_valid(board, row, col):for i in range(row):if board[i] == col or \board[i] - i == col - row or \board[i] + i == col + row:return Falsereturn Truedef solve_n_queens(board, row):if row == len(board):return Truefor col in range(len(board)):if is_valid(board, row, col):board[row] = colif solve_n_queens(board, row + 1):return Trueboard[row] = -1return Falsedef print_board(board):for row in board:print(' '.join(['Q' if x == row else '.' for x in range(len(board))]))def n_queens():board = [-1] 8if solve_n_queens(board, 0):print_board(board)else:print("No solution exists")n_queens()```2. 0/1背包问题(1)定义问题:给定n个物品,每个物品有重量和价值,背包容量为W,求出能够装入背包的物品组合,使得背包内物品的总价值最大。

数据结构实验报告利用栈结构实现八皇后问题

数据结构实验报告利用栈结构实现八皇后问题

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

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

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

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

①可以使用递归或非递归两种方法实现②实现一个关键算法:判断任意两个皇后是否在同一行、同一列和同一斜线。

(3)代码要求①必须要有异常处理,比如删除空链表时需要抛出异常;②保持良好的编程的风格:代码段与段之间要有空行和缩近标识符名称应该与其代表的意义一致函数名之前应该添加注释说明该函数的功能关键代码应说明其功能③递归程序注意调用的过程,防止栈溢出2. 程序分析2.1 存储结构栈(递归):2.2 关键算法分析(1)递归void SeqStack<T>::PlaceQueen(int row) //在栈顶放置符合条件的值的操作,即摆放皇后{for (int col=0;col<StackSize;col++) //穷尽~7,即穷尽列{Push(col);if (Judgement()) //判断摆放皇后的位置是否安全{if (row<StackSize-1) //若还没有放到第八个皇后,则进行下一个皇后的放置PlaceQueen(row+1);else{ans++;Output();}}Pop(); //若不符合条件则出栈}}时间复杂度:O(n2)(2) 判断皇后放置位置是否符合要求bool SeqStack<T>::Judgement(){for(int i=0;i<top;i++) //依次检查前面各行的皇后位置,if(data[top]==data[i]||(abs(data[top]-data[i]))==(top-i)) //判断是否在同一列同一斜线return false;return true;}算法步骤:①对于一个坐标,将前面每一个坐标均与这个坐标比较②若在同一列或在同一斜线上,则返回0,③否则j自增1,面每一个坐标与前面做比较④若与前面坐标在同一列⑤最后返回true or false.2.3 其他说明:由于输出显示时对话框有限,而程序结果比较多,占用空间大,最后只显示60种到92种,这需要适当的设置对话框,设置步骤为:属性—屏幕缓冲区高度设为相对大些的值(1000或其他),即可显示所有结果。

(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.问题描述设在初始状态下在国际象棋的棋盘上没有任何棋子(这里的棋子指皇后棋子)。

然后顺序在第1行,第2行……第8行上布放棋子。

在每一行中共有8个可选择的位置,但在任一时刻棋盘的合法布局都必须满足3个限制条件(1)任意两个棋子不得放在同一行(2)任意两个棋子不得放在同一列上(3)任意棋子不得放在同一正斜线和反斜线上。

2.基本要求编写求解并输出此问题的一个合法布局的程序。

3、实现提示:在第i行布放棋子时,从第1列到第8列逐列考察。

当在第i行第j列布放棋子时,需要考察布放棋子后在行方向、列方向、正斜线和反斜线方向上的布局状态是否合法,若该棋子布放合法,再递归求解在第i+1行布放棋子;若该棋子布放不合法,移去这个棋子,恢复布放该棋子前的状态,然后再试探在第i行第j+1列布放棋子。

4 程序代码#include<iostream.h>#include<stdio.h>static char Queen[8][8];static int a[8];static int b[15];static int c[15];static int QueenNum=0;//记录总的棋盘状态数void qu(int i);//参数i代表行int main(){int Line,Column;//棋盘初始化,空格为*,放置皇后的地方为@ for(Line=0;Line<8;Line++){a[Line]=0; //列标记初始化,表示无列冲突for(Column=0;Column<8;Column++)Queen[Line][Column]='*';}//主、从对角线标记初始化,表示没有冲突for(Line=0;Line<15;Line++)b[Line]=c[Line]=0;qu(0);return 0;}void qu(int i){int Column;for(Column=0;Column<8;Column++){if(a[Column]==0&&b[i-Column+7]==0&&c[i+Column]==0) //如果无冲突{Queen[i][Column]='Q'; //放皇后a[Column]=1;//标记,下一次该列上不能放皇后b[i-Column+7]=1;//标记,下一次该主对角线上不能放皇后c[i+Column]=1;//标记,下一次该从对角线上不能放皇后if(i<7) qu(i+1); //如果行还没有遍历完,进入下一行else//否则输出{//输出棋盘状态int Line,Column;cout<<"第"<<++QueenNum<<"种状态为:"<<endl;for(Line=0;Line<8;Line++){for(Column=0;Column<8;Column++)cout<<Queen[Line][Column]<<" ";cout<<endl;}cout<<endl;getchar();}/*如果前次的皇后放置导致后面的放置无论如何都不能满足要求,则回溯,重置*/Queen[i][Column]='*';a[Column]=0;b[i-Column+7]=0;c[i+Column]=0;}}}5 程序结果题目2 背包问题的求解1.问题描述假设有一个能装入总体积为T的背包和n件体积分别为w1,w2,…w n的物品,能否从n件物品中挑选若干件恰好装满背包,即使w1+w2+…+w m=T,要求找出所有满足上述条件的解。

八皇后数据结构实验报告 完整版

八皇后数据结构实验报告 完整版

数据结构实验报告——八皇后问题实验目的:熟练掌握栈操作的基本算法实现。

实现功能:利用回溯法和栈来实现八皇后问题:在8×8的国际象棋棋盘上, 安放8个皇后, 要求没有一个皇后能够“吃掉”任何其他一个皇后, 即没有两个或两个以上的皇后占据棋盘上的同一行、同一列或同一对角线。

设计思路:数据结构:enum boolean { false , true }enum boolean a[9] , b[17] , c[17] ;//检查皇后之间是否冲突//皇后位置安全性可用逻辑表达式: a[ j ] && b[ i+j ] && c[ i-j+9 ]int s[9];//s[1..8]表示顺序栈, 栈的下标值表示皇后所在的行号, 栈的内容是皇后所在的列号。

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

程序流程图:源程序:#include<stdio.h>enum boolean {FALSE,TRUE}; //声明全局变量enum boolean a[9],b[17],c[17];int s[9];int num=0;//函数声明void print();void movequeen();void eightqueen();void main(){ //主函数eightqueen();printf("共有%d种解法\n",num);}void print() //输出函数{int k;printf("\n");printf("NO.%d\n",++num);printf("行号: 1 2 3 4 5 6 7 8\n");printf("列号:");for(k=1;k<=8;k++)printf("%3d",s[k]);printf("\n");}void movequeen(int i,int j){a[j]=TRUE;b[i+j]=TRUE;c[i-j+9]=TRUE;}void eightqueen()//算法函数{int i,j;for(i=2;i<=16;i++){if(i>=2&&i<=9)a[i-1]=TRUE;b[i]=TRUE;c[i]=TRUE;}i=1;j=1;while(i>=1){while(j<=8){if(a[j]&&b[i+j]&&c[i-j+9])break;j++;}if(j<=8){a[j]=FALSE;b[i+j]=FALSE;c[i-j+9]=FALSE;s[i]=j;if(i==8){num++;print();movequeen(i,j);i--;j=s[i];movequeen(i,j);j++;}else {i++;j=1;}}else{i--;if(i>=1){j=s[i];movequeen(i,j);j++;}}}}实验心得:通过本次实验大大的提高了我个人的动手能力, 对VC编程更加的熟练, 这个程序也一定程度的锻炼了我的思考能力, 对于八皇后问题的逻辑编排, 全局处理, 细节完善等方面都有一个深刻的认识。

八皇后实验报告

八皇后实验报告

实验项目:八皇后问题1•实验目的:通过求解皇后问题,熟悉深度优先搜索法DFS (回溯法(Backtracking Algorithms)技术。

2•实验内容:由n2个方块排成n行n列的正方形称为n元棋盘。

如果两个皇后位于n元棋盘上的同一行、同一列或同一对角线上,则称它们在互相攻击。

现要找出使棋盘上n 个皇后互不攻击的布局。

编制程序解决上述问题,以n=6运行程序,输出结果。

3•程序简介:将n个皇后放到一个n*n的方阵中,要求每个皇后不在同一行同一列及同一对角线,我的程序是先把每个皇后放在了第零列,然后再按行检查,不符合要求继续下一列,若已经到这一行的最后一列,还没找到符合要求的位置,则回到上一行。

4•算法设计介绍:定义一个一维数组,数组的下标是皇后所在位置的行数,数组存的值是皇后所在位置的列数,现将A[0]-A[n-l]都赋成零,然后随着检查的进行,皇后的位置也在不断地变化,最后找到一个符合要求的方阵时,本质上就是一个存放整数的一维数组,数组的下标是行数,存放的值是列数。

5•困难及解答我很久以前就听说过八皇后问题,没想到现在轮到自己编了,一开始还真是特别糊涂呢,后来老师上课把算法大概讲了一遍,就清楚很多了,要说问题,就是一开始纠结怎么存放皇后,我开始想用二维数组着,后来老师说用一维数组比较好做,我看了一下老师的算法,就明白了大概,经过一段时间就编出来了5•心得我编程变得还是很少,天天下决心说以后多编,也没践行,心想着吧,不挂在嘴上了,努力!6•程序清单/*〃我真诚地保证:〃我独立完成了整个程序从分析、设计到编码的所有工作。

〃如果在上述过程中,我遇到了什么困难而求教于人,那么,我将在程序实习报告中〃详细地列举我所遇到的问题,以及别人给我的提示。

〃我的程序里中凡是引用到其他程序或文档之处,〃例如教材、课堂笔记、网上的源代码以及其他参考书上的代码段,〃我都已经在程序的注释里很清楚地注明了引用的出处。

〃我从未没抄袭过别人的程序,也没有盗用别人的程序,〃不管是修改式的抄袭还是原封不动的抄袭。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
A[n-1]++;//继续向右走
前一行去,即回溯
}}A[i]=0; i--;//行数减一
if(i>=0) A[i]++;}//向后挪一个把前一行的皇后
return0;}运行结果:
for(n=0;n<m;n++)//从第零行开始检查{if((A[n]==A[m])||((A[n]+n)==(A[m]+m))||((A[n]-n)==(A[m]-m))||((n-A[n])==(m- A[m])))//这种检查方法不包含同一行的情况,因为m不可能等于n}return true;}int main(){int n,i,A[max],s=1;
返回后的处理:
返回一个bool型的变量,若true,则下一个进入方阵的皇后可以放在这, 反之,则不能;
返回值(如果有的话):
true or false
函数的输入参数:无函数的输出参数:无*/
#include "iostream"
#define max100
using namespace std;
bБайду номын сангаасol unguarded(int A[],int m){int n;
独立
2.关于类的说明:
类名称:无定义该类的目的:
类属性:
类中函数及功能:
与其他类的关系(调用/被调用哪类对象中的什么函数):
3.关于函数的说明
(1)函数名称:
bool unguarded(int A[],int m)
函数功能描述:
检查A[]-1列和第m-1的皇后是否设防
函数调用之前的预备条件:
一位数组和整数m
//用一维数组表示皇后的位置的思想来自课堂笔记
cout«"请输入皇后的个数"<<endl;
cin>>n;
if((n<=3)||(n>=100))cout<<"请不要输入
1、2、3或者大于100的数!"<<endl;〃一个没有意义,两个和三个不管怎 么放都会在同一行和同一列
else{
for(i=0;i< n;i++) A[i]=0;〃先把每个皇后放在第一列,然后按行检察i=0;〃然后
从第零行开始
while(i>=0)//回溯结束的条件{if(A[i]<=n-1)//当前行数的前边的每一行都要检查,从第零列return false;
检查到第n-1列
{//检测A[i]与A[0]~A[i-1]是否有冲突}else {//当某一行全检查完了还是没有皇后的位置,就得返回到if(!unguarded(A,i)) A[i]++;//设防,继续往下一列走else{}if(i<n-1) i++;〃当i行不是最后一行的时候
文件名称:
创建者:
创建时间:
2011.4.14
最后修改时间:
2011.4.17
功能:
不同个数皇后的排列问题,各个皇后不再同一行同一列以及同一对角线 文件中的函数名称和简单功能描述:
bool unguarded(int A[],int m),检查A[]-1列和第m-1行的皇后有没有设防
文件中定义的全局变量和简单功能描述:无文件中用到的他处定义的全局 变量及其出处:无与其他文件的依赖关系:
//我的程序里中凡是引用到其他程序或文档之处,
//例如教材、课堂笔记、网上的源代码以及其他参考书上的代码段,
//我都已经在程序的注释里很清楚地注明了引用的出处。
//我从未没抄袭过别人的程序,也没有盗用别人的程序,//不管是修改式的 抄袭还是原封不动的抄袭。//我编写这个程序,从来没有想过要去破坏或妨碍其 他计算机系统的正常运转
实验项目:
八皇后问题
1.实验目的:
通过求解皇后问题,熟悉深度优先搜索法DFS(回溯法(Backtracking Algorithms)技术。
2.实验内容:
由n2
个方块排成n行n列的正方形称为n元棋盘。如果两个皇后位于n元棋盘 上的同一行、同一列或同一对角线上,则称它们在互相攻击。现要找出使棋盘 上n个皇后互不攻击的布局。编制程序解决上述问题,以n=6运行程序,输出
我编程变得还是很少,天天下决心说以后多编,也没践行,心想着吧,不 挂在嘴上了,努力!
6.程序清单
/*
//我真诚地保证:
//我独立完成了整个程序从分析、设计到编码的所有工作。
//如果在上述过程中,我遇到了什么困难而求教于人,那么,我将在程序实 习报告中
//详细地列举我所遇到的问题,以及别人给我的提示。
5.困难及解答
我很久以前就听说过八皇后问题,没想到现在轮到自己编了,一开始还真 是特别糊涂呢,后来老师上课把算法大概讲了一遍,就清楚很多了,要说问 题,就是一开始纠结怎么存放皇后,我开始想用二维数组着,后来老师说用一
维数组比较好做,我看了一下老师的算法,就明白了大概,经过一段时间就编 出来了
5.心得
结果。
3.程序简介:
将n个皇后放到一个n*n的方阵中,要求每个皇后不在同一行同一列及同 一对角线,我的程序是先把每个皇后放在了第零列,然后再按行检查,不符合 要求继续下一列,若已经到这一行的最后一列,还没找到符合要求的位置,则 回到上一行。
4.算法设计介绍:
定义一个一维数组,数组的下标是皇后所在位置的行数,数组存的值是皇 后所在位置的列数,现将A[0]-A [n-1]都赋成零,然后随着检查的进行,皇后的位 置也在不断地变化,最后找到一个符合要求的方阵时,本质上就是一个存放整 数的一维数组,数组的下标是行数,存放的值是列数。
else//是最后一行的话输出皇后的摆放方式{}cout<<"第”vvsvv”个:
"<<endl;
for(int j=0;j<n;j++){
for(int d=0;d<n;d++){
if(d!=A[j])
cout<<'+'<<'';
else
cout<<'@'<<'';}
cout<<endl;}
s+=1;//记录已近有几种摆放方式
相关文档
最新文档