八皇后问题

八皇后问题
八皇后问题

安徽省巢湖学院计算机与信息工程学院

课程设计报告

课程名称《数据结构》

课题名称八皇后问题

专业计算机科学与技术

班级

学号

姓名

联系方式

指导教师

2011 年 12 月 25日

目录

1、数据结构课程设计任务书.............................................................................................. 1

1.1、题目..................................................................................................................... 1

1.2、要求..................................................................................................................... 1

2、总体设计....................................................................................................................... 1

2.1、功能模块设计 ...................................................................................................... 1

2.2、所有功能模块的流程图........................................................................................ 2

3、详细设计....................................................................................................................... 5

3.1、程序中所采用的数据结构及存储结构的说明........................................................ 5

3.2、算法的设计思想................................................................................................... 5

3.3、稀疏矩阵各种运算的性质变换 ............................................................................. 5

4、调试与测试:................................................................................................................ 6

4.1、调试方法与步骤: ............................................................................................... 6

4.2、测试结果的分析与讨论: .................................................................................... 6

4.3、测试过程中遇到的主要问题及采取的解决措施:................................................. 6

5、时间复杂度的分析:..................................................................................................... 6

6、源程序清单和执行结果 ................................................................................................. 6

7、C程序设计总结 ........................................................................................................ 10

8、致谢.......................................................................................................................... 10

9、参考文献................................................................................................................... 10

1、数据结构课程设计任务书

1.1、题目

八皇后问题

1.2、要求

编写程序实现将八个皇后放置在国际象棋棋盘的无冲突的位置上的算法,并给出所有的解。

2、总体设计

本课件学生是用循环递归循环来实现的,分别一一测试了每一种摆法,并把它拥有的92种变化表现出来。在这个程序中,我的主要思路以及思想是这样的:

1)解决冲突问题:

这个问题包括了行,列,两条对角线;

列:规定每一列放一个皇后,不会造成列上的冲突;

行:当第I行被某个皇后占领后,则同一行上的所有空格都不能再放皇后,要把以I 为下标的标记置为被占领状态;

对角线:对角线有两个方向。在这我把这两条对角线称为:主对角线和从对角线。在同一对角线上的所有点(设下标为(i,j)),要么(i+j)是常数,要么(i-j)是常数。因此,当第I 个皇后占领了第J列后,要同时把以(i+j)、(i-j)为下标的标记置为被占领状态。

2)数据结构的实现

而对于数据结构的实现,学生则是着重于:

数组a[I]:a [I]表示第I个皇后放置的列;I的范围:1..8;

对角线数组:b[j](主对角线),c[j](从对角线),根据程序的运行,去决定主从对角线是否放入皇后;

2.1、功能模块设计

根据课程设计题目的功能要求,各个功能模块的组成框图如下:

Mian()函数

QueenRe(Qu een *Q, int y)函数

PrintQueen( Queen *t)函数

Checker(voi d)函数

QueenPic(v

oid)函数

SetQueen(

Queen *Q)

2.2、所有功能模块的流程图

皇后模块流程图

八皇后递归流程图

START

行循环遍历完毕

列循环遍历

当前位置可否放置皇后

放置皇后,并且标记下次该列,主次对角线不能放皇后

回朔 重置 Y

N

列遍历完毕

输出图形

End

N

Y

N

Y

3、详细设计

模块功能说明:如函数功能、入口及出口参数说明,函数调用关系描述等;

皇后模块算法:画皇后图象,然后存储到缓冲区

八皇后摆放方法模块:八皇后的递归算法

初始化模块:初始化

3.1、程序中所采用的数据结构及存储结构的说明

数据结构的实现:数组a[i]:a [i]表示第i个皇后放置的列;i的范围:1-8;对角线数组:b[j](主对角线),c[j](从对角线),根据程序的运行,去决定主从对角线是否放入皇后;然后进行数据的初始化。从n列开始摆放第n个皇后(因为这样便可以符合每一竖列一个皇后的要求),先测试当前位置(n,m)是否等于0(未被占领):如果是,摆放第n个皇后,并宣布占领(切记要横列竖列斜列一起来),接着进行递归;如果不是,测试下一个位置(n,m+1),但是如果当n<=8,m=8时,却发现此时已经无法摆放时,便要进行回溯。

3.2、算法的设计思想

本程序通过对子函数void qu(int i)的调用,将八皇后的问题关键通过数据结构的思想予以了实现。虽然题目以及演算看起来都比较复杂,繁琐,但在实际中,只要当一只皇后放入棋盘后,在横与列、斜线上没有另外一只皇后与其冲突,再对皇后的定位进行相关的判断。即可完成。如果在这个程序中,我们运用的是非递归的思想,那么将大量使用if等语句,并通过不断的判断,去推出答案,而且这种非递归的思想,大大的增加了程序的时间复杂度。如果我们使用了数据结构中的算法后,那么程序的时间复杂度,以及相关的代码简化都能取得不错的改进。这个程序,我运用到了数据结构中的栈、数组,以及树和回溯的方法。特别是在对于树以及二叉树的学习,更是为八皇后的问题提供了科学的解决方案,通过对树的分析,把八皇后的问题看成了树,而在衍生第一个变化后,上面的第一层八个变化就变成了八个结点,而这八个结点再继续的衍生……,这样比较形象的将八皇后的问题简单化了。然后再通过回溯法进行设计,回溯法是设计递归过程的一个重要的方法。它的求解过程实质上是一个先序遍历一棵“状态树“的过程。在这个程序设计中,它先进行判断,棋盘上是否已经得到一个完整的布局(即棋盘是否已经摆上8个棋子),如果是,则输出布局;如果不是则依次先根遍历满足约束条件的各棵子树,流程即是:

判断该子树根的布局是否合法:如果合法的话,则先根遍历该子树;如果不合法的话,则剪去该子树的分支。

3.3、稀疏矩阵各种运算的性质变换

4、调试与测试:

4.1、调试方法与步骤:

4.2、测试结果的分析与讨论:

(测试要写出测试用例及每个用例结果的的截图)

通过编译连接后,程序基本上把八皇后的92种摆法的都进行了演示;但程序运行中也出现了以下缺点:

因为八皇后的表现方法甚多,输出后虽能全部显示,但未能使屏幕停留,把一个一个的将其显示出来,但是这样便使得操作步骤太多,也会造成不必要的麻烦!所以只画出了第一种和最后一种的输出结果,演示如图所示:

正确输出结果如下:

4.3、测试过程中遇到的主要问题及采取的解决措施:

5、时间复杂度的分析:

6、源程序清单和执行结果

(清单中应有足够的注释)

【示例1】

#include

#include

#include

#include

#include

void *buff1,*buff2;

typedef struct

{

int A[21],B[21],C[21],Y[8];

}

Queen;

void SetQueen(Queen *Q) /* 初始化 */

{

int i;

for(i=0;i<21;i++)

{

Q->A[i]=0;

Q->B[i]=0;

Q->C[i]=0;

}

for(i=0; i<8; i++)

Q->Y[i]=-1;

}

void QueenPic(void) /* 画皇后图象,然后存储到缓冲区 */ {

int size,

polypoints1[10]={9,1,11,1,20,20,1,20,9,1},

polypoints2[10]={29,1,31,1,40,20,21,20,29,1};

setfillstyle(SOLID_FILL,LIGHTBLUE); /* 画淡蓝色棋格 */ setcolor(LIGHTBLUE);

rectangle(1,1,20,20);

floodfill(10,10,LIGHTBLUE);

setfillstyle(SOLID_FILL,WHITE); /* 画白色棋格 */

setcolor(WHITE);

rectangle(21,1,40,20);

floodfill(30,10,WHITE);

setfillstyle(SOLID_FILL,DARKGRAY);

setcolor(YELLOW);

drawpoly(5,polypoints1);

floodfill(10,10,YELLOW);

floodfill(30,10,YELLOW);

size=imagesize(1,1,20,20); /* 计算缓冲区大小,然后存储 */ buff1=(void *)malloc(size);

buff2=(void *)malloc(size);

getimage(1,1,20,20,buff1);

getimage(21,1,40,20,buff2);

cleardevice();

}

void Checker(void) /* 画棋盘函数 */

{

int i,k;

for(k=0;k<8;k++)

for(i=0;i<8;i++)

if(k%2==0&&i%2==0||k%2!=0&&i%2!=0)

{

setfillstyle(SOLID_FILL,LIGHTBLUE);

setcolor(LIGHTBLUE);

rectangle(i*20,20+k*20,(i+1)*20,20+(k+1)*20);

floodfill(i*20+10,20+k*20+10,LIGHTBLUE);

}

else

{

setfillstyle(SOLID_FILL,WHITE);

setcolor(WHITE);

rectangle(i*20,20+k*20,(i+1)*20,20+(k+1)*20);

floodfill(i*20+10,20+k*20+10,WHITE);

}

}

void PrintQueen(Queen *t) /* 图形输出函数 */

{int k;

char str[20];

static total=0;

total++;

setviewport(240,80,400,260,1); /* 设置窗口 */

sprintf(str,"NO.%d",total);

setcolor(GREEN);

settextstyle(0,0,1);

outtextxy(0,0,str);

Checker();

for(k=0;k<8;k++)

if(k%2==0&&t->Y[k]%2==0||k%2!=0&&t->Y[k]%2!=0)

putimage((t->Y[k])*20,20+k*20,buff1,COPY_PUT);

else

getch();

if(getch()==27) exit(0);

clearviewport();}

void QueenRe(Queen *Q, int y) /* 八皇后的递归算法 */

{int x;

if(y>7)

return;

for(x=0;x<8;x++)

if(!Q->A[x+7]&&!Q->B[x+y+7]&&!Q->C[x-y+7]) /* 下一棵要遍历的子树由状态数确定 */

{Q->Y[y]=x;

Q->A[x+7]=1;

Q->B[x+y+7]=1;

Q->C[x-y+7]=1;

if(y==7)

PrintQueen(Q);

QueenRe(Q,y+1); /* 进入下一层递归 */

Q->A[x+7]=0;

Q->B[x+y+7]=0;

Q->C[x-y+7]=0;}

}

void main(void)

{

Queen Q;

int gdriver=DETECT,gmode;

initgraph(&gdriver,&gmode,"D://Win-TC");

SetQueen(&Q);

setcolor(YELLOW);

QueenPic();

cleardevice();

setcolor(LIGHTGREEN);

settextstyle(0,0,3);

outtextxy(180,10,"Eight Queens");

setcolor(WHITE);

settextstyle(0,0,1);

outtextxy(250,400,"2009.11.8 3:30pm");

QueenRe(&Q,0);

getch();

closegraph();

}

.

.

.

.

.

第92

7、C程序设计总结

《数据结构》是计算机专业很重要的一门课程,也是必须要熟练掌握的课程,这次的课程设计对我的数据结构知识进行了一次全面的综合训练,加深了对数据结构基本概念和基本知识的理解,巩固了课堂上学的知识,掌握了数据结构的一些基本方法,深刻理解了算法,锻炼了自己分析问题解决问题的能力。

8、致谢

能够完成这次课程设计必须感谢^^(他帮我修改了几处重要错误,同时启发我完善了该

程序的功能)。

9、参考文献

吕凤哲 C++语言程序设计(第二版)北京:电子工业出版社,2005

耿国华数据结构——C语言描述西安电子科技大学出版社

苏仕华数据结构课程设计北京:机械工业出版社,2005.5

严蔚敏数据结构北京:清华大学出版社,1997

算法实验 递归回溯解八皇后问题

深圳大学实验报告 课程名称:算法分析与复杂性理论 实验项目名称:八皇后问题 学院:计算机与软件学院 专业:软件工程 指导教师:杨烜 报告人:学号:班级:15级软工学术型实验时间:2015-12-08 实验报告提交时间:2015-12-09 教务部制

一.实验目的 1.掌握选回溯法设计思想。 2.掌握八皇后问题的回溯法解法。 二.实验步骤与结果 实验总体思路: 根据实验要求,通过switch选择八皇后求解模块以及测试数据模块操作,其中八皇后模块调用摆放皇后函数模块,摆放皇后模块中调用判断模块。测试数据模块主要调用判断模块进行判断,完成测试。用一维数组保存每行摆放皇后的位置,根据回溯法的思想递归讨论该行的列位置上能否放置皇后,由判断函数Judge()判断,若不能放置则检查该行下一个位置。相应结果和过程如下所示(代码和结果如下图所示)。 回溯法的实现及实验结果: 1、判断函数 代码1: procedure BTrack_Queen(n) //如果一个皇后能放在第K行和X(k)列,则返回true,否则返回false。 global X(1:k);integer i,k i←1 while i0 do X(k)←X(k)+1 //移到下一个位置 while X(k)<=n and not Judge(k) do //判断能否放置皇后 X(k)←X(k)+1 repeat if X(k)<=n //找到一个位置 then if k=n //是一个完整的解吗

回溯法之N皇后问题(C语言)

//回溯法之N皇后问题当N>10,就有点抽了~~ /*结果前total行每行均为一种放法,表示第i行摆放皇后的列位置,第total+1行,输出total*/ #include #include int n,stack[100]; //存当前路径 int total; //路径数 void make(int l) //递归搜索以stack[l]为初结点的所有路径 { int i,j; //子结点个数 if (l==n+1) { total=total+1; //路径数+1 for(i=1;i<=n;i++) printf("%-3d",stack[i]); //输出第i行皇后的列位置stack[i] printf("\n"); exit; //回溯(若试题仅要求一条路径,则exit改为halt即可)} for (i=1;i<=n;i++) { stack[l]=i; //算符i作用于生成stack[l-1]产生子状态stack[l]; if (!att(l,i)) make(l+1); } //再无算符可用,回溯 } int att(int l,int i) { int k; for (k=1;k

八皇后问题算法分析

流程图 八皇后问题算法分析 在这个问题中首先定义的是一个用于构造界面的二位数组a【i】【j】和一个用于判断的表头数组number【】。在开始进行八皇后棋子排列的时候,首先对行进行递增循环,即i初始值为0,每次i++,i最大值为8的循环。在每次循环中产生一个小于8的随机数q,然后判断表头数组number【】中number【q】位置的值是否为1,如果不是,则在二维数组a【i】【q】位置上打印表示棋子的“K”;如果为1,则返回产生随机数的步骤继续产生随机数。在循环到i>8时,跳出循环,这时候一个完整的八皇后排列也就出来了。 源代码: package queen; import java.awt.*; import java.awt.event.*; class equeen extends Frame implements ActionListener{ //构造界面和定义数组 Button enter; Button clean; Button exit; int number[] = new int[8]; int i,j,q; Label a[][] = new Label[8][8]; equeen(String s){ GridLayout grid; grid = new GridLayout(9,8); setLayout(grid); enter = new Button("begin"); clean = new Button("clean");

exit = new Button("esit"); for(int i = 0;i<8;i++){ for(int j = 0;j<8;j++){ a[i][j] = new Label(); if((i+j)%2==0)a[i][j].setBackground(Color.yellow); else a[i][j].setBackground(Color.gray); add(a[i][j]); } } for(int i = 0;i<8;i++){ number[i] = 0;//初始化判断数组 } add(enter); add(clean); add(exit); enter.addActionListener(this); clean.addActionListener(this); exit.addActionListener(this); setBounds(100,100,300,300); setVisible(true); validate(); } public void actionPerformed(ActionEvent e){ if(e.getSource()==enter){ for(int i =0;i<8;i++){ for(int j=0;j<8;j++){ a[i][j].setText(""); } } for(int i =0;i<8;i++){ while(true){ q = (int)(Math.random()*8); if(number[q]==0){ a[i][q].setText("K"); number[q] = 1; break; } else if(number[q]!=0) continue; } } for(int i = 0;i<8;i++){ number[i] = 0; } }

八皇后问题及解答

八皇后问题 问题描述: 在一个8×8的棋盘里放置8个皇后,要求每个皇后两两之间不相冲突 (在每一横列,竖列,斜列只有一个皇后)。 求解: 标题: 八皇后问题的解(回溯法程序代码) 发信站: 网易虚拟社区(Fri Jul 14 10:06:52 2000),站内信件 以前上学的时候,写8皇后程序的时候偷懒用最笨的算法,在8086上计算十皇后的时候,我放了张纸条,说明计算机正在运行,然后去吃饭,吃完以后,才看到结果。前几天,刚好有空,所以重写了一次,以补当年的遗憾。 #include "stdio.h" int attacked(int *array,int position){ int flag=-1; float step; if(position==1) return flag; for(step= 1.00;step

(array+(int)step)-*(array+position))/(step-position))==-1){ flag=1; break;}} return flag;}void main(void){ int countSum,queenSum,printCount,*queenArray,queenPosition=0; int tempArray[20]={66,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; countSum=1; queenArray=tempArray; printf("input you queenSum here: "); scanf("%d",&queenSum); fflush(stdin); if(queenSum<4){ printf("the %d queen's sum is 0\n",queenSum); return;}for(;;){ if(countSum=queenSum){ if(*(queenArray+countSum-1)

八皇后问题的解决完整文档

工学院 数据结构课程设计报告设计题目:八皇后 2008 年 6 月25 日 设计任务书

摘要: 八皇后问题要求在一个8*8的棋盘上放上8个皇后,使得每一个皇后既攻击不到另外七个皇后,也不被另外七个皇后所攻击.按照国际象棋的规则,一个皇后可以攻击与之处在同一行或同一列或同一斜线上的其他任何棋子.因此,八皇后问题等于要求八个皇后中的任意两个不能被放在同一行或同一列或同一斜线上。 而本课程设计本人的目的也是通过用c++语言平台将一个8*8的棋盘上放上8个皇后,使得每一个皇后既攻击不到另外七个皇后,也不被另外七个皇后所攻击的92种结构予以实现.使用递归方法最终将其问题变得一目了然,更加易懂。 关键词:八皇后; c++; 递归法

目录 1. 课题综述 (1) 1.1课题的来源及意义 (1) 1.2面对的问题 (1) 2. 需求分析 (1) 2.1涉及到的知识 (2) 2.2软硬件的需求 (2) 2.3功能需求 (2) 3. 概要设计 (2) 4. 详细设计和实现 (3) 4.1算法描述及详细流程图 (3) 4.1.1算法描述 (3) 4.1.2算法流程图 (3) 5. 代码编写及详细注释 (4) 6. 程序调试 (8) 6.1调试过程、步骤及遇到的问题 (8) 7. 运行与测试 (8) 7.1运行演示 (8) 总结 (10) 致 (11)

参考文献 (12) .

1. 课题综述 1. 1课题的来源及意义 八皇后问题是一个古老而著名的问题,该问题是十九世纪著名的数学家高斯1850年提出的。 在国际象棋中,皇后是最有权利的一个棋子;只要别的棋子在它的同一行或同一列或同一斜线(正斜线或反斜线)上时,它就能把对方棋子吃掉。所以高斯提出了一个问题:在8*8的格的国际象棋上摆放八个皇后,使其不能相互攻击,即任意两个皇后都不能处于同一列、同一行、或同一条斜线上面,问共有多少种解法。 到了现代,随着计算机技术的飞速发展,这一古老而有趣的数学游戏问题也自然而然的被搬到了计算机上。运用所学计算机知识来试着解决这个问题是个锻炼和提高我自己编程能力和独立解决问题能力的好机会,可以使我增强信心,为我以后的编程开个好头,故我选择了这个有趣的课题。 1. 2 面对的问题 1)解决冲突问题: 这个问题包括了行,列,两条对角线; 列:规定每一列放一个皇后,不会造成列上的冲突; 行:当第I行被某个皇后占领后,则同一行上的所有空格都不能再放皇后,要把以I为下标的标记置为被占领状态; 2)使用数据结构的知识,用递归法解决问题。 2. 需求分析

回溯算法与八皇后问题N皇后问题Word版

回溯算法与八皇后问题(N皇后问题) 1 问题描述 八皇后问题是数据结构与算法这一门课中经典的一个问题。下面再来看一下这个问题的描述。八皇后问题说的是在8*8国际象棋棋盘上,要求在每一行放置一个皇后,且能做到在竖方向,斜方向都没有冲突。更通用的描述就是有没有可能在一张N*N的棋盘上安全地放N个皇后? 2 回溯算法 回溯算法也叫试探法,它是一种系统地搜索问题的解的方法。回溯算法的基本思想是:从一条路往前走,能进则进,不能进则退回来,换一条路再试。 在现实中,有很多问题往往需要我们把其所有可能穷举出来,然后从中找出满足某种要求的可能或最优的情况,从而得到整个问题的解。回溯算法就是解决这种问题的“通用算法”,有“万能算法”之称。N皇后问题在N增大时就是这样一个解空间很大的问题,所以比较适合用这种方法求解。这也是N皇后问题的传统解法,很经典。 下面是算法的高级伪码描述,这里用一个N*N的矩阵来存储棋盘: 1) 算法开始, 清空棋盘,当前行设为第一行,当前列设为第一列 2) 在当前行,当前列的位置上判断是否满足条件(即保证经过这一点的行,列与斜线上都没 有两个皇后),若不满足,跳到第4步 3) 在当前位置上满足条件的情形: 在当前位置放一个皇后,若当前行是最后一行,记录一个解; 若当前行不是最后一行,当前行设为下一行, 当前列设为当前行的第一个待测位置;

若当前行是最后一行,当前列不是最后一列,当前列设为下一列; 若当前行是最后一行,当前列是最后一列,回溯,即清空当前行及以下各行的棋盘,然后,当前行设为上一行,当前列设为当前行的下一个待测位置; 以上返回到第2步 4) 在当前位置上不满足条件的情形: 若当前列不是最后一列,当前列设为下一列,返回到第2步; 若当前列是最后一列了,回溯,即,若当前行已经是第一行了,算法退出,否则,清空当前行及以下各行的棋盘,然后,当前行设为上一行,当前列设为当前行的下一个待测位置,返回到第2步; 算法的基本原理是上面这个样子,但不同的是用的数据结构不同,检查某个位置是否满足条件的方法也不同。为了提高效率,有各种优化策略,如多线程,多分配内存表示棋盘等。 为了便于将上述算法编程实现,将它用另一种形式重写: Queen() Loop: if check_pos(curr_row, curr_col) == 1 then put_a_queen(curr_row, curr_col); if curr_row == N then record_a_solution(); end if; if curr_row != N then curr_row = curr_row + 1; curr_col = 1; else if curr_col != N then curr_col = curr_col + 1; else backtrack(); end if; end if; else if curr_col != N then

n皇后问题算法实验报告

算法分析与设计实验报告 实验内容:N皇后问题 实验时间:2013.12.3 姓名:杜茂鹏 班级:计科1101 学号:0909101605

一、实验内容及要求 在n×n格的棋盘上放置彼此不受攻击的n个皇后,按照国际象棋的规则,皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。 二、实验目的 1.巩固和加深对回溯法的理解 2.了解递归和迭代法在回溯法中的应用 三、算法分析 1.理解皇后不被攻击的条件:n后问题等价于在n*n格的棋盘上放置n个皇后,任何两个皇后不能放在同一行或同一列或同一斜线上。 2.算法模块简要分析 用数组存储皇后的位置,将i设置为0. Int place(*x,n) :数组x[] 用来表示列数,n为皇后个数,用来判断皇后是否被攻击,判断的条件是(x[i]-x[n]==i-n||x[i]-x[n]==n-i||x[i]==x[n])即用来判断“同一行或同一列或同一斜线上”。 Int print(*x,n):打印皇后解的空间。 Int iniprint(*x,n):初始化打印函数,相当于对棋盘初始化。将可以放皇后的位置记为“1”,不放皇后的位置记为“0”。 Int Nqueen(int n):n皇后问题求解,如果满足一组可行解,sum++。Int i=0,如果x[i]>=n的时候即进行下一行,i++;当i=n时,

sum++;输出该组可行解的个数和位置的矩阵。并且i--,回溯到上一层继续搜索可行解。 四、运行结果及分析 1、三皇后没有可行解 2、 2.4个皇后有2个可行解 3.5皇后有10个可行解 五、源代码 #include static int n, sum=0;//可行解个数 static int locate[20]; int place(int k) {//判断是否在一条线上并返回0,1 for(int i=1;in){

回溯法解八皇后问题

回溯法解八皇后问题 在N * N 格的棋盘上放置彼此不受攻击的N 个皇后。N个皇后问题等价于在N * N 格的棋盘上放置N 个皇后,任何2个皇后不在同一行或同一列或同一斜线上。当N等于8,就是著名的八皇后问题。 此问题是通过C语言程序编写的,在Turboc环境下完成实现的。输出结果见(输出结果。TXT文件) 详细代码为: /*///////////////////////////////////////////////////////////////////// /// /////The programming is a complex problem about the ways of queens./////// /////Programmer: Luo Xiaochun /////// /////Completed date: 2007.12 //////// /////V ersion number: Turboc 2.0 //////// /////////////////////////////////////////////////////////////////////// /*/ #include #include #define false 0 #define true 1 #define quesize 8 int gx[quesize+1]; int sum=0; int place( int k ); void print( int a[] ); void nqueens( int n ); FILE *fp; int main( ) { system("cls"); fp = fopen("outfile.txt", "w");

8皇后问题matlab算法

M文件 function PlaceQueen(row,matrix,N)%回溯法放置皇后 if row>N PrintQueen(N,matrix);%打印棋盘 else for col=1:N matrix(row,col)=1; if row==1||Conflict(row,col,N,matrix)%检测是否冲突 PlaceQueen(row+1,matrix,N); end matrix(row,col)=0; end end %子函数:检测冲突 function result=Conflict(row,col,N,matrix)%检测是否冲突 result=1; for i=1:row-1 for j=1:N if matrix(i,j)==1 if ((j==col)||(abs(row-i)==abs(col-j)))%是否产生冲突:在同一直线,斜线上 result=0; break; end end end if result==0 break; end end %子函数:打印棋盘信息

function PrintQueen(N,matrix) global solutionNum; %定义全局变量,来累积方法数 solutionNum=solutionNum+1; disp(['第',num2str(solutionNum),'种方法:']) disp(matrix) 脚本文件 clear all clc global solutionNum; solutionNum=0;%全局变量记录方法数 N=8;%皇后个数 matrix=zeros(N);%存储皇后位置信息 PlaceQueen(1,matrix,N)%调用放置方法

八皇后问题讲解

计算机科学与技术专业 数据结构课程设计报告设计题目:八皇后问题

目录 1需求分析 (3) 1.1功能分析 (3) 1.2设计平台 (4) 2概要设计 (4) 2.1算法描述 (5) 2.2算法思想 (6) 2.3数据类型的定义 (6) 3详细设计和实现 (7) 3.1算法流程图 (7) 3.2 主程序 (7) 3.3 回溯算法程序 (8) 4调试与操作说明 (10) 4.1调试情况 (10) 4.2操作说明 (10) 5设计总结 (12) 参考文献 (13) 附录 (13)

1需求分析 1.1功能分析 八皇后问题是一个古老而著名的问题,该问题是十九世纪著名的数学家高斯1850年提出的,并作了部分解答。高斯在棋盘上放下了八个互不攻击的皇后,他还认为可能有76种不同的放法,这就是有名的“八皇后”问题。 在国际象棋中,皇后是最有权利的一个棋子;只要别的棋子在它的同一行或同一列或同一斜线(正斜线或反斜线)上时,它就能把对方棋子吃掉。所以高斯提出了一个问题:在8*8的格的国际象棋上摆放八个皇后,使其不能相互攻击,即任意两个皇后都不能处于同一列、同一行、或同一条斜线上面,问共有多少种解法。现在我们已经知道八皇后问题有92个解答。 1、本演示程序中,利用选择进行。程序运行后,首先要求用户选择模式,然后进入模式。皇后个数设0

八皇后问题(回溯法)

八皇后问题(回溯法)2009-08-11 12:03问题描述: 求出在一个n×n的棋盘上,放置n个不能互相捕捉的国际象棋“皇后”的所有布局,这是来源于国际象棋的一个问题。皇后可以沿着纵横和两条斜线4个方向互相捕捉。 解题思路: 总体思想为回溯法。 求解过程从空配置开始。在第1列~的m列为合理配置的基础上,再配置第m+1列,直至第n列也是合理时,就找到了一个解。在每列上,顺次从第一行到第n行配置,当第n行也找不到一个合理的配置时,就要回溯,去改变前一列的配置。 为使在检查皇后配置的合理性方面简易方便,引入一下4个工作数组: ?数组col[i],表示在棋盘第i列,col[i]行有一个皇后; ?数组a[],a[k]表示第k行上还没有皇后; ?数组b[],b[k]表示第k列右高左低斜线上没有皇后; ?数组c[],c[k]表示第k列左高右低斜线上没有皇后; 代码: #include #include void queen(int N) { //初始化N+1个元素,第一个元素不使用int col[N+1]; //col[m]=n表示第m列,第n行放置皇后 int a[N+1]; //a[k]=1表示第k行没有皇后 int b[2*N+1]; //b[k]=1表示第k条主对角线上没有皇后 int c[2*N+1]; //c[k]=1表示第k条次对角线上没有皇后 int j,m=1,good=1;char awn; for(j=0;j<=N;j++) {a[j]=1;} for(j=0;j<=2*N;j++) {b[j]=c[j]=1;} col[1]=1;col[0]=0; do { if(good) { if(m==N) //已经找到一个解

回溯法 八皇后

回溯法(8皇后问题) 1.1算法原理 回溯算法实际是一个类似枚举的搜索尝试方法,其基本思想是在搜索尝试中找问题的解,采用了一种“走不通就掉头”的思想,作为其控制结构。 从一条路往前走,能进则进,不能进则退回来,换一条路再试。八皇后问题就是回溯算法的典型,第一步按照顺序放一个皇后,然后第二步符合要求放第2个皇后,如果没有符合条件的位置符合要求,那么就要改变第一个皇后的位置,重新放第2个皇后的位置,直到找到符合条件的位置就可以了。回溯在迷宫搜索中使用很常见,就是这条路走不通,然后返回前一个路口,继续下一条路。回溯算法说白了就是穷举法。不过回溯算法使用剪枝函数,剪去一些不可能到达最终状态(即答案状态)的节点,从而减少状态空间树节点的生成。回溯法是一个既带有系统性又带有跳跃性的的搜索算法。它在包含问题的所有解的解空间树中,按照深度优先的策略,从根结点出发搜索解空间树。算法搜索至解空间树的任一结点时,总是先判断该结点是否肯定不包含问题的解。如果肯定不包含,则跳过对以该结点为根的子树的系统搜索,逐层向其祖先结点回溯。否则,进入该子树,继续按深度优先的策略进行搜索。回溯法在用来求问题的所有解时,要回溯到根,且根结点的所有子树都已被搜索遍才结束。而回溯法在用来求问题的任一解时,只要搜索到问题的一个解就可以结束。 用回溯法搜索解空间树时,通常采用两种策略来避免无效搜索,提高回溯法的搜索效率。其一是用约束函数在扩展结点处剪去不满足约束的子树;其二是用限界函数剪去不能得到最优 解的子树。 1.2算法适用性 它适用于解一些组合数较大的问题,有条件限制的枚举,即优化的枚举. 1.3算法描述 8皇后回溯算法 1.设Column[8]数组依次存储第一行到第八行的列位置,QUEEN_NUM=8,皇后个数 2.从第一行第一列开始放置,开始放置下一行的皇后(当且仅当前行的皇后位置正确时) 3.判断放置位置是否合理:Column[i]==Column[n],判断是否在同一列, abs(Column[i]-Column[n])==(n-i)),判断时候在斜线上。如果不在用一列,同一斜线上,则位置合理,进行下一行皇后放置,否则回溯 4.当最后一行皇后放置正确时,一种放置方法结束,进行下一种方法,查找。

第五组回溯算法(N皇后排列方法问题)

实训一 N皇后排列方法问题的回溯算法与实现 一、设计目的 1)掌握N皇后排列方法问题的回溯算法; 2)进一步掌握回溯算法的基本思想和算法设计方法; 二、设计内容 1.任务描述 1)算法简介 回溯法(探索与回溯法)是一种选优搜索法,按选优条件向前搜索,以达到目标。但当探索到某一步时,发现原先选择并不优或达不到目标,就退回一步重新选择,这种走不通就退回再 走的技术为回溯法,而满足回溯条件的某个状态的点称为“回溯点”。 2)N皇后排列方法问题简介 在N*N格的棋盘上放置彼此不受攻击的N个皇后.按照国际象棋的规则,皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子.N后问题等价于在N*N格的棋盘上放置N个皇后,任何2个皇后不放在同一行或同一列或同一斜线上. 3)设计任务简介 对于回溯类似的问题。首先,要能理解该问题运用到的回溯的概念;其次,根据回溯相关的基本思想,找出相应的数学公式;最后,进行程序的设计和编写。 利用回溯的基本思想和计算步骤,有助于我们解决生活中遇到的各种数学问题。 4)问题分析 由于这是一个平面上棋子布局处理问题,因此,我们可以将问题看成是一个二维数组问题。给八个皇后分别编号为1,2,…,8,其中第i个皇后放置在第i行上,并这就解决了不同皇后分别摆放在 不同列的问题,这样又可以把问题简化为一个一维数组的问题,假设用一维数组x[i]来存放皇后所放 置的列,对于第i个皇后,假设它存放在x[i]列上,则对应的x数组应满足如下的条件:[2] 1)因为一共只有8列,故x[i]的取值只能取1到8之间的数。 2)因为不同的皇后只能粗放在不同的列上,则对于任意的i和j,应满足如果i!=j,则x[i]!=x[j] 3)因为不同的皇后不能存放在同一对角线上,故连接两个皇后的直线的斜率应不能等于正负1,而 连接任意第i个皇后和第j个皇后(i与j不同)的直线的斜率的计算公式为:(x[i]-x[j])/(i-j), 即(x[i]-x[j])/(i-j)!=±1,即:|x[i]-x[j]|!=| i-j | N皇后排列方法问题的表示方案

回溯算法的一些例题

回溯算法 搜索与回溯是计算机解题中常用的算法,很多问题无法根据某种确定的计算法则来求解,可以利用搜索与回溯的技术求解。回溯是搜索算法中的一种控制策略。它的基本思想是:为了求得问题的解,先选择某一种可能情况向前探索,在探索过程中,一旦发现原来的选择是错误的,就退回一步重新选择,继续向前探索,如此反复进行,直至得到解或证明无解。如迷宫问题:进入迷宫后,先随意选择一个前进方向,一步步向前试探前进,如果碰到死胡同,说明前进方向已无路可走,这时,首先看其它方向是否还有路可走,如果有路可走,则沿该方向再向前试探;如果已无路可走,则返回一步,再看其它方向是否还有路可走;如果有路可走,则沿该方向再向前试探。按此原则不断搜索回溯再搜索,直到找到新的出路或从原路返回入口处无解为止。 递归回溯法算法框架[一] procedure Try(k:integer); begin for i:=1 to 算符种数 Do if 满足条件 then begin 保存结果 if 到目的地 then 输出解 else Try(k+1); 恢复:保存结果之前的状态{回溯一步} end; end; 递归回溯法算法框架[二] procedure Try(k:integer); begin if 到目的地 then 输出解 else for i:=1 to 算符种数 Do if 满足条件 then begin 保存结果 Try(k+1); end; end;

例 1:素数环:把从1到20这20个数摆成一个环,要求相邻的两个数的和是一个素数。【算法分析】非常明显,这是一道回溯的题目。从1 开始,每个空位有 20(19)种可能,只要填进去的数合法:与前面的数不相同;与左边相邻的数的和是一个素数。第 20个数还要判断和第1个数的和是否素数。 〖算法流程〗1、数据初始化; 2、递归填数: 判断第J种可能是否合法; A、如果合法:填数;判断是否到达目标(20个已填完):是,打印结果;不是,递归填下一个; B、如果不合法:选择下一种可能; 【参考程序】 program z74;框架[一] var a:array[0..20]of byte; b:array[0..20]of boolean; total:integer; function pd(x,y:byte):boolean; var k,i:byte; begin k:=2; i:=x+y; pd:=false; while (k<=trunc(sqrt(i)))and(i mod k<>0) do inc(k); if k>trunc(sqrt(i)) then pd:=true; end; procedure print; var j:byte; begin inc(total);write('<',total,'>:'); for j:=1 to 20 do write(a[j],' '); writeln; end; procedure try(t:byte); var i:byte; begin for i:=1 to 20 do if pd(a[t-1],i)and b[i] then begin a[t]:=i; b[i]:=false; if t=20 then begin if pd(a[20],a[1]) then print;end

八皇后问题 C语言程序设计

八皇后问题学 2012年 9 月 5 日 目录 一、选题 1.1背景知识 (2) 1.2设计目的与要求 (2) 二、算法设计 2.1问题分析 (3) 2.2算法设计 (3) 三、详细设计 3.1源程序清单 (4) 四、调试结果及分析 4.1调试结果 (6) 4.2调试分析 (7) 五、课程设计总结 5.1总结及体会 (7) 六、答辩 6.1答辩记录 (8) 6.2教师意见 (8) 一、选题及背景知识 1.1 背景知识

在国际象棋中,皇后是一个威力很大的棋子,她可以“横冲直撞”(在正负或垂直方向走任意步数),也可以“斜刺冲杀”(在正负45度方向走任意步数),所以在8*8的棋盘上要布互相不受攻击的皇后,最多只能布八个,共92种布法,再也不能有别的布法了——这就是著名的八皇后问题 在8*8的国际象棋棋盘上,放置八个皇后,使得这八个棋子不能互相被对方吃掉。也就是说一个皇后可以攻击与之处在同一行或同一列或同一斜线上的其他任何棋子.因此,八皇后问题等于要求八个皇后中的任意两个不能被放在同一行或同一列或同一斜线上。 1.2 设计要求 要求:·判断在国际象棋中,能否在空棋盘上摆放8个皇后,并使其中任意两个皇后不能在同一行,同一列或同一对角线上。 ·编写完整的摆放八皇后问题的程序 ·具体要求第一个皇后的起始位置由键盘输入 二、算法设计 2.1问题分析 设计——图形表示下图中,Q代表皇后 假设在第k列上找到合适的位置放置一个皇后,要求它与第1——k-1列上的皇后不同行、列、对角线;可以从图上找到规律:不同列时成立,皇后放在第k列上;讨论行时,第j个皇后的位置(a[j] ,j)要与(i,k)位置的皇后不同行;如果同在/斜线上,行列值之和相同;如果同在\斜线上,行列值之差相同;如果斜线不分方向则同一斜线上两皇后的行号之差的绝对值与列号之差的绝对值相同,可表示为(|a[j]-i|=|j-k|)。 2.2 算法设计 利用计算机运行速度快的特点,采用枚举法,逐一尝试各种摆放方式,来判断最终摆法。其中判断是否同在对角线上用到了:行数差的绝对值与列数差的绝对值相等,

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

课程设计报告 课程名称数据结构课程设计 课题名称八皇后问题演示 专业通信工程 班级通信工程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.程序由哪些模块组成以及模块之间的层次结构、各模块的调用关系;每个模块 的功能。

八皇后问题的解决完整

八皇后问题的解决完整 Standardization of sany group #QS8QHH-HHGX8Q8-GNHHJ8-HHMHGN#

淮阴工学院 数据结构课程设计报告 设计题目:八皇后 2008 年 6 月 25 日 设计任务书

摘要: 八皇后问题要求在一个8*8的棋盘上放上8个皇后,使得每一个皇后既攻击不到另外七个皇后,也不被另外七个皇后所攻击.按照国际象棋的规则,一个皇后可以攻击与之处在同一行或同一列或同一斜线上的其他任何棋子.因此,八皇后问题等于要求八个皇后中的任意两个不能被放在同一行或同一列或同一斜线上。 而本课程设计本人的目的也是通过用c++语言平台将一个8*8的棋盘上放上8个皇后,使得每一个皇后既攻击不到另外七个皇后,也不被另外七个皇后所攻击的92种结构予以实现.使用递归方法最终将其问题变得一目了然,更加易懂。 关键词:八皇后 ; c++ ; 递归法 目录 .

1. 课题综述 1. 1课题的来源及意义 八皇后问题是一个古老而着名的问题,该问题是十九世纪着名的数学家高斯1850年提出的。 在国际象棋中,皇后是最有权利的一个棋子;只要别的棋子在它的同一行或同一列或同一斜线(正斜线或反斜线)上时,它就能把对方棋子吃掉。 所以高斯提出了一个问题:在8*8的格的国际象棋上摆放八个皇后,使其不能相互攻击,即任意两个皇后都不能处于同一列、同一行、或同一条斜线上面,问共有多少种解法。 到了现代,随着计算机技术的飞速发展,这一古老而有趣的数学游戏问题也自然而然的被搬到了计算机上。运用所学计算机知识来试着解决这个问题是个锻炼和提高我自己编程能力和独立解决问题能力的好机会,可以使我增强信心,为我以后的编程开个好头,故我选择了这个有趣的课题。 1. 2 面对的问题 1)解决冲突问题: 这个问题包括了行,列,两条对角线; 列:规定每一列放一个皇后,不会造成列上的冲突; 行:当第I行被某个皇后占领后,则同一行上的所有空格都不能再放皇后,要把以I为下标的标记置为被占领状态;

八皇后问题的解决完整文档

淮阴工学院 数据结构课程设计报告 设计题目:八皇后 系(院):计算机工程系 专业:信息安全 班级:信息 1 0 6 学生姓名: 叶青学号:1061303127 指导教师:张亚红寇海洲胡荣林夏森 学年学期: 2007 ~ 2008 学年第 2 学期 2008 年 6 月25 日

设计任务书

摘要: 八皇后问题要求在一个8*8的棋盘上放上8个皇后,使得每一个皇后既攻击不到另外七个皇后,也不被另外七个皇后所攻击.按照国际象棋的规则,一个皇后可以攻击与之处在同一行或同一列或同一斜线上的其他任何棋子.因此,八皇后问题等于要求八个皇后中的任意两个不能被放在同一行或同一列或同一斜线上。 而本课程设计本人的目的也是通过用c++语言平台将一个8*8的棋盘上放上8个皇后,使得每一个皇后既攻击不到另外七个皇后,也不被另外七个皇后所攻击的92种结构予以实现.使用递归方法最终将其问题变得一目了然,更加易懂。 关键词:八皇后; c++; 递归法

目录 1. 课题综述 (1) 1.1课题的来源及意义 (1) 1.2面对的问题 (1) 2. 需求分析 (1) 2.1涉及到的知识 (1) 2.2软硬件的需求 (1) 2.3功能需求 (2) 3. 概要设计 (2) 4. 详细设计和实现 (2) 4.1算法描述及详细流程图 (2) 4.1.1算法描述 (3) 4.1.2算法流程图 (3) 5. 代码编写及详细注释 (4) 6. 程序调试 (7) 6.1调试过程、步骤及遇到的问题 (7) 7. 运行与测试 (7) 7.1运行演示 (7) 总结 (9) 致谢 (10) 参考文献 (11) .

回溯法实验(n皇后问题)(迭代法)

算法分析与设计实验报告第三次附加实验

附录: 完整代码(回溯法) //回溯算法递归回溯n皇后问题#include #include #include #include"math.h" using namespace std; class Queen

{ friend int nQueen(int); //定义友元函数,可以访问私有数据 private: bool Place(int k); //判断该位置是否可用的函数 void Backtrack(int t); //定义回溯函数 int n; //皇后个数 int *x; //当前解 long sum; //当前已找到的可行方案数 }; int main() { int m,n; for(int i=1;i<=1;i++) { cout<<"请输入皇后的个数:"; //输入皇后个数 cin>>n; cout<<"皇后问题的解为:"<

相关文档
最新文档