求 N 皇后问题回溯算法
n皇后问题解法总数 规律
n皇后问题解法总数规律n皇后问题是一个经典的数学问题，最早由欧洲的数学家在18世纪提出。
问题的描述是在一个n×n的棋盘上放置n个皇后，使得它们互不攻击，即任意两个皇后不能处于同一行、同一列或同一斜线上。
这个问题的解法总数一直是一个引人关注的问题，不同的n对应的解法总数有一定的规律。
首先，我们来分析一下较小的n对应的解法总数。
当n=1时，显然只有一种解法。
当n=2时，由于两个皇后不能处于同一行、同一列或同一斜线上，所以无解。
当n=3时，也无解。
当n=4时，解法总数为2。
具体的解法如下所示：. Q . . . . Q .. . . Q Q . . .Q . . . . . . Q. . Q . . Q . .可以发现，当n=4时，只有两种解法。
随着n的增大，解法总数逐渐增加。
当n=5时，解法总数为10。
当n=6时，解法总数为4。
当n=7时，解法总数为40。
当n=8时，解法总数为92。
当n=9时，解法总数为352。
可以看出，解法总数并不是一个简单的线性增长。
为了进一步分析n皇后问题解法总数的规律，我们可以使用回溯算法。
回溯算法是一种穷举搜索的算法，通过尝试所有可能的解，找到所有满足条件的解。
在n皇后问题中，我们可以从第一行开始，依次尝试每一列，如果当前位置可以放置一个皇后，我们就继续尝试下一行，直到放置了n个皇后，即找到了一种解法。
然后，我们回溯到上一行，尝试该行的下一列，继续寻找下一种解法。
当回溯到第一行时，即找到了所有的解法。
通过回溯算法，我们可以得到n=1到n=9的解法总数，如下所示：n=1，解法总数为1n=2，解法总数为0n=3，解法总数为0n=4，解法总数为2n=5，解法总数为10n=6，解法总数为4n=7，解法总数为40n=8，解法总数为92n=9，解法总数为352可以观察到，n=1到n=9的解法总数并不是一个简单的规律，解法总数的增长呈现出一定的波动。
然而，当n=10时，解法总数突然增加到724。
n皇后问题算法设计
算法设计及分析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号皇后在同一列不满足约束条件，回溯后这些状态是不会搜索的。
n后问题-回溯法
n后问题-回溯法问题描述： 在n*n的棋盘上放置彼此不受攻击的n个皇后。
按国际象棋的规则，皇后可以与之处在同⼀⾏或者同⼀列或同⼀斜线上的棋⼦。
n后问题等价于在n*n格的棋盘上放置n皇后，任何2个皇后不放在同⼀⾏或同⼀列的斜线上。
算法设计： |i-k|=|j-l|成⽴，就说明2个皇后在同⼀条斜线上。
可以设计⼀个place函数，测试是否满⾜这个条件。
1 当i>n时，算法搜索⾄叶节点，得到⼀个新的n皇后互不攻击放置⽅案，当前已找到的可⾏⽅案sum加1. 2 当i<=n时，当前扩展结点Z是解空间中的内部结点。
该结点有x[i]=1,2,3....n共n个⼉⼦节点。
对当前扩展结点Z的每个⼉⼦节点，由place检察其可⾏性。
并以深度优先的⽅式递归地对可⾏⼦树，或剪去不可⾏⼦树。
算法描述： #include <iostream>#include <cstdlib>using namespace std;class Queen{friend int nQueen(int);private:bool Place(int k);void Backtrack(int t);int n,* x;long sum;};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++;elsefor(int i=1;i<=n;i++){x[t] = i;if(Place(t))Backtrack(t+1);}}int nQueen(int n){Queen X;X.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;cout<<X.sum<<endl;return X.sum;}int main(){nQueen(4);nQueen(2);nQueen(3);return0;}执⾏结果：迭代回溯：数组x记录了解空间树中从根到当前扩展结点的路径，这些信息已包含了回溯法在回溯时所需要的信息。
回溯法求解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皇后问题
① 如果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皇后问题递归算法c语言
n皇后问题递归算法c语言概述n皇后问题是一个经典的回溯算法问题，它要求在一个n×n的棋盘上放置n个皇后，使得它们互不攻击。
本文将使用递归算法来解决n皇后问题，并使用C语言进行实现。
问题描述在n×n的棋盘上放置n个皇后，使得它们不在同一行、同一列或同一斜线上。
其中，皇后的移动规则是可以横向、纵向、对角线方向上自由移动任意步数。
算法思路为了解决n皇后问题，我们可以采用递归的方式逐行放置皇后。
具体地，可以按照行优先的顺序，从第一行开始放置皇后，并逐行向下递归，直到放置了n个皇后，或者无法再放置皇后为止。
算法的关键在于如何判断当前位置是否可以放置皇后，即判断是否与已经放置的皇后位置冲突。
为了判断冲突，我们需要考虑以下几个方面：1.所有皇后不能在同一列：我们可以使用一个数组q ue en[]来记录每一行放置的皇后的列位置。
2.所有皇后不能在同一对角线上：我们可以使用两个数组up D ia g[]和d ow nD ia g[]来记录每一条对角线上是否已经存在皇后。
对于任意一个位置(i,j)，它所在的主对角线上的元素满足i-j的值相等，次对角线上的元素满足i+j的值相等。
在放置皇后时，我们可以逐个尝试每一列，然后检查当前位置是否与已经放置的皇后位置冲突，如果冲突则继续尝试下一列，直到找到一个合适的位置。
然后，继续递归放置下一行的皇后，直到放置了n个皇后或者无法再放置为止。
伪代码定义一个全局整型数组q ue en[]，用于记录每一行放置的皇后的列位置定义两个全局整型数组u pD ia g[]和do wn D ia g[]，用于记录每一条对角线上是否已经存在皇后P r oc ed ur en Qu ee ns(r ow):i f ro w=n://找到一个解P r in tS ol ut io n()r e tu rnf o rc ol fr om0t on-1:i f Ca nP la ce Qu ee n(r o w,co l):P l ac eQ ue en(r ow,co l)n Q ue en s(ro w+1)R e mo ve Qu ee n(ro w,c o l)P r oc ed ur eC an Pl ace Q ue en(r ow,c ol):i f qu ee n[co l]!=-1:r e tu rn fa ls ei f up Di ag[r ow-c ol+n-1]!=-1o rd ow nDi a g[ro w+co l]!=-1:r e tu rn fa ls er e tu rn tr ueP r oc ed ur eP la ce Que e n(ro w,co l):q u ee n[co l]=r owu p Di ag[r ow-c ol+n-1]=1d o wn Di ag[r ow+c ol]=1q u ee n[co l]=-1u p Di ag[r ow-c ol+n-1]=-1d o wn Di ag[r ow+c ol]=-1P r oc ed u r eP ri nt Sol u ti on():f o rr ow fr om0t on-1:f o rc ol fr om0t on-1:i f qu ee n[co l]=r ow:p r in t"Q"e l se:p r in t"*"p r in tn ew li nep r in tn ew li neC语言实现下面是使用C语言实现的n皇后问题递归算法的代码示例：#i nc lu de<s td io.h>#d ef in eN8i n tq ue en[N];//记录每一行放置的皇后的列位置i n tu pD ia g[2*N-1];//记录每一条对角线上是否已经存在皇后i n td ow nD ia g[2*N-1];//记录每一条对角线上是否已经存在皇后v o id nQ ue en s(in tro w);i n tc an Pl ac eQ ue en(i nt ro w,in tc ol);v o id pl ac eQ ue en(in t ro w,in tc ol);v o id pr in tS ol ut ion();i n tm ai n(){f o r(in ti=0;i<N;i++){q u ee n[i]=-1;}f o r(in ti=0;i<2*N-1;i++){u p Di ag[i]=-1;d o wn Di ag[i]=-1;}n Q ue en s(0);r e tu rn0;}v o id nQ ue en s(in tro w){i f(r ow==N){p r in tS ol ut io n();r e tu rn;}f o r(in tc ol=0;c ol<N;c ol++){ i f(c an Pl ac eQ ue en(r ow,c ol)){ p l ac eQ ue en(r ow,co l);n Q ue en s(ro w+1);r e mo ve Qu ee n(ro w,c o l);}}}i n tc an Pl ac eQ ue en(i nt r o w,in tc ol){i f(q ue en[c ol]!=-1){r e tu rn0;}i f(u pD ia g[ro w-col+N-1]!=-1||do wnD i ag[r ow+c ol]!=-1){ r e tu rn0;}r e tu rn1;}v o id pl ac eQ ue en(in t ro w,in tc ol){q u ee n[co l]=r ow;u p Di ag[r ow-c ol+N-1]=1;d o wn Di ag[r ow+c ol]=1;}v o id re mo ve Qu ee n(i n tr ow,i nt co l){q u ee n[co l]=-1;u p Di ag[r ow-c ol+N-1]=-1;d o wn Di ag[r ow+c ol]=-1;}v o id pr in tS ol ut ion(){f o r(in tr ow=0;r ow<N;r ow++){f o r(in tc ol=0;c ol<N;c ol++){i f(q ue en[c ol]==ro w){p r in tf("Q");}e ls e{p r in tf("*");}}p r in tf("\n");}p r in tf("\n");}总结本文使用C语言实现了n皇后问题的递归算法。
回溯算法解决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。
n皇后问题
n 后问题1 问题描述：N 皇后问题是一个古老而著名的问题。
该问题是十九世纪著名的数学家高斯1850年提出的。
八皇后问题要求在一个N ＊N 的棋盘上放上N 个皇后，使得每一个皇后既攻击不到另外N-1个皇后，也不被另外N-1个皇后所攻击．按照国际象棋的规则，一个皇后可以攻击与之处在同一行或同一列或同一斜线上的其他任何棋子，问有多少种不同的摆法？并找出所有的摆法。
因此，N 皇后问题等于要求N 个皇后中的任意两个不能被放在同一行或同一列或同一斜线上。
2 回朔法回溯法有“通用的题解法”之称。
从问题的某种可能情况出发，搜索所有能到达的可能情况，然后以其中一种可能的情况为新的出发点，继续向下探索，当所有可能情况1 2 3 4 5 6 7 8 1 2 3 4 5 6 78都探索过且都无法到达目标的时候，再回退到上一个出发点，继续探索另一个可能情况，这种不断回头寻找目标的方法称为“回溯法”。
适用于解组合是较大的问题。
回朔法思想：1针对所给问题，定义问题的解空间。
2.确定易于搜索的解空间结构。
3.以深度优先的方式搜索解空间，并且在搜索过程中用剪枝函数避免无效搜索。
在搜索过程中，通常采用两种策略避免无效搜索：一是用约束函数剪去得不到可行解的子树；二是用限界函数剪去得不到最优解的子树。
这两类函数统称为剪枝函数。
回溯算法的一个显著的特性是在搜索过程中动态产生问题的解空间。
在任何时刻，只保存从根结点到当前扩展结点的路径。
因此，回溯算法的空间需求为o（n），（n为从根结点起最长路径的长度）。
而显式地存储整个解空间则需要o（2n）或o（n!）内存空间。
回溯法对解空间作深度优先搜索，因此，在一般情况下用递归方法实现回溯法。
void backtrack (int t){if (t>n) output(x);elsefor (int i=f(n,t);i<=g(n,t);i++){x[t]=h(i);if (constraint(t)&&bound(t)) backtrack(t+1);}}采用树的非递归深度优先遍历算法，可将回溯法表示为一个非递归迭代过程。
n皇后问题 (回溯法) 原创
for (int i=1;i<=n;i++) {//搜索子结点
x[t]=i;//进入第i个子结点
பைடு நூலகம்if (Place(t)) Backtrack(t+1);}}
int nQueen(int n){Queen X;
//初始化X
X.n=n;
X.sum=0;
int *p=new int [n+1];
}；
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=0;i<=n;i++)
p[i]=0;
X.x=p;
X.Backtrack
(1);//对整个解空间回溯搜索
delete []p;
return X.sum;}运行结果：
•隐约束：
1)不同列：
xixj
2)不处于同一正、反对角线：
|i-j||xi-xj|
代码实现：
class Queen{friend int nQueen(int)
private:
bool Place(int k);
void Backtrack(int t);
int n,//皇后个数
*n;//当前解
long sum;//当前已找到的可行方案数
n
一种求解n皇后问题的概率回溯复合算法
n皇后问题是一种经典的搜索问题，它的目标是在n*n的棋盘上放置n个皇后，使得这n 个皇后互不攻击（不在同一行、同一列、同一对角线上）。
求解n皇后问题的概率回溯复合算法是一种搜索算法，它通过在回溯过程中加入概率元素，来提高求解n皇后问题的效率。
具体来说，该算法的基本思路是：
初始化：将棋盘初始化为一个n*n的空棋盘，并设置一个计数器count，用于记录已经放置的皇后的数量。
回溯：从第0行开始，依次枚举每一行的每一列，判断是否可以在该位置放置皇后。
如果可以，就在该位置放置皇后，并将计数器count加1。
如果不可以，就跳过该位置，继续枚举下一列。
概率元素：在枚举每一列时，随机生成一个概率值p（0<=p<=1）。
如果p大于0.5，则在该位置放置皇后；否则跳过该位置，继续枚举下一列。
这样，在回溯过程中加入了一定的随机性，使得算法具有一定的概率元素。
终止条件：如果count的值等于n，则说明已经成功放置了n个皇后，可以终止算法。
否则，继续执行下一行的枚举过程。
复合：在每一行枚举完所有列之后，需要将已经放置的皇后撤销，并将计数器count减1，然后回到上一行，继续枚举下一列。
这样，在回溯的过程中，算法会不断地撤销和放置皇后，从而实现复合的效果。
总之，求解n皇后问题的概率回溯复合算法是一种结合了回溯和概率元素的搜索算法，可以有效地提高求解n皇后问题的效率。
n皇后问题非递归回溯算法
n皇后问题非递归回溯算法一、问题描述n皇后问题是一个经典的回溯算法问题，其目标是在一个n*n的棋盘上放置n个皇后，使得它们互相之间不能攻击。
即任意两个皇后都不能处于同一行、同一列或者同一斜线上。
二、问题分析1. 回溯算法思路回溯算法是一种通过穷举所有可能情况来找到所有解的算法。
在遍历过程中，如果发现当前状态不符合要求，则回溯到上一个状态进行下一步尝试。
2. 非递归实现传统的n皇后问题解法大多采用递归实现，但是递归实现会存在栈溢出等问题。
因此，我们可以采用非递归实现方式来避免这些问题。
三、算法设计1. 状态表示我们可以用一个数组board来表示当前棋盘状态，其中board[i]表示第i行皇后所在的列数。
2. 状态转移在每一行中，我们依次尝试将皇后放置在每一个位置上。
如果当前位置不符合要求，则继续尝试下一个位置；如果当前位置符合要求，则将该位置标记为已占用，并将当前状态入栈进入下一层搜索。
当搜索到第n层时，说明找到了一组解，将该解保存并回溯到上一层继续搜索。
3. 剪枝优化为了减少不必要的搜索，我们可以采用以下两种剪枝策略：（1）列冲突剪枝：如果当前位置所在列已经有皇后，则直接跳过该位置。
（2）斜线冲突剪枝：如果当前位置所在的左上、右上斜线已经有皇后，则直接跳过该位置。
四、代码实现1. 初始化首先，我们需要定义一个栈来保存状态，并将第一行的所有位置都尝试一遍。
同时，我们还需要定义一个二维数组visited来保存哪些列和哪些斜线已经被占用。
```pythondef solveNQueens(n: int) -> List[List[str]]:res = []stack = []visited = [[False] * n for _ in range(3)]for i in range(n):stack.append([i])visited[0][i] = Truevisited[1][i - 0 + n - 1] = Truevisited[2][i + 0] = True```2. 回溯搜索在搜索过程中，我们不断取出栈顶状态进行扩展。
用回溯法求解n皇后问题
c程序实现
分析问题
//求解的递归函数 void Queen(int i,int n) { if(i>n) Output(); else { for(int j=1;j<=n;++j) // j代表列值 { int k=1; x[i]=j;//重新换一个列值，这里就是体现回溯的地方 while(k<i) { if((x[k]-x[i])*(abs(x[k]-x[i])-abs(k-i))!=0)
分析问题
问题分析
如何保证任何两个皇后不再一 条斜线上？设两个皇后q1和q2放 在（i，j）和（k，l）位置上，如 果q1和q2在斜率为-1的对角线上， 那么i - j = k - l成立，如果在斜率 为1的对角线上，那么 i + j = k + l成立，由此可知只要 | i - k | ≠ | j - l |成立，q1和q2就不 再同一条斜线上。 |i-k|≠|j-l|
分析问题
2.确定解空间 用完全n叉树表示解空间，现在以n=4为例：
分析问题
问题分析
1
1
2 1 34
3 1 24
4 123
2 34
× ×× ×34 24 23 ×14 13 × 34 ×
√
24 14 12 23 13 12
√
4 3 4 2 3 2 4 3 4 1 3 1 4 2 41 21 3 2 31 2 1
回溯法的基本思想
回溯法的基本思想是在问题的解空间树上按 深度优先搜索策略，从根节点出发搜索整个解 空间。搜索过程中，每到达一个结点时，则判 断该结点为根的子树是否含有问题的解，如果 可以确定该子树中不含有问题的解，则放弃对 该子树的搜索，逐层向其祖先节点回溯。否则， 进入该子树。
n皇后问题—回溯法
n皇后问题—回溯法⼀、问题简介描述在n×n 格的棋盘上放置彼此不受攻击的n 个皇后。
按照国际象棋的规则，皇后可以攻击与之处在同⼀⾏或同⼀列或同⼀斜线上的棋⼦。
n后问题等价于在n×n格的棋盘上放置n个皇后，任何2 个皇后不放在同⼀⾏或同⼀列或同⼀斜线上。
设计⼀个解n 后问题的队列式分⽀限界法，计算在n× n个⽅格上放置彼此不受攻击的n个皇后的⼀个放置⽅案。
Input输⼊数据只占⼀⾏，有1 个正整数n，n≤20。
Output将计算出的彼此不受攻击的n个皇后的⼀个放置⽅案输出。
第1⾏是n个皇后的放置⽅案。
Sample Input5Sample Output1 3 52 4⼆、问题分析回溯法解的⽣成回溯法对任⼀解的⽣成，⼀般都采⽤逐步扩⼤解的⽅式。
每前进⼀步，都试图在当前部分解的基础上扩⼤该部分解。
它在问题的状态空间树中，从开始结点（根结点）出发，以深度优先搜索整个状态空间。
这个开始结点成为活结点，同时也成为当前的扩展结点。
在当前扩展结点处，搜索向纵深⽅向移⾄⼀个新结点。
这个新结点成为新的活结点，并成为当前扩展结点。
如果在当前扩展结点处不能再向纵深⽅向移动，则当前扩展结点就成为死结点。
此时，应往回移动（回溯）⾄最近的活结点处，并使这个活结点成为当前扩展结点。
回溯法以这种⼯作⽅式递归地在状态空间中搜索，直到找到所要求的解或解空间中已⽆活结点时为⽌。
回溯法与穷举法回溯法与穷举法有某些联系，它们都是基于试探的。
穷举法要将⼀个解的各个部分全部⽣成后，才检查是否满⾜条件，若不满⾜，则直接放弃该完整解，然后再尝试另⼀个可能的完整解，它并没有沿着⼀个可能的完整解的各个部分逐步回退⽣成解的过程。
⽽对于回溯法，⼀个解的各个部分是逐步⽣成的，当发现当前⽣成的某部分不满⾜约束条件时，就放弃该步所做的⼯作，退到上⼀步进⾏新的尝试，⽽不是放弃整个解重来。
解题思路⽤ d[i]=k 表⽰第 i 个皇后放在第 k 个位置上，然后从第1个皇后，第1个位置开始，每次放置前先调⽤ check() 函数判断与其他皇后是否冲突如果不冲突则放置如果冲突则移⾄下⼀个位置，如果位置到了最后⼀个，则不放，且将上⼀次放置的皇后移⾄下⼀个位置，递归调⽤。
回溯法之N皇后问题
回溯法之N皇后问题回溯法之N皇后问题1. 问题描述在n*n格的棋盘上放置彼此不受攻击的n个皇后。
按照国际象棋的规则，皇后可以攻击与之在同⼀⾏或同⼀列或同⼀斜线上的旗⼦。
n后问题等价于在n*n格的棋盘上放置n个皇后，任何2个皇后不放在同⼀⾏或同⼀列或同⼀斜线上。
2. 问题分析（以n=4皇后问题为例）有俩种解法，第⼀种采⽤解空间为N(4)叉树的解法、第⼆种是采⽤解空间为排列数的解法。
2.1. N(4)叉树的解法每个皇后在⼀⾏上有四个可选位置。
即每个⾮叶结点有4个⼦节点，4叉树如下：解向量：(x1,x2,x3,......,x n)显约束：任意俩皇后不同⾏。
隐约束：(1) 不同列：x i ≠ x j (2) 不处于同⼀正反对⾓线：|i - j| ≠ |x i - x j|核⼼代码：// 剪枝函数，排除同列和同⼀对⾓线的分⽀int place1(int k) {for (int j = 1; j < k; j++)if (abs(k - j) == abs(x[j] - x[k]) || x[j] == x[k])return 0;return 1;}// t > n代表当前解已经求出，将总数+1// 利⽤循环遍历节点的n叉，同时判断分叉是否符合条件// 符合条件的分叉继续遍历下去void BackTrack1(int t) {if (t > n)sum++;elsefor (int i = 1; i <= n; i++) {x[t] = i;if (place1(t))BackTrack1(t + 1);}}2.2 排列数的解法解向量：(x1,x2,x3,......,x n)显约束：任意俩皇后不同⾏、不同列。
x1,x2,x3,......,x n是1,2,3.......n排列隐约束：不处于同⼀正反对⾓线：|i - j| ≠ |x i - x j|核⼼代码：// 交换俩⾏皇后的位置// 实现切换排列数的分⽀作⽤void swap(int i, int j) {int tmp = x[i];x[i] = x[j];x[j] = tmp;}// 剪枝函数，排除在同⼀对⾓线上的情况int place2(int k) {for (int j = 1; j < k; j++)if (abs(k - j) == abs(x[j] - x[k]))return 0;return 1;}// t > n时表⽰当前排列符合条件，总数 + 1// 利⽤for循环，和swap函数，将节点对应的所有排列遍历⼀次// 同时采⽤剪枝函数，减去错误的分⽀// 对正确的分⽀继续求解下去// 最后递归求解结束后，再次调⽤swap函数将状态返回到原本的节点状态void BackTrack2(int t) {if (t > n) sum++;elsefor (int i = t; i <= n; i++) {swap(t, i);if (place2(t))BackTrack2(t + 1);swap(t ,i);}}3. 完整代码/*** 回溯法求解n皇后问题* 使⽤x解向量，x1,x2,x3分别表⽰在1,2,3⾏上皇后的列号**/#include <stdio.h>#include <stdlib.h>#define MAX 4/*** n 皇后个数* x 当前解* sum**/int n = MAX;int x[MAX + 1];long sum = 0;// 剪枝函数，排除同列和同⼀对⾓线的分⽀int place1(int k) {for (int j = 1; j < k; j++)if (abs(k - j) == abs(x[j] - x[k]) || x[j] == x[k])return 0;return 1;}// t > n代表当前解已经求出，将总数+1// 利⽤循环遍历节点的n叉，同时判断分叉是否符合条件// 符合条件的分叉继续遍历下去void BackTrack1(int t) {if (t > n)sum++;elsefor (int i = 1; i <= n; i++) {x[t] = i;if (place1(t))BackTrack1(t + 1);}}// 交换俩⾏皇后的位置// 实现切换排列数的分⽀作⽤void swap(int i, int j) {int tmp = x[i];x[i] = x[j];x[j] = tmp;}// 剪枝函数，排除在同⼀对⾓线上的情况int place2(int k) {for (int j = 1; j < k; j++)if (abs(k - j) == abs(x[j] - x[k]))return 0;return 1;}// t > n时表⽰当前排列符合条件，总数 + 1// 利⽤for循环，和swap函数，将节点对应的所有排列遍历⼀次// 同时采⽤剪枝函数，减去错误的分⽀// 对正确的分⽀继续求解下去// 最后递归求解结束后，再次调⽤swap函数将状态返回到原本的节点状态void BackTrack2(int t) {if (t > n) sum++;elsefor (int i = t; i <= n; i++) {swap(t, i);if (place2(t))BackTrack2(t + 1);swap(t ,i);}}void main() {for (int i = 0; i <= n; i++)x[i] = i;BackTrack1(1);printf("%d\n", sum);for (int i = 0; i <= n; i++)x[i] = i;sum = 0;BackTrack2(1);printf("%d\n", sum);system("pause");}。
用回溯法实现n皇后问题
今天学习了一个经典的算法题：N皇后问题。
在N*N格的棋盘上放置N个皇后，使这些皇后不能互相攻击，即皇后不能在同一行，同一列或者同一对角线上。
以下是看到的比较经典的算法。
解决该问题的最典型的算法就是回溯法。
在那些涉及到寻找一组解的问题或者求满足某些约束条件的最优解的问题中，有许多可以用回溯法来求解。
回溯法是一个既带有系统性又带有跳跃性的的搜索算法。
它在包含问题的所有解的解空间树中，按照深度优先的策略，从根结点出发搜索解空间树。
算法搜索至解空间树的任一结点时，总是先判断该结点是否肯定不包含问题的解。
如果肯定不包含，则跳过对以该结点为根的子树的系统搜索，逐层向其祖先结点回溯。
否则，进入该子树，继续按深度优先的策略进行搜索。
回溯法在用来求问题的所有解时，要回溯到根，且根结点的所有子树都已被搜索遍才结束。
而回溯法在用来求问题的任一解时，只要搜索到问题的一个解就可以结束。
这种以深度优先的方式系统地搜索问题的解的算法称为回溯法，它适用于解一些组合数较大的问题。
回溯法的基本思想：确定了解空间的组织结构后，回溯法就从开始结点（根结点）出发，以深度优先的方式搜索整个解空间。
这个开始结点就成为一个活结点，同时也成为当前的扩展结点。
在当前的扩展结点处，搜索向纵深方向移至一个新结点。
这个新结点就成为一个新的活结点，并成为当前扩展结点。
如果在当前的扩展结点处不能再向纵深方向移动，则当前扩展结点就成为死结点。
换句话说，这个结点不再是一个活结点。
此时，应往回移动（回溯）至最近的一个活结点处，并使这个活结点成为当前的扩展结点。
回溯法即以这种工作方式递归地在解空间中搜索，直至找到所要求的解或解空间中已没有活结点时为止。
运用回溯法解题通常包含以下三个步骤：（1）针对所给问题，定义问题的解空间；（2）确定易于搜索的解空间结构；（3）以深度优先的方式搜索解空间，并且在搜索过程中用剪枝函数避免无效搜索；回溯法可用递归实现：procedure try(i:integer);varbeginif i>n then 输出结果else for j:=下界 to 上界 dobeginx[i]:=h[j];if 可行{满足限界函数和约束条件} then begin 置值；try(i+1); end;end;end;回到N皇后问题的解决来，看看如何用回溯法解。
回溯法解决n皇后问题
n 皇 后 问 题N 皇后问题，是一个古老而着名的问题，是回溯算法的典型例题：在N*N 格的格子上摆放N 个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法？ 1、定义问题的解空间首先以八皇后为例，可以用一棵树表示8皇后问题的解空间。
由于8皇后问题的解空间为8!种排列，因此我们将要构造的这棵树实际上是一棵排列树。
2、确定解空间树的结构给棋盘上的行和列从1到8编号，同时也给皇后从1到8编号。
由于每一个皇后应放在不同的行上，不失一般性，假设皇后i 放在第i 行上，因此8皇后问题可以表示成8元组(x 1， x 2， …， x 8)， 其中xi (i =1， 2， …， 8)表示皇后i 所放置的列号。
这种表示法的显式约束条件是S i ={1， 2， 3， 4， 5， 6， 7， 8}，i =1， 2， …， 8。
在这种情况下， 解空间为88个8元组组成，而隐式约束条件是没有两个xi 相同(即所有皇后必须在不同列上)，且满足不存在两个皇后在同一条对角线上。
加上隐式约束条件，问题的解空间可进一步减小。
此时，解空间大小为8!，因为所有解都是8元组的一个置换。
图5-7表示了8皇后问题的一个解。
图5-7 8皇后问题的一个解为了简单起见，图5-8只给出了n =4时问题的一种可能树结构。
QQQQQQQQ8765432112345678图5-8 4皇后问题解空间的树结构在实际中，并不需要生成问题的整个状态空间。
通过使用限界函数来删除那些还没有生成其所有子结点的活结点。
如果用(x1，x2，…，x i)表示到当前E结点的路径，那么xi+1就是这样的一些结点，它使得(x1，x2，…，x i，x i+1)没有两个皇后处于相互攻击的棋盘格局。
在4皇后问题中，惟一开始结点为根结点1，路径为( )。
开始结点既是一个活结点，又是一个E结点，它按照深度优先的方式生成一个新结点2，此时路径为(1)，这个新结点2变成一个活结点和新的E结点，原来的E结点1仍然是一个活结点。
n皇后问题涉及的算法
n皇后问题是一个经典的回溯算法问题。
算法步骤如下：
1. 创建一个n×n的棋盘，并初始化所有格子为空。
2. 从第一行开始，依次放置皇后，直到放置完所有皇后或无法放置皇后为止。
3. 如果放置完所有皇后，则返回一个解，即找到了一个可行的放置方案。
4. 如果无法放置皇后，则回溯到上一行，尝试在其它列中放置皇后。
如果上一行也无法放置皇后，则继续回溯到前一行，直到找到一个可行的放置位置为止。
5. 如果所有的皇后都被成功放置，则输出所有的解。
在这个算法中，回溯是一种试错的方法，它尝试分步解决问题。
在每个步骤中，算法做出一个可能的选择，如果这个选择无法导致解决方案，那么算法就会“回溯”并尝试其他的选择。
同时也可以用位运算来求解n皇后问题，其中最主要的是利用了异或运算。
以上就是求解n皇后问题涉及的主要算法。
基本算法4-回溯法-N皇后问题
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
借书问题 [问题描述]
学校放暑假时，信息学辅导教师有n本书要分给参加培训的n个学生。如：A， B，C，D，E共5本书要分给参加培训的张、刘、王、李、孙5位学生，每人只能选 1本。教师事先让每个人将自己喜爱的书填写在如下的表中，然后根据他们填写的 表来分配书本，希望设计一个程序帮助教师求出可能的分配方案，使每个学生都满 意。 A 张 王 刘 孙 李 Y Y Y Y Y Y Y B C Y D Y E
● ●
……
● ● ● ● ● ● ● ●
……
……
●
●
●
●
●
● ● ● ●
●
●
● ●
●
● ●
●
● ●
● ● ● ●
● ● ● ●
● ● ● ●
● ● ● ● ●
● ● ●
•搜索解空间，剪枝：
– (1) 从空棋盘起，逐行放置棋子。
– (2) 每在一个布局中放下一个棋子，即推演到一 个新的布局。 – (3) 如果当前行上没有可合法放置棋子的位置， 则回溯到上一行，重新布放上一行的棋子。
61 2
64
3
16
3
20
4
22
1
25
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
/*
* File: queen.c
* Description: 求 N 皇后问题回溯算法
* Created: 2001/11/12
* Author: Justin Hou [mailto:justin_hou@]
*/
#include <stdio.h>
#define DelayTime 20000 /* 显示棋局时间 */
#define TopX 10 /* 棋盘左上角 x 坐标 */ #define TopY 5 /* 棋盘左上角 y 坐标 */
int N; /* 皇后数量 */
int a[8], b[15], c[15];
/*
* a[col-1] 记录第 col 列有无皇后, 1 表示有。
* b[row+col-2] 记录从左上数第 row+col-1 条斜率为 1 的线上有无皇后。
* c[row-col+7] 记录从右上数第 row-col+8 条斜率为 -1 的线上有无皇后。
*/
int Num = 0;
int row;
void BackTrack (int row)
{
int col; /* 局部变量 */ for (col=1; col<=N; col++)
{
if (a[col-1] + b[row+col-2] + c[row-col+N-1] == 0)
{
a[col-1] = 1; /* 更改数据 */ b[row+col-2] = 1;
c[row-col+N-1] = 1;
gotoxy(col*2 + TopX, row + TopY); /* 画皇后 */
putch('Q');
if (row < N)
{
BackTrack (row + 1);
}
else
{
Num++; /* 递归终点 */ gotoxy(40, 9);
printf("Num: %d ", Num);
delay(DelayTime);
}
a[col-1] = 0; /* 清空数据 */
b[row+col-2] = 0;
c[row-col+N-1] = 0;
gotoxy(col*2 + TopX, row + TopY); /* 清除图象 */ putch('.');
}/* end if */
}/* end for */
}/* end function BackTrack */
void main()
{
int i, j;
clrscr();
gotoxy(1, 10); /* 要求用户输入皇后数量*/
printf("Input the number of queen: ");
while(N <= 0 || N > 14)
{
scanf("%d", &N);
if(N > 14) printf("Two huge number, input again:");
if(N <= 0) printf("Can's smaller than 1, again:");
}
clrscr();
for(i=1; i<=N; i++) /* 画棋盘(Chessboard) */
{
for(j=1; j<=N; j++)
{
gotoxy(i*2 + TopX, j + TopY);
putch('.');
}
}
BackTrack(1); /* 开始回溯算法*/
gotoxy(12, 17); /* 显示最后结果*/
printf ("There are %d kinds of solution.\n", Num);
getch();
}。