实验报告
一、实验名称：回溯法求解N皇后问题（Java实现）
二、学习知识：
回溯法：也称为试探法，它并不考虑问题规模的大小，而是从问题的最明显的最小规模开始逐步求解出可能的答案，并以此慢慢地扩大问题规模，迭代地逼近最终问题的解。这种迭代类似于穷举并且是试探性的，因为当目前的可能答案被测试出不可能可以获得最终解时，则撤销当前的这一步求解过程，回溯到上一步寻找其他求解路径。
为了能够撤销当前的求解过程，必须保存上一步以来的求解路径，这一点相当重要。
三、问题描述
N皇后问题：在一个 N * N 的国际象棋棋盘中，怎样放置 N 个皇后才能使 N 个皇后之间不会互相有威胁而共同存在于棋局中，即在 N * N 个格子的棋盘中没有任何两个皇后是在同一行、同一列、同一斜线上。
深度优先遍历的典型案例。
四、求解思路
1、求解思路：最容易想到的方法就是有序地从第 1 列的第 1 行开始，尝试放上一个皇后，然后再尝试第 2 列的第几行能够放上一个皇后，如果第 2 列也放置成功，那么就继续放置第 3 列，如果此时第 3 列没有一行可以放置一个皇后，说明目前为止的尝试是无效的（即不可能得到最终解），那么此时就应该回溯到上一步（即第 2 步），将上一步（第 2 步）所放置的皇后的位置再重新取走放在另一个符合要求的地方…如此尝试性地遍历加上回溯，就可以慢慢地逼近最终解了。
2、需要解决的问题：如何表示一个 N * N 方格棋盘能够更有效？怎样测试当前所走的试探路径是否符合要求？这两个问题都需要考虑到使用怎样的数据结构，使用恰当的数据结构有利于简化编程求解问题的难度。
3、我们使用以下的数据结构：
int column[col] = row 表示第 col 列的第 row 行放置一个皇后
boolean rowExists[i] = true 表示第 i 行有皇后
boolean a[i] = true 表示右高左低的第 i 条斜线有皇后（按→↓顺序从1~ 2*N -1 依次编号）
boolean b[i] = true 表示左高右低的第 i 条斜线有皇后（按→↑顺序从1~ 2*N -1 依次编号）
五、算法实现
对应这个数据结构的算法实现如下：
1.**
2. * 回溯法求解 N 皇后问题
3. * @author haolloyin
4. */
5.public class N_Queens {
6.
7.// 皇后的个数
8. private int queensNum = 4;
9.
10.// column[i] = j表示第 i 列的第 j 行放置一个皇后
11. private int[] queens = new int[queensNum + 1];
12.
13.// rowExists[i] = true 表示第 i 行有皇后
14. private boolean[] rowExists = new boolean[queen
sNum + 1];
15.
16.// a[i] = true 表示右高左低的第 i 条斜线有皇后
17. private boolean[] a = new boolean[queensNum * 2
];
18.
19.// b[i] = true 表示左高右低的第 i 条斜线有皇后
20. private boolean[] b = new boolean[queensNum * 2
];
21.
22.// 初始化变量
23. private void init() {
24. for (int i = 0; i < queensNum + 1; i++) {
25. rowExists[i] = false;
26. }
27.
28. for(int i = 0; i < queensNum * 2; i++) {
29. a[i] = b[i] = false;
30. }
31. }
32.
33.// 判断该位置是否已经存在一个皇后,存在则返回 true
34. private boolean isExists(int row, int col) {
35. return (rowExists[row] || a[row + col - 1]
|| b[queensNum + col - row]);
36. }
37.
38.// 主方法：测试放置皇后
39. public void testing(int column) {
40.
41.// 遍历每一行
42. for (int row = 1; row < queensNum + 1; row+
+) {
43.// 如果第 row 行第 column 列可以放置皇后
44. if (!isExists(row, column)) {
45.// 设置第 row 行第 column 列有皇后
46. queens[column] = row;
47.// 设置以第 row 行第 column 列为交叉点
的斜线不可放置皇后
48. rowExists[row] = a[row + column - 1
] = b[queensNum + column - row] = true;
49.
50.// 全部尝试过，打印
51. if(column == queensNum) {
52. for(int col = 1; col <= queensN
um; col++) {
53. System.out.print("("+col +
"," + queens[col] + ") ");
54. }
55. System.out.println();
56. }else {
57.// 放置下一列的皇后
58. testing(column + 1);
59. }
60.// 撤销上一步所放置的皇后，即回溯
61. rowExists[row] = a[row + column - 1
] = b[queensNum + column - row] = false;
62. }
63. }
64. }
65.
66.//测试
67. public static void main(String[] args) {
68. N_Queens queen = new N_Queens();
69. queen.init();
70.// 从第 1 列开始求解
71. queen.testing(1);
72. }
73.}
六、运行结果
当N = 8 时，求解结果如下（注：横坐标为列数，纵坐标为行数）：
(1,1) (2,5) (3,8) (4,6) (5,3) (6,7) (7,2) (8,4)
1.(1,1) (2,6) (3,8) (4,3) (5,7) (6,4) (7,2) (8,5)
2.(1,1) (2,7) (3,4) (4,6) (5,8) (6,2) (7,5) (8,3)
3.... ...
4.... ...
5.(1,8) (2,2) (3,4) (4,1) (5,7) (6,5) (7,3) (8,6)
6.(1,8) (2,2) (3,5) (4,3) (5,1) (6,7) (7,4) (8,6)
7.(1,8) (2,3) (3,1) (4,6) (5,2) (6,5) (7,7) (8,4)
8.(1,8) (2,4) (3,1) (4,3) (5,6) (6,2) (7,7) (8,5) 当N = 4 时，求解结果如下：
1.(1,2) (2,4) (3,1) (4,3)
2.(1,3) (2,1) (3,4) (4,2)
七、实验小结：
1、根据问题选择恰当的数据结构非常重要，就像上面 a 、b 标志数组来表示每一条斜线的编号顺序以及方向都相当重要。看书的时候也是费了些时间来理解的，呼…另外，queens [col] = row 数组只是用了一维而不是二维来表示纵横交错的方格棋盘上特定位置是否有皇后也是比较经济而有意思的。
2、正确运用、组织所确定的数据结构到算法的实现逻辑中也是很重要的，就像代码中的 isExists(int row, int col) 方法内的 (rowExists[row] || a[row + col - 1] || b[queensNum + col - row]) 就是很明确的理解了尝试放置皇后的位置的 x ，y 坐标与斜线之间的数值关系，才使得算法得以正确执行。当然，对于斜线的编号、顺序也是相当重要的。
一．实验目的 1. 了解皇后相互攻击的条件：如果任意两个皇后在同一行，同一列或同一对角线，则她们相互攻击。 2. 运用迭代的方法实现n皇后问题，求解得到皇后不相互攻击的一个解 二．实验内容 基本思路：用n元组x[1:n]表示n后问题的解，其中x[i]表示第i个皇后放在棋盘的第i行的第x[i]列。抽象约束条件得到能放置一个皇后的约束条件：(1)x[i]!=x[k]; (2)abs(x[i]-x[k])!=abs(i-k)。应用回溯法，当可以放置皇后时就继续到下一行，不行的话就返回到第一行，重新检验要放的列数，如此反复，直到将所有解解出。在回溯法中，递归函数Backtrack(1)实现对整个解空间的回溯搜索。Backtrack(i)搜索解空间的第i层子树。类Queen的数据成员记录解空间的节点信息，以减少传给Backtrack函数的参数。sum记录当前已找到的可行方案数。 运用回溯法解题通常包含以下三个步骤： （1）针对所给问题，定义问题的解空间； （2）确定易于搜索的解空间结构； （3）以深度优先的方式搜索解空间，并且在搜索过程中用剪枝函数避免无效搜索。 源代码： #include //回溯法之N皇后问题当N>10，就有点抽了~~ /*结果前total行每行均为一种放法，表示第i行摆放皇后的列位置，第total+1行，输出total*/ #include 深圳大学实验报告 课程名称：算法分析与复杂性理论 实验项目名称：八皇后问题 学院：计算机与软件学院 专业：软件工程 指导教师：杨烜 报告人：学号：班级：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 i 算法分析与设计实验报告 实验内容：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 算法分析与设计实验报告第六次实验 附录： 完整代码（回溯法） //回溯算法递归回溯n皇后问题#include { 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<<"皇后问题的解为："< 1．实验要求 【实验目的】 1、进一步掌握指针、模板类、异常处理的使用 2、掌握栈的操作的实现方法 3、掌握队列的操作的实现方法 4、学习使用栈解决实际问题的能力 5、学习使用队列解决实际问题的能力 【实验内容】 利用栈结构实现八皇后问题。 八皇后问题19世纪著名的数学家高斯于1850年提出的。他的问题是：在8*8的棋盘上放置8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列、同一斜线上。请设计算法打印所有可能的摆放方法。 提示： 1、可以使用递归或非递归两种方法实现 2、实现一个关键算法：判断任意两个皇后是否在同一行、同一列和同一斜线上2. 程序分析 2.1 存储结构 存储结构：栈（递归） 2.2 关键算法分析 【设计思想】 由于八皇后问题，可以分解成算法相同的子问题，所以使用递归的方法 【伪代码】 1、输入皇后个数n 2、k=1 3、判断k是否大于n 3.1 是：打印一组可能 3.2 否：循环行位置1~n 判断该位置是否符合要求，若符合记录q[k]的坐标y值 k+1 重复3 【关键算法】 1、递归 void Queen::Queens(int k,int n) { int i; if(k>n) { Print(n); count(); } else { for(i=1;i<=n;i++) if(Isavailable(i,k)) //判断该行中该位置放置‘皇后’是否符合要求 { q[k]=i; //记录改行中该点的位置 Queens(k+1,n); //放置下一行的‘皇后’ } } } 2、判断皇后放置位置是否符合要求 bool Queen::Isavailable(int i,int k) { int j; j=1; while(j 实训一 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皇后排列方法问题的表示方案 N后问题算法 一、实验目的及要求 所要涉及或掌握的知识： 1. 了解皇后相互攻击的条件：如果任意两个皇后在同一行，同一列或同一对角线，则她们相互攻击。 2. 运用迭代的方法实现6皇后问题，求解得到皇后不相互攻击的一个解 3. 在运用迭代的方法实现编程时，要注意回溯点 二、问题描述及实验内容 对6皇后问题求解，用数组c[1…6]来存皇后的位置。c[i]=j表示第i个皇后放在第j列。 最后程序运行的结果是c[1…6]={1,5,8,6,3,7 } 三、问题分析和算法描述 6-QUEENS的算法表示： 输入：空。 输出：对应于6皇后问题的解的向量c[1…6]={1,5,8,6,3,7} 1. for k=1 to 6 2. c[k]=0 //没有放皇后 3. end for 4. flag=false 5. k=1 6. while k>=1 7.while c[k]<=5 8.c[k]=c[k]+1 9.if c为合法着色 then set flag=ture 且从两个while循环退出 10.else if c是部分解 then k=k+1 11.end while 12. c[k]=0 //回溯并c[k]=0 13. k=k-1 14. end while 15. if flag then output c 16. else output “no solution” 四、具体实现 # include 回溯法解八皇后问题 在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 回溯算法与八皇后问题(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 实验项目： 八皇后问题 1.实验目的： 通过求解皇后问题，熟悉深度优先搜索法DFS（回溯法（Backtracking Algorithms）技术。 2.实验内容： 由n2 个方块排成n行n列的正方形称为n元棋盘。如果两个皇后位于n元棋盘上的同一行、同一列或同一对角线上，则称它们在互相攻击。现要找出使棋盘上n个皇后互不攻击的布局。编制程序解决上述问题，以n=6运行程序，输出结果。 3.程序简介： 将n个皇后放到一个n*n的方阵中，要求每个皇后不在同一行同一列及同一对角线，我的程序是先把每个皇后放在了第零列，然后再按行检查，不符合要求继续下一列，若已经到这一行的最后一列，还没找到符合要求的位置，则回到上一行。 4.算法设计介绍： 定义一个一维数组，数组的下标是皇后所在位置的行数，数组存的值是皇后所在位置的列数，现将A[0]-A[n-1]都赋成零，然后随着检查的进行，皇后的位置也在不断地变化，最后找到一个符合要求的方阵时，本质上就是一个存放整数的一维数组，数组的下标是行数，存放的值是列数。 5.困难及解答 我很久以前就听说过八皇后问题，没想到现在轮到自己编了，一开始还真是特别糊涂呢，后来老师上课把算法大概讲了一遍，就清楚很多了，要说问题，就是一开始纠结怎么存放皇后，我开始想用二维数组着，后来老师说用一 维数组比较好做，我看了一下老师的算法，就明白了大概，经过一段时间就编出来了 5.心得 我编程变得还是很少，天天下决心说以后多编，也没践行，心想着吧，不挂在嘴上了，努力！ 6.程序清单 /* //我真诚地保证： //我独立完成了整个程序从分析、设计到编码的所有工作。 //如果在上述过程中，我遇到了什么困难而求教于人，那么，我将在程序实习报告中 //详细地列举我所遇到的问题，以及别人给我的提示。 //我的程序里中凡是引用到其他程序或文档之处， //例如教材、课堂笔记、网上的源代码以及其他参考书上的代码段, //我都已经在程序的注释里很清楚地注明了引用的出处。 //我从未没抄袭过别人的程序，也没有盗用别人的程序，//不管是修改式的抄袭还是原封不动的抄袭。//我编写这个程序，从来没有想过要去破坏或妨碍其他计算机系统的正常运转 文件名称： 创建者： 创建时间： 2011.4.14 算法分析与设计实验报告第三次附加实验 附录： 完整代码（回溯法） //回溯算法递归回溯n皇后问题#include { 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<<"皇后问题的解为："< 实验报告 一、实验名称：回溯法求解N皇后问题（Java实现） 二、学习知识： 回溯法：也称为试探法，它并不考虑问题规模的大小，而是从问题的最明显的最小规模开始逐步求解出可能的答案，并以此慢慢地扩大问题规模，迭代地逼近最终问题的解。这种迭代类似于穷举并且是试探性的，因为当目前的可能答案被测试出不可能可以获得最终解时，则撤销当前的这一步求解过程，回溯到上一步寻找其他求解路径。 为了能够撤销当前的求解过程，必须保存上一步以来的求解路径，这一点相当重要。 三、问题描述 N皇后问题：在一个 N * N 的国际象棋棋盘中，怎样放置 N 个皇后才能使 N 个皇后之间不会互相有威胁而共同存在于棋局中，即在 N * N 个格子的棋盘中没有任何两个皇后是在同一行、同一列、同一斜线上。 深度优先遍历的典型案例。 四、求解思路 1、求解思路：最容易想到的方法就是有序地从第 1 列的第 1 行开始，尝试放上一个皇后，然后再尝试第 2 列的第几行能够放上一个皇后，如果第 2 列也放置成功，那么就继续放置第 3 列，如果此时第 3 列没有一行可以放置一个皇后，说明目前为止的尝试是无效的（即不可能得到最终解），那么此时就应该回溯到上一步（即第 2 步），将上一步（第 2 步）所放置的皇后的位置再重新取走放在另一个符合要求的地方…如此尝试性地遍历加上回溯，就可以慢慢地逼近最终解了。 2、需要解决的问题：如何表示一个 N * N 方格棋盘能够更有效？怎样测试当前所走的试探路径是否符合要求？这两个问题都需要考虑到使用怎样的数据结构，使用恰当的数据结构有利于简化编程求解问题的难度。 3、我们使用以下的数据结构： int column[col] = row 表示第 col 列的第 row 行放置一个皇后 boolean rowExists[i] = true 表示第 i 行有皇后 boolean a[i] = true 表示右高左低的第 i 条斜线有皇后（按→↓顺序从1~ 2*N -1 依次编号） boolean b[i] = true 表示左高右低的第 i 条斜线有皇后（按→↑顺序从1~ 2*N -1 依次编号） 五、算法实现 对应这个数据结构的算法实现如下： 算 法 分 析 与 设 计 报 告 N皇后问题 N后问题算法 一、实验目的及要求 所要涉及或掌握的知识： 1. 了解皇后相互攻击的条件：如果任意两个皇后在同一行，同一列或同一对角线，则她们相互攻击。 2. 运用迭代的方法实现6皇后问题，求解得到皇后不相互攻击的一个解 3. 在运用迭代的方法实现编程时，要注意回溯点 二、问题描述及实验内容 对6皇后问题求解，用数组c[1…6]来存皇后的位置。c[i]=j表示第i个皇后放在第j列。 最后程序运行的结果是c[1…6]={1,5,8,6,3,7 } 三、问题分析和算法描述 6-QUEENS的算法表示： 输入：空。 输出：对应于6皇后问题的解的向量c[1…6]={1,5,8,6,3,7} 1. for k=1 to 6 2. c[k]=0 //没有放皇后 3. end for 4. flag=false 5. k=1 6. while k>=1 7. while c[k]<=5 8. c[k]=c[k]+1 9. if c为合法着色 then set flag=ture 且从两个while循环退出 10. else if c是部分解 then k=k+1 11. end while 12. c[k]=0 //回溯并c[k]=0 13. k=k-1 14. end while 15. if flag then output c 16. else output “no solution” 四、具体实现 # include 实验报告4 回溯算法 实验4 回溯算法解决N皇后问题 一、实验目的 1）掌握回溯算法的实现原理，生成树的建立以及限界函数的实现； 2）利用回溯算法解决N皇后问题； 二、实验内容 回溯算法解决N皇后问题。 三、算法设计 1）编写限界函数bool PLACE(int k,int x[])，用以确定在k列上能否放置皇后； 2）编写void NQUEENS(int n)函数用以摆放N个皇后； 3）编写主函数，控制输入的皇后数目； 4）改进和检验程序。 四、程序代码 //回溯算法解决N皇后问题的c++程序 #include void NQUEENS(int n){ /*此过程使用回溯算法求出在一个n*n棋盘上放置n个皇后，使其即不同行，也不同列，也不在同一斜角线上*/ int k, *x=new int[n];//存放皇后所在的行与列 x[0]=0; k=0; while (k>=0&&k 1、方法思想 回溯法是一个既带有系统性又带有跳跃性的搜索算法。它在问题的解空间树中，按深度优先策略，从根节点出发搜索解空间树。算法搜索至解空间树的任何一结点时，先判断该结点是否包含问题的解。如果肯定不包含，则跳过对以该结点为根的子树的搜索，逐层向其祖先结点回溯；否则进入该子树，继续按深度优先策略搜索。 代码实现： class Queen { friend int nQueen(int) private: bool Place(int k); void Backtrack(int t); int n, //皇后个数 *n; //当前解 long sum; //当前已找到的可行方案数 }； bool Queen::Place(int k) { for (int j=1;j 课程:人工智能课程设计报告 班级: 姓名: 学号: 指导教师:赵曼 2015年11月 人工智能课程设计报告 课程背景 人工智能（Artificial Intelligence），英文缩写为AI。它是研究、开发用于模拟、延伸和扩展人的智能的理论、方法、技术及应用系统的一门新的技术科学。人工智能是计算机科学的一个分支，它企图了解智能的实质，并生产出一种新的能以人类智能相似的方式做出反应的智能机器，该领域的研究包括机器人、语言识别、图像识别、自然语言处理和专家系统等。人工智能从诞生以来，理论和技术日益成熟，应用领域也不断扩大，可以设想，未来人工智能带来的科技产品，将会是人类智慧的“容器”。 人工智能是对人的意识、思维的信息过程的模拟。人工智能不是人的智能，但能像人那样思考、也可能超过人的智能。 人工智能是一门极富挑战性的科学，从事这项工作的人必须懂得计算机知识，心理学和哲学。人工智能是包括十分广泛的科学，它由不同的领域组成，如机器学习，计算机视觉等等，总的说来，人工智能研究的一个主要目标是使机器能够胜任一些通常需要人类智能才能完成的复杂工作。但不同的时代、不同的人对这种“复杂工作”的理解是不同的。 人工智能是计算机学科的一个分支，二十世纪七十年代以来被称为世界三大尖端技术之一（空间技术、能源技术、人工智能）。也被认为是二十一世纪三大尖端技术（基因工程、纳米科学、人工智能）之一。这是因为近三十年来它获得了迅速的发展，在很多学科领域都获得了广泛应用，并取得了丰硕的成果，人工智能已逐步成为一个独立的分支，无论在理论和实践上都已自成一个系统。 人工智能是研究使计算机来模拟人的某些思维过程和智能行为（如学习、推理、思考、规划等）的学科，主要包括计算机实现智能的原理、制造类似于人脑智能的计算机，使计算机能实现更高层次的应用。人工智能将涉及到计算机科学、心理学、哲学和语言学等学科。可以说几乎是自然科学和社会科学的所有学科，其范围已远远超出了计算机科学的范畴，人工智能与思维科学的关系是实践和理论的关系，人工智能是处于思维科学的技术应用层次，是它的一个应用分支。从思维观点看，人工智能不仅限于逻辑思维，要考虑形象思维、灵感思维才能促进人工智能的突破性的发展，数学常被认为是多种学科的基础科学，数学也进入语言、思维领域，人工智能学科也必须借用数学工具，数学不仅在标准逻辑、模糊数学等范围发挥作用，数学进入人工智能学科，它们将互相促进而更快地发展。 Tree-回溯法求N皇后问题 #include 人工智能——四皇后问题 一、问题描述 四皇后问题 一个4×4国际象棋盘，依次放入四个皇后，条件：每行、每列及对角线上只允许出现一枚棋子。 设：DATA=L（表） x∈L x ∈﹛i j﹜ 1≤ i, j ≤4 其中：i j 表示棋子所在行列如：24 表示第二行第四列有一枚棋子 ∵棋盘上可放入的棋子数为0 ～ 4 个 ∴L表中的元素数为0 ～ 4 个，即 Length L = 0 ～ 4 ，如图A ﹛12，24，31，43 ﹜ 定义规则： if 1≤ i ≤4 and Length DATA = i －1 then APPEND(DATA( ij )) 1≤ j ≤4 ①对于任一行i ， 1≤ j ≤4 表明每行有四条规则。 比如第一行：R11，R12，R13，R14 ②棋盘中共有四行，所以共有16条规则。 即： R11，R12，R13，R14 R21，R22，R23，R24 R31，R32，R33，R34 R41，R42，R43，R44 ③ 16条规则中，哪些是当前可用规则，取决于DATA的长度，即：DATA中的元素个数。换言之，每次只能将一个棋子放在当前行的下一行。 二、回溯法搜索策略图 讨论： 上述算法产生22次回溯，原因在于规则自然顺序排列，没考虑任何智能因素。改进算法 定义对角线函数：diag(i,j)：过ij点最长的对角线长度值。 规定：①如果： diag(i,k) ≤ diag(i,j) 则规则排列次序为： Rik， Rij 同一行四条规则中，对角线函数值小的排在前面 ②如果：diag(i,k) ＝ diag(i,j) 则规则排列次序为： Rij ，Rik j ＜ k 对角线长度相等的规则按照字母排列顺序排序 讨论： ①利用局部知识排列规则是有效的。 ② BACKTRACK算法对重复出现的状态没有判断，所以可能造成出现死循环。 ③没有对搜索深度加以限制，可能造成搜索代价太大。 算法设计及分析 n皇后问题---回溯求解 国际象棋中皇后威力很大，它可以象“车”一样沿直线上下或左右移动；也可以如同 “象”那样沿着斜线移动。双方的皇后是不能在同一行或同一列或同一斜线上对持的。那么， 在一张空白的国际象棋盘上最多可以放上几个皇后并且不让它们互相攻击呢？这个问题是伟 大数学家高斯在十九世纪中期提出来的，并作了部分解答。高斯在棋盘上放下了N个互不攻 击的皇后，他还认为可能有N种不同的放法，这就是有名的“N皇后”问题。如果你动手试试， 就一定会发现开头几颗皇后很容易放置，越到后来就越困难。由于我们的记忆有限，很可能 在某个位置放过子后来证明不行取消了，但是以后又重新放上子去试探，这样就会不断地走 弯路，花费大量的精力。因此，必须找到一个简易有效、有条不紊的法则才行。 回溯法的基本思想： 对于用回溯法求解的问题，首先要将问题进行适当的转化，得出状态空间树。这棵树的 每条完整路径都代表了一种解的可能。通过深度优先搜索这棵树，枚举每种可能的解的情况； 从而得出结果。在深度优先搜索的过程中，不断的将每个解（并不一定是完整的，事实上这 也就是构造约束函数的意义所在）与约束函数进行对照从而删除一些不可能的解，这样就不 必继续把解的剩余部分列出从而节省部分时间。 不妨以8皇后为例，设8皇后为x i，她们分别在第i行（i=1,2,3,4,5,6,7,8）,这样问 题的解空间就是一个8个皇后所在列的序号，为n元一维向量（x1,x2,,x3,x4,x5,x6,x7,x8），搜 索空间是1≤x i≤8（i=1,2,3,4,5,6,7,8）,共88个状态。约束条件是8个点 （1,x1）,(2,x2),(3,x3),(4,x4),(5,x5),(6,x6),(7,x7),(8,x8)不在同一列和同一对角线上。虽 然问题共有88个状态，但算法不会真正地搜索这么多的状态，因为回溯法采用的是“走不通 就掉头”的策略，而形如（1,1,x3,x4,x5,x6,x7,x8）的状态共有86个，由于1,2号皇后在同一 列不满足约束条件，回溯后这些状态是不会搜索的。 算法设计： 我们用三个数组c,b,d分别记录棋盘上的n个列，2n-1个住对角线和2n-1个副对角线的 占用情况。用i,j分别表示皇后所在的行列，用表达式i-j+n对主对角线编号，范围是1～2n-1， 用i+j为负对角线编号，范围为2～2n. 程序代码： #include"stdio.h" int a[20],b[20],c[40],d[40],n,i,k; int t=0; //t记录解的个数 void output() { t=t+1; printf("第%d个解:",t); for(k=1;k<=n;k++) printf("%d",a[k]); printf("\n"); } void find(int i) { int j; for(j=1;j<=n;j++) //第i个皇后有n种可能位置 if(b[j]==0&&c[i+j]==0&&d[i-j+n]==0) //判断位置是否冲突 {a[i]=j; //摆放皇后 b[j]=1; //占领第j列 c[i+j]=1;//占领两个对角线 d[i-j+n]=1; if(i回溯法之N皇后问题(C语言)
算法实验 递归回溯解八皇后问题
n皇后问题算法实验报告
回溯法实验(n皇后问题)
数据结构实验报告——栈(八皇后问题)
第五组回溯算法(N皇后排列方法问题)
n皇后问题实验报告
回溯法解八皇后问题
回溯算法与八皇后问题N皇后问题Word版
八皇后实验报告
回溯法实验(n皇后问题)(迭代法)
实验报告：回溯法求解N皇后问题(Java实现)
n皇后问题实验报告
回溯算法解决N皇后问题实验及其代码
回溯法n皇后问题
人工智能课程设计报告-n皇后问题解读
回溯法求N皇后问题
四皇后问题实验报告
n皇后问题算法设计
相关主题
文本预览