基本算法4-回溯法-N皇后问题
n皇后问题实验报告
n皇后问题实验报告n皇后问题实验报告引言：n皇后问题是一个经典的数学问题，它要求在一个n×n的棋盘上放置n个皇后，使得它们互相之间不能相互攻击，即任意两个皇后不能处于同一行、同一列或同一对角线上。
本实验旨在通过编程实现n皇后问题的求解，并探索不同算法在解决该问题上的性能差异。
实验步骤及结果：1. 回溯算法的实现与性能分析回溯算法是最常见的解决n皇后问题的方法之一。
它通过递归的方式遍历所有可能的解，并通过剪枝操作来提高效率。
我们首先实现了回溯算法，并对不同规模的问题进行了求解。
在测试中，我们将问题规模设置为4、8、12和16。
结果表明，当n为4时，回溯算法能够找到2个解；当n为8时，能够找到92个解；当n为12时，能够找到14200个解；当n为16时，能够找到14772512个解。
可以看出，随着问题规模的增加，回溯算法的求解时间呈指数级增长。
2. 启发式算法的实现与性能分析为了提高求解效率，我们尝试了一种基于启发式算法的解决方法。
在该方法中，我们使用了遗传算法来搜索解空间。
遗传算法是一种模拟生物进化过程的优化算法，通过进化操作（如选择、交叉和变异）来寻找问题的最优解。
我们将遗传算法应用于n皇后问题，并对不同规模的问题进行了求解。
在测试中，我们将问题规模设置为8、12和16。
结果表明，遗传算法能够在较短的时间内找到问题的一个解。
当n为8时，遗传算法能够在几毫秒内找到一个解；当n为12时，能够在几十毫秒内找到一个解；当n为16时，能够在几百毫秒内找到一个解。
相比之下，回溯算法在同样规模的问题上需要几秒钟甚至更长的时间。
3. 算法性能对比与分析通过对比回溯算法和启发式算法的性能，我们可以看到启发式算法在求解n皇后问题上具有明显的优势。
回溯算法的求解时间随问题规模呈指数级增长，而启发式算法的求解时间相对较短。
这是因为启发式算法通过优化搜索策略，能够更快地找到问题的解。
然而，启发式算法并非没有缺点。
回溯法实验(n皇后问题)(迭代法)
算法分析与设计实验报告第三次附加实验附录：完整代码（回溯法）//回溯算法递归回溯n皇后问题#include<iostream>#include<time.h>#include<iomanip>#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<<"皇后问题的解为："<<endl;clock_t start,end,over; //计算程序运行时间的算法start=clock();end=clock();over=end-start;start=clock();m=nQueen(n); //调用求解的函数cout<<n<<"皇后问题共有";cout<<m<<"个不同的解！"<<endl; //输出结果end=clock();printf("The time is %6.3f",(double)(end-start-over)/CLK_TCK); //显示运行时间cout<<endl;}system("pause");return 0;}bool Queen::Place(int k)//传入行号{for(int j=1;j<k;j++){if((abs(k-j)==abs(x[j]-x[k]))||(x[j]==x[k]))//如果两个在同一斜线或者在同一列上，说明冲突，该位置不可用{return false;}}return true;}void Queen::Backtrack(int t){if(t>n){sum++;/*for(int i=1;i<=n;i++) //输出皇后排列的解{cout<<x[i]<<" ";}cout<<endl;*/}else{//回溯探索第i行的每一列是否有元素满足要求for(int i=1;i<=n;i++){x[t]=i;if(Place(t)){Backtrack(t+1);}}}}int nQueen(int n){Queen X; //定义Queen类的对象X//初始化XX.n=n;X.sum=0;int *p=new int[n+1]; //动态分配for(int i=0;i<=n;i++) //初始化数组{p[i]=0;}X.x=p;X.Backtrack(1);delete[] p;return X.sum;//输出解的个数}完整代码（回溯法）//回溯算法迭代回溯n皇后问题#include<iostream>#include<time.h>#include<iomanip>#include"math.h"using namespace std;class Queen{friend int nQueen(int); //定义友元函数private:bool Place(int k); //定义位置是否可用的判断函数void Backtrack(void); //定义回溯函数int n; // 皇后个数int *x; // 当前解long sum; // 当前已找到的可行方案数};int main(){int n,m;for(int i=1;i<=1;i++){cout<<"请输入皇后的个数：";cin>>n;cout<<n<<"皇后问题的解为："<<endl;clock_t start,end,over; //计算程序运行时间的算法start=clock();end=clock();over=end-start;start=clock();m=nQueen(n); //调用求解皇后问题的函数cout<<n<<"皇后问题共有";cout<<m<<"个不同的解!"<<endl;end=clock();printf("The time is %6.3f",(double)(end-start-over)/CLK_TCK); //显示运行时间cout<<endl;}system("pause");return 0;}bool Queen::Place(int k){for (int j=1;j<k;j++){if ((abs(k-j)==abs(x[j]-x[k]))||(x[j]==x[k])) //如果两个皇后在同一斜线或者在同一列上，说明冲突，该位置不可用{return false;}}return true;}void Queen::Backtrack() //迭代法实现回溯函数{x[1] = 0;int k = 1;while(k>0){x[k] += 1; //先将皇后放在第一列的位置上while((x[k]<=n)&&!(Place(k))) //寻找能够放置皇后的位置{x[k] += 1;}if(x[k]<=n) //找到位置{if(k == n) //如果寻找结束输出结果{/*for (int i=1;i<=n;i++){cout<<x[i]<<" ";}cout<<endl; */sum++;}else//没有结束则找下一行{k++;x[k]=0;}}else//没有找到合适的位置则回溯{ k--; }}}int nQueen(int n){Queen X; //定义Queen类的对象X//初始化XX.n=n;X.sum=0;int *p=new int[n+1];for(int i=0;i<=n;i++){p[i]=0;}X.x=p;X.Backtrack();delete []p;return X.sum; //返回不同解的个数}。
回溯法求解N皇后问题
算法的实现
• 假设回溯法要找出所有的答案结点 。 • 设(x1,x2,…,xi-1)是状态空间树中由根到一个结 点的路径，而T(x1,…xi-1)是下述所有结点xi的 集合，它使得对于每一个xi，(x1,x2,…,xi)是由 根到一个结点xi的路径；假定还存在着一些限 界函数Bi，如果路径(x1,x2,…,xi)不可能延伸到 一个答案结点，则Bi(x1,x2,…,xi)取假值，否则 取真值。 • 于是解向量X(1:n)中的第i个分量，就是那些 选自集合T (x1,x2,…,xi-1)且使Bi为真的xi
HHIT
算法8.5：n-皇后问题的解
Algorithm
Procedure NQUEENS(n) //此过程使用回溯法求出一个n*n棋盘上放置n个皇后，使其不能互相攻 击的所有可能位置// integer k,n,X(1:n) X(1)0 ; k1 // 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 //不能放则转到下一列// repeat if X(k)<=n then //找到一个位置// if k=n then print (X) //是一个完整的解则打印这个数组// else kk+1;X(k)0 //否则转到下一行// end if else kk-1 //回溯// end if repeat End NQUEENS
HHIT
Algorithm
显然，棋盘的每一行上可以而且必须摆放一个皇后， 所以，n皇后问题的可能解用一个n元向量X=(x1, x2, …, xn) 表示，其中，1≤i≤n并且1≤xi≤n，即第i个皇后放在第i行第 xi列上。 由于两个皇后不能位于同一列上，所以，解向量X必 须满足约束条件： xi≠xj （式8.1）
实验四N皇后问题求解
实验四N 皇后问题求解、题目1) 以Q-皇后问题为例，掌握回溯法的基本设计策略。
2) 掌握回溯法解决Q-皇后问题的算法并实现；二、算法设计思想回溯法是在包含问题的所有解的解空间树中，按照深度优先搜索的策略，从根结点出发深度探索解空间树。
当探索到某一结点时，要先判断该结点是否包含问题的解，如果包含，就从该结点出发继续探索下去，如果该结点不包含问题的解，则逐层向其祖先结点回溯。
(其实回溯法就是对隐式图的深度优先搜索算法)。
若用回溯法求问题的所有解时，要回溯到根，且根结点的所有可行的子树都要已被搜索遍才结束。
而若使用回溯法求任一个解时，只要搜索到问题的一个解就可以结束。
判断解是否可行的条件：1. 不在同一行或者同一列，x[i]!=x[j],i!=j2•不在一条斜线上，设两个皇后在(i,j)和(k,l)位置，卜k|!=|j-l|三、程序#include<stdio.h>#include<stdlib.h>int n,stack[100]; // 存当前路径int total; // 路径数int att(int,int);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]}int att(int l,int i){}for (i=1;i<=n;i++){stack[l]=i; II算符i 作用于生成stack[l-1]产生子状态stack[l];if (!att(l,i))make(l+1);printf("\n");exit; II 回溯} II 再无算符可用，回溯int k;for (k=1;k<l;k++)if (abs(l-k)==abs(stack[k]-i)||i==stack[k])return 1;return 0;}int main(){}四、运行结果printf("N=");scanf("%d",&n);total=0; II 路径数初始化为0make(1); II从结点1出发，递归搜索所有的路径printf("%d\n",total);system("pause");return 0;六、心得体会在解决N皇后的时候一开始有点不止如何着手，因为这里有个N的不确定性，所以选择简单少量的情况进行具体考虑显得相对容易了许多，还有一个值得注意的问题就是如何判断要不要重新开始搜索，并且在已经形成的简单模型基础上进行改进，使之也能满足后面较复杂情况。
回溯法求解N皇后问题
① 如果xi+1= ai＋1k不是集合Si＋1的最后一个元素，则令xi+1= ai＋ 1k＋1，即选择Si+1的下一个元素作为解向量X的第i+1个分量；
② 如果xi+1= ai＋1k是集合Si＋1的最后一个元素，就回溯到X=(x1, x2, …, xi)，选择Si的下一个元素作为解向量X的第i个分量，假 设xi= aik，如果aik不是集合Si的最后一个元素，则令xi= aik＋1； 否则，就继续回溯到X=(x1, x2, …, xi－1)；
global X(1:k); integer i,k;
i1
while i<k do
if X(i)=X(k) or ABS(X(i)-X(k))=ABS(i-k) then
return (false)
end if
ii+1 repeat return (true)
判断是否有其它的皇 后与之在同一列或同 一斜对角线上
HHIT
Algorithm
（1）如果X=(x1, x2, …, xi＋1)是问题的最终解，则输出这个解。 如果问题只希望得到一个解，则结束搜索，否则继续搜索其
他解；
（2）如果X=(x1, x2, …, xi＋1)是问题的部分解，则继续构造解 向量的下一个分量；
（3）如果X=(x1, x2, …, xi＋1)既不是问题的部分解也不是问题 的最终解，则存在下面两种情况：
while k>0 do // 对所有的行，执行以下语句 //
X(k)X(k)+1 //移到下一列//
while X(k)<=n and Not PLACE(k) do //此处能放这个皇后吗//
X(k)X(k)+1 //不能放则转到下一列//
实验四回溯法求n皇后问题
return true;
}
void queue(intn)
{
inti,k;
for(i=1;i<=n;i++)
x[i]=0;
k=1;
while(k>=1)
{
x[k]=x[k]+1; //在下一列放置第k个皇后
while(x[k]<=n&&!place(k))
x[k]=x[k]+1;//搜索下一列
k=k+1;//放置下一个皇后
else
{
x[k]=0;//重置x[k],回溯
k=k-1;
}
}
}
void main()
{
intn;
printf("输入皇后个数n:\n");
scanf("%d",&n);
queue(n);
}
五、实验结果截图
六、实验总结
关于n皇后问题，看似复杂难懂，运行结果也很多，但是如果掌握了算法的要点，并且编写的准确无误，其实很简单明了的，而且在组实验的过程中会体会到很多乐趣，当然也有不懂得地方，需要请教别人，总之受益匪浅。
if(x[k]<=n&&k==n)//得到一个输出
{
for(i=1;i<=n;i++)
printf("%d ",x[i]);
printf("\n");
//return;//若return则只求出其中一种解，若不return则可以继续回溯，求出全部的可能的解
}
else if(x[k]<=n&&k<n)
八皇后以及N皇后问题分析
⼋皇后以及N皇后问题分析⼋皇后是⼀个经典问题，在8*8的棋盘上放置8个皇后，每⼀⾏不能互相攻击。
因此拓展出 N皇后问题。
下⾯慢慢了解解决这些问题的⽅法：回溯法：回溯算法也叫试探法，它是⼀种系统地搜索问题的解的⽅法。
回溯算法的基本思想是：从⼀条路往前⾛，能进则进，不能进则退回来，换⼀条路再试。
在现实中，有很多问题往往需要我们把其所有可能穷举出来，然后从中找出满⾜某种要求的可能或最优的情况，从⽽得到整个问题的解。
回溯算法就是解决这种问题的“通⽤算法”，有“万能算法”之称。
N皇后问题在N增⼤时就是这样⼀个解空间很⼤的问题，所以⽐较适合⽤这种⽅法求解。
这也是N皇后问题的传统解法，很经典。
算法描述：1. 算法开始，清空棋盘。
当前⾏设为第⼀⾏，当前列设为第⼀列。
2. 在当前⾏，当前列的判断放置皇后是否安全，若不安全，则跳到第四步。
3. 在当前位置上满⾜条件的情况： 在当前位置放⼀个皇后，若当前⾏是最后⼀⾏，记录⼀个解； 若当前⾏不是最后⼀⾏，当前⾏设为下⼀⾏，当前列设为当前⾏的第⼀个待测位置； 若当前⾏是最后⼀⾏，当前列不是最后⼀列，当前列设为下⼀列； 若当前⾏是最后⼀⾏，当前列是最后⼀列，回溯，即清空当前⾏以及以下各⾏的棋盘，然后当前⾏设为上⼀⾏，当前列设为当前⾏的下⼀个待测位置； 以上返回第⼆步。
4.在当前位置上不满⾜条件： 若当前列不是最后⼀列，当前列设为下⼀列，返回到第⼆步； 若当前列是最后⼀列，回溯，即，若当前⾏已经是第⼀⾏了，算法退出，否则，清空当前⾏以及以下各⾏的棋盘，然后，当前⾏设为上⼀⾏，当前列设为当前⾏的下⼀个待测位置，返回第⼆步。
如何判断是否安全：把棋盘存储为⼀个N维数组a[N]，数组中第i个元素的值代表第i⾏的皇后位置，这样便可以把问题的空间规模压缩为⼀维O(N)，在判断是否冲突时也很简单， ⾸先每⾏只有⼀个皇后，且在数组中只占据⼀个元素的位置，⾏冲突就不存在了， 其次是列冲突，判断⼀下是否有a[i]与当前要放置皇后的列j相等即可。
回溯算法解决N皇后问题实验及其代码
实验报告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<math.h>#include<iostream>using namespace std;int count=0; //皇后摆放的可能性bool PLACE(int k,int x[]);//限界函数void NQUEENS(int n);//摆放皇后int main(){}int queen;cout<<"先生（女士）请您输入皇后的总数，谢谢！:"<<endl;cin>>queen;NQUEENS(queen);cout<<"所有可能均摆放完毕,谢谢操作"<<endl;return 0;void NQUEENS(int n){/*此过程使用回溯算法求出在一个n*n棋盘上放置n个皇后，使其即不同行，也不同列，也不在同一斜角线上*/int k, *x=new int[n];//存放皇后所在的行与列x[0]=0;k=0;while (k>=0&&k<n){ //对所有的行执行以下语句x[k]=x[k]+1; //移到下一列while(x[k]<=n&&(!PLACE(k,x))){ //此处能放置一个皇后吗?}if( x[k]<=n ) { //找到一个位置if( k==n-1 ){ //是一个完整的解吗cout<<"第"<<++count<<"排法是："<<endl;for(int i=0;i<n;i++)//打印皇后的排列{}cout<<"\n";for (int j=0;j<n;j++){}cout<<"\n";if (x[i] == j+1){}else{}cout<<". ";cout<<"*";x[k]=x[k]+1; //移到下一列}}}}else { k=k+1; x[k]=0;} //移向下一行else k=k-1; //回溯bool PLACE(int k,int x[]){/*如果一个皇后能放在第k行和x(k)列，返回ture;否则返回false。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
program jieshu; var a:array[1..100,1..100] of integer; {a[i,j]=1:第i个人喜欢第j本书,0 表示不喜欢} b,book:array[1..100] of integer; {b[i]是第i个人借第b[i]本书 ,book[[i]值为0表示可以借此本书，为1表示已经被他人借走} n:integer; procedure csh();{读入原始数据} var i,j:integer; begin fillchar(b,sizeof(b),0); {所有人未借书} fillchar(book,sizeof(book),0); {所有书未借出} fillchar(a,sizeof(a),0); readln(n); for i:=1 to n do begin for j:=1 to n do read(a[i,j]); readln; end; end;
61 2
64
3
16
3
20
4
22
1
25
4 1 27 1
30
4 1
38 41
9 11
4
43 46 48 52 54
57 59
62
2
3
15
2
17
4
21
3
23
4
26
3
1
4
2
39
4
42
1
44
2
1
2
3
3
58
1
60
2
63
1
65
5
10 12
28 31
33 37
47 49
53 55
参考程序段
Procedure try(I:Integer) ; Var j:integer; Begin for j:=1 to N do IF 在J位置安排皇后不冲突，满足条件 then begin 确定A（I）=J，同时确定以后的约束条件 IF 不是最后一个皇后 THEN 递归调用 try(i+1) ELSE 打印结果； 如果I+1出了问题，应在此时回溯。上面的A（I）=J释放， 由于递归时，自动记录了定位时的J值，所以在前面的J值后继续探索。 End; End;
1 x1=1 2 x2= 4 x1= 2 18
1 3
1
x2= 1 x2= 4 x2= 3 29 24 13 19 8 3 x3=2 kill kill kill x3=4 x3=1 x3=2 x3=3 x2= 2 x2= 3
2
4 1 2 3 1 2
9 kill
11 14 kill x4=3 15 kill
● ●
……
● ● ● ● ● ● ● ●
……
……
●
●
●
●
●
● ● ● ●
●
●
● ●
●
● ●
●
● ●
● ● ● ●
● ● ● ●
● ● ● ●
● ● ● ● ●
● ● ●
•搜索解空间，剪枝：
– (1) 从空棋盘起，逐行放置棋子。
– (2) 每在一个布局中放下一个棋子，即推演到一 个新的布局。 – (3) 如果当前行上没有可合法放置棋子的位置， 则回溯到上一行，重新布放上一行的棋子。
18 x2= 4
1 1
2
x2= 1 x2 = 3 24 13 19 8 3 x3=2 kill kill kill x3=4 x3=2 x3=3 x2= 2 x2= 3 9 kill 11 14 kill x4=3 15 kill 16 kill
1 2
结点18生成结点29, 结点29成为E结点, 路径变为(2,4); 结点29生成结点30, 路径变为(2,4,1) 结点30生成结点31, 路 径变为(2,4,1,3), 找到一 个4-王后问题的可行解
输入格式： 第一行一个数n（学生的个数，书的数量） 以下共n行，每行n个0或1（由空格隔开），第I行数据表 示第i个同学对所有书的喜爱情况。0表示不喜欢该书，1表示喜 欢该书。 输出格式： 依次输出每个学生分到的书号。 输入样例：book.in 5 00110 11000 01100 00010 01001 输出样例：book.out 31245
开始把根结点作为唯一的活结点, 根结点就成为E-结点 而且路径为( ); 接着生成子结点, 假设按自然数递增的次 序来生成子结点, 那么结点2被生成, 这条路径为(1), 即把 皇后1放在第1列上.
结点2变成E-结点, 它再生成结点3, 路径变为 (1, 2), 即皇后1在第1列上,王后2在第2列上, 所 以结点3被杀死, 此时应回溯.
不同行：由于是一行只排一个皇 后，所以肯定不同行。 不同列：设置一个数组：MARK0， 当J列已安排皇后时， MARK0[J]:=FALSE。不允许再安排 皇后。 不在同一对角线： *任意一条红色左斜线上的方格坐 标都有一个规律： Ｉ＋Ｊ相等，只要标记 MARK1[I+J]:=FALSE，该条红色左 斜线都将不可安排。 红色的斜线从最左边1＋1， 2+1或1+2到N＋N条。 *任意一条绿色的右斜线上的方格 坐标也有一个规律： Ｉ－Ｊ相等，也只要定义 MARK2[I-J]=FALSE，则所有该右 斜线都将不可安排。 绿色的斜线从最右边 1-N到 N-1条。
1
1
2
3
x2= 2 x2 = 3 3 kill 8 x3=2 9 kill
1
2
1 2 3
4
结点2的所有儿子表示的都是不可能 导致答案的棋盘格局, 因此结点2也被 杀死; 再回溯到结点1生成结点18, 路径 变为(2). 结点18的子结点19、结点 24被杀死, 应回溯.
1 x1=1 2 x1= 2
4×4
Q1 Q2 Q3 Q4
4皇后问题的回溯举例
如何在4×4的方格棋盘上放置4个皇后，使它们互不攻击:
N皇后问题
• 确定问题状态：问题的状态即棋盘的布局状态。
• 构造状态空间树：状态空间树的根为空棋盘，每个布局 的下一步可能布局是该布局结点的子结点。
– 由于可以预知，在每行中有且只有一个皇后，因此可 采用逐行布局的方式，即每个布局有n个子结点。
回溯：
当所有的J都不满足条件，第I+1个皇后无法安置时，此 时应回溯第I个皇后，回溯如下： MARK0[J]:=TRUE： MARK1[I+J]:=TRUE： MARK2[I-J]:=TRUE 将第 I个皇后的约束条件释放，待重新安置后再确定约 束条件。
加约束条件
● ● ● ●
● ●
● ●
ห้องสมุดไป่ตู้
● ●
1
x1=1 2
x2= 2 3 kill
1
1 2
回溯到结点2生成结点8, 路径变为(1, 3), 则结点8成为E-结点, 它生成结点9和结点11都会被杀死(即它的儿子表示不可能导 x1=1 致答案的棋盘格局), 所以结点8也被杀死, 应回溯.
1
1
1
2
2
3
x2= 2 x2= 3 3 kill 8 x3=2 9 kill x3=4 11 kill
16 kill
30 x4=3 31
可 行 解
n=4的n皇后问题的搜索、剪枝与回溯
1
2 2 2 3 3 3 4 4 4 2 6 3 7 8 4 2
14 13 19 18
1 3 34 4
29
4
50 4 45 4 1 2 3 51 2 1 1 3
4
1
3 24
1 35 3 2
32 36
2 40
2 56
3 1
1
2
1 2 3
回溯到结点2生成结点13, 路径变为(1, 4), 结点13成 为E-结点, 由于它的儿子表示的是一些不可能导致答 案结点的棋盘格局, 因此结点13也被杀死, 应回溯
1 x1=1 2 x2= 4 13 x3=2 x3=4 x3=3 11 14 kill x4=3 15 kill 16 kill
• 设4个皇后为xi，分别在第i行(i=1，2，3，4)； • 问题的解状态：可以用(1,x1)，(2,x2)，……，(4,x4) 表示4个皇后的位置； – 由于行号固定，可简单记为：(x1,x2,x3,x4)； – 例如：(4, 2, 1,3) • 问题的解空间： (x1,x2,x3,x4)，1≤xi≤4(i=1，2，3，4)， 共4！个状态；
算法设计: procedure work(i:integer);//要搜索第i个人可以借的书b[i]，说明:前 i-1个人已经借好书 begin if (i>n) then sc();//输出结果； for j:=1 to n do//搜索第i个人能够借的书 if (book[j]=0) and (a[i,j]=1) then //第i个人可以借第j 本书 begin b[i]:=j;//记录下第i个人借的书j book[j]:=1;//标记第j本数已被借 work(i+1);//搜索第i+1个人可以借的书 book[j]:=0;//删除书的被借标志;回溯时要消除当前作的标 记，不影响下一次重新尝试 end; end;
1
62
2
64
9 11
4 2
27
1
30
43 46 48 52 54
57 59
4
5
3
15
2
17
4
21
3
23
4
26
3
1
4
2
39
4
42
1
44
2
1
2
3
3
58
1