N皇后问题回溯算法探讨
回溯算法与八皇后问题N皇后问题Word版
回溯算法与八皇后问题(N皇后问题)1 问题描述八皇后问题是数据结构与算法这一门课中经典的一个问题。
下面再来看一下这个问题的描述。
八皇后问题说的是在8*8国际象棋棋盘上，要求在每一行放置一个皇后，且能做到在竖方向，斜方向都没有冲突。
更通用的描述就是有没有可能在一张N*N的棋盘上安全地放N个皇后？2 回溯算法回溯算法也叫试探法，它是一种系统地搜索问题的解的方法。
回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来，换一条路再试。
在现实中，有很多问题往往需要我们把其所有可能穷举出来，然后从中找出满足某种要求的可能或最优的情况，从而得到整个问题的解。
回溯算法就是解决这种问题的“通用算法”，有“万能算法”之称。
N皇后问题在N增大时就是这样一个解空间很大的问题，所以比较适合用这种方法求解。
这也是N皇后问题的传统解法，很经典。
下面是算法的高级伪码描述，这里用一个N*N的矩阵来存储棋盘：1) 算法开始, 清空棋盘，当前行设为第一行，当前列设为第一列2) 在当前行，当前列的位置上判断是否满足条件(即保证经过这一点的行,列与斜线上都没有两个皇后)，若不满足，跳到第4步3) 在当前位置上满足条件的情形：在当前位置放一个皇后，若当前行是最后一行，记录一个解；若当前行不是最后一行，当前行设为下一行, 当前列设为当前行的第一个待测位置；若当前行是最后一行，当前列不是最后一列，当前列设为下一列；若当前行是最后一行，当前列是最后一列，回溯，即清空当前行及以下各行的棋盘，然后，当前行设为上一行，当前列设为当前行的下一个待测位置；以上返回到第2步4) 在当前位置上不满足条件的情形：若当前列不是最后一列，当前列设为下一列，返回到第2步;若当前列是最后一列了，回溯，即，若当前行已经是第一行了，算法退出，否则，清空当前行及以下各行的棋盘，然后，当前行设为上一行，当前列设为当前行的下一个待测位置，返回到第2步;算法的基本原理是上面这个样子，但不同的是用的数据结构不同，检查某个位置是否满足条件的方法也不同。
回溯法求解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皇后问题实验报告
n皇后问题实验报告《n皇后问题实验报告》引言n皇后问题是一个经典的数学问题，它要求在一个n×n的棋盘上放置n个皇后，使得它们互相不攻击。
这个问题不仅在数学领域有着重要的意义，而且在计算机算法设计中也有着广泛的应用。
本实验报告将对n皇后问题进行实验研究，并探讨不同算法在解决该问题时的效率和优劣。
实验目的1. 了解n皇后问题的定义和基本解法。
2. 实现并比较不同算法在解决n皇后问题时的效率和优劣。
3. 分析算法在不同规模问题下的表现。
实验方法1. 实现基本的回溯算法解决n皇后问题。
2. 实现改进的算法，如剪枝算法、遗传算法等，并与基本算法进行比较。
3. 使用不同规模的n值进行实验，比较不同算法在不同规模问题下的表现。
实验结果通过实验我们发现，在小规模问题下，基本的回溯算法能够快速求解n皇后问题。
但是随着n的增大，回溯算法的效率急剧下降，甚至在n较大时无法得到解。
而采用改进的算法，如剪枝算法和遗传算法，能够在大规模问题下取得更好的效果，尤其是遗传算法在大规模问题下能够更快速地找到解。
结论通过本次实验，我们了解了n皇后问题的定义和基本解法，同时也发现了在不同规模问题下不同算法的优劣。
在实际应用中，我们可以根据具体情况选择合适的算法来解决n皇后问题，以取得更好的效果。
参考文献1. 陈世杰, 谢东风. (2015). 《遗传算法在n皇后问题求解中的应用》. 计算机工程与应用, 51(14), 157-160.2. 王明宇. (2018). 《剪枝算法在n皇后问题中的应用》. 计算机科学, 45(12), 256-259.。
用回溯算法解n皇后问题实验步骤
湖州师范学院实验报告课程名称：算法实验四：回溯算法一、实验目的1、理解回溯算法的概念，掌握回溯算法的基本要素。
2、掌握设计回溯算法的一般步骤，针对具体问题，能应用回溯算法求解。
二、实验内容1、问题描述1 ）n后问题在n×n格的棋盘上放置彼此不受攻击的n个皇后。
按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。
n后问题等价于在n×n格的棋盘上放置n个皇后，任何2个皇后不放在同一行或同一列或同一斜线上。
2）0-1 背包问题需对容量为 c 的背包进行装载。
从n 个物品中选取装入背包的物品，每件物品i 的重量为wi ，价值为pi 。
对于可行的背包装载，背包中物品的总重量不能超过背包的容量，最佳装载是指所装入的物品价值最高。
每种物品要么放进背包，要么丢弃。
2、数据输入：文件输入或键盘输入。
3、要求：1）完成上述两个问题，时间为2 次课。
2）独立完成实验及实验报告。
三、实验步骤1、理解方法思想和问题要求。
2、采用编程语言实现题目要求。
3、上机输入和调试自己所写的程序。
4、附程序主要代码：1.n后问题：#include<iostream>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) {for (int i = 1; i <= n; i++)cout << x[i] << " ";cout << endl;sum++;}else {for (int i = 1; i <= n; i++) {x[t] = i;if (Place(t)) Backtrack(t + 1);}}}int nQueen(int n) {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;}void main() {int n, set;cout << "请输入皇后个数："; cin >> n;cout << "可行方案所有解：" << endl;set = nQueen(n);cout << "可行方案数：" << set << endl;}2.0-1背包：#include <stdio.h>#include <conio.h>int n;//物品数量double c;//背包容量double v[100];//各个物品的价值double w[100];//各个物品的重量double cw = 0.0;//当前背包重量double cp = 0.0;//当前背包中物品价值double bestp = 0.0;//当前最优价值double perp[100];//单位物品价值排序后int order[100];//物品编号int put[100];//设置是否装入//按单位价值排序void knapsack(){int i,j;int temporder = 0;double temp = 0.0;for(i=1;i<=n;i++)perp[i]=v[i]/w[i];for(i=1;i<=n-1;i++){for(j=i+1;j<=n;j++)if(perp[i]<perp[j]) perp[],order[],sortv[],sortw[] {temp = perp[i];perp[i]=perp[i];perp[j]=temp;temporder=order[i]; order[i]=order[j]; order[j]=temporder; temp = v[i];v[i]=v[j];v[j]=temp;temp=w[i];w[i]=w[j];w[j]=temp;}}}//回溯函数void backtrack(int i){double bound(int i);if(i>n){bestp = cp;return;}if(cw+w[i]<=c){cw+=w[i];cp+=v[i];put[i]=1;backtrack(i+1);cw-=w[i];cp-=v[i];}if(bound(i+1)>bestp)//符合条件搜索右子数 backtrack(i+1);}//计算上界函数double bound(int i){double leftw= c-cw;double b = cp;while(i<=n&&w[i]<=leftw){leftw-=w[i];b+=v[i];i++;}if(i<=n)b+=v[i]/w[i]*leftw;return b;}int main(){int i;printf("请输入物品的数量和容量：");scanf("%d %lf",&n,&c);printf("请输入物品的重量和价值：");for(i=1;i<=n;i++){printf("第%d个物品的重量：",i);scanf("%lf",&w[i]);printf("价值是：");scanf("%lf",&v[i]);order[i]=i;}knapsack();backtrack(1);printf("最有价值为：%lf\n",bestp);printf("需要装入的物品编号是：");for(i=1;i<=n;i++){if(put[i]==1)printf("%d ",order[i]);}return 0;}5、实验结果：四、实验分析1、：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皇后问题
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皇后问题（分析）这道题需要⽤到回溯算法，现在在这⾥先简单的介绍⼀下这个算法：回溯算法也叫试探法，它是⼀种系统地搜索问题的解的⽅法。
回溯算法的基本思想是：从⼀条路往前⾛，能进则进，不能进则退回来，换⼀条路再试。
⽤回溯算法解决问题的⼀般步骤为：1、定义⼀个解空间，它包含问题的解。
2、利⽤适于搜索的⽅法组织解空间。
3、利⽤深度优先法搜索解空间。
4、利⽤限界函数避免移动到不可能产⽣解的⼦空间。
问题的解空间通常是在搜索问题的解的过程中动态产⽣的，这是回溯算法的⼀个重要特性。
⾸先，看⼀个简单的程序;1 #include <stdio.h>2 #include <stdlib.h>34void function(int a)5 {6if (a > 0)7 {8 printf("%d\n", a);9 function(a - 1);10 }11 }1213int main(void)14 {15int a = 3;16 function(3);17 system("PAUSE");18return0;19 }输出：3 2 11 #include <stdio.h>2 #include <stdlib.h>34void function(int a)5 {6if (a > 0)7 {8 function(a - 1);9 printf("%d\n",a);10 }11 }1213int main(void)14 {15int a = 3;16 function(3);17 system("PAUSE");18return0;19 }输出：1 2 3⾸先第⼀个不难理解，第⼆个，⾸先进⾏三次递归，分别是function(2),function(1),function(0)=>a=3,a=2,a=1;当到a=1递归执⾏结束，就会接着往下执⾏，执⾏printf，所以此时输出1，然后，返回到上⼀级递归，function(1),执⾏结束后，再次执⾏printf,输出1...⼋皇后问题：⼋皇后问题，是⼀个古⽼⽽著名的问题，是回溯算法的典型案例。
人工智能--N皇后问题回溯法爬山算法的实现及性能分析
N皇后问题爬山法和回溯法的实现及性能分析云南大学信息学院专业：计算机软件与理论目录一、N皇后问题 (3)1.问题描述 (3)2.数据结构 (3)二、爬山算法 (3)1.爬山算法一般介绍 (3)2. 爬山算法的伪代码 (4)3. 算法评价 (4)三、回溯法 (4)1.回溯法一般介绍 (4)2. 回溯法的伪代码 (4)3. 算法评价 (5)四、算法实现及性能比较 (5)五、两种算法性能分析 (6)六、结论 (7)七、参考文献 (7)附录 (8)一、N皇后问题1.问题描述（1）n皇后问题：在n*n格的国际象棋上摆放n个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，（2）分别用回溯法（递归）、爬山法和GA算法求解n皇后问题。
要求：输入n，并用运行时间比较几种算法在相同规模的问题时的求解效率。
列表给出结果。
2.数据结构1、逻辑结构：用到线性结构包括数组等。
2、存储结构（物理结构）：顺序存储结构。
二、爬山算法1.爬山算法一般介绍爬山法是指从当前的节点开始，和周围的邻居节点的值进行比较。
如果当前节点是最大的，那么返回当前节点，作为最大值(既山峰最高点)；反之就用最高的邻居节点来，替换当前节点，从而实现向山峰的高处攀爬的目的。
如此循环直到达到最高点。
每次都选择是与目标结点启发函数值最小的那个结点，经过迂回前进,最终达到解决问题的总目标。
如果我们把目标函数的几何图形看成一个山峰,那么点的直接移动就像人在爬山,选择方向,逐步向山顶移动。
爬山法需要建立一个描述数据库变化的单极值函数，且使极值对应目标状态；选取使函数值增长最大的那条规则作用于数据库；重复上步，直到没有规则使函数值继续增长。
爬山法是一种局部搜索算法，也属一种启发式方法。
但它一般只能得到局部最优，并且这种解还依赖于起始点的选取。
它是一种解多变量无约束最优化问题的一类方法，通过点的直接移动产生的目标值有所改善的点,经过这样的移动,逐步到达使目标函数最优的点。
回溯法解决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. 引言1.1 概述本文主要讨论的是n皇后问题及其解决方法。
n皇后问题是一个经典的数学问题，旨在找到如何将n个皇后放置在一个nxn的棋盘上，使得所有皇后彼此之间不会互相攻击。
这个问题具有一定难度，但可以通过回溯法和递归实现来有效解决。
1.2 文章结构本文共分为五个部分：引言、n皇后问题、回溯法解决n皇后问题的步骤、递归实现n皇后问题解决方案的详细步骤与算法思路以及结论。
引言部分主要对文章内容进行概述和介绍，并给出本文的结构安排。
1.3 目的本文旨在通过对n皇后问题的深入研究和探讨，介绍回溯法和递归实现在解决该问题中的应用方法。
通过详细说明算法步骤和思路，帮助读者理解如何使用回溯法和递归实现有效地解决n皇后问题，并对两种方法进行评价与讨论。
同时，还展望了可能的未来研究方向，为读者提供更多思考和拓展的空间。
本文旨在为对n皇后问题感兴趣的读者提供有益的参考和指导。
（文章引言部分完）2. n皇后问题:2.1 问题描述:n皇后问题是一个经典的组合问题，其中n表示棋盘上的行数和列数。
在一个nxn的棋盘上，要放置n个皇后，并且要求任意两个皇后之间不得互相攻击（即不能处于同一行、同一列或同一对角线上）。
这是一个相当困难的问题，因为随着n的增大，可能的解法呈指数增长。
2.2 解决方法介绍:为了解决n皇后问题，可以使用回溯法和递归实现的组合算法。
回溯法是一种通过尝试所有可能情况来找到解决方案的方法。
它通过逐步构建解，并在遇到无效解时进行回溯。
而递归是把大规模的问题分解成相似但规模更小的子问题来求解。
2.3 回溯法和递归实现的关系:在解决n皇后问题中，回溯法是主要思想，而递归则用于辅助实现回溯过程。
在每一步尝试放置一个皇后时，会先判断该位置是否与之前已经放置好的皇后冲突。
如果没有冲突，则继续考虑下一个位置，并以递归的方式调用自身。
如果找到一个有效解时，会结束递归并返回结果。
如果所有位置都无法放置皇后，则回溯至上一步进行下一种尝试。
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皇后问题—回溯法
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的棋盘上放置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皇后问题的概率回溯复合算法
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皇后”问题。
如果你动手试试，就一定会发现开头几颗皇后很容易放置，越到后来就越困难。
由于我们的记忆有限，很可能在某个位置放过子后来证明不行取消了，但是以后又重新放上子去试探，这样就会不断地走弯路，花费大量的精力。
因此，必须找到一个简易有效、有条不紊的法则才行。
回溯法的基本思想：对于用回溯法求解的问题，首先要将问题进行适当的转化，得出状态空间树。
这棵树的每条完整路径都代表了一种解的可能。
通过深度优先搜索这棵树，枚举每种可能的解的情况；从而得出结果。
在深度优先搜索的过程中，不断的将每个解（并不一定是完整的，事实上这也就是构造约束函数的意义所在）与约束函数进行对照从而删除一些不可能的解，这样就不必继续把解的剩余部分列出从而节省部分时间。
不妨以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皇后问题是一个经典的数学问题，最早由欧洲的数学家在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。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
ｉ １ ： ：
变换， 而且有以下结论 ：
ｗｉ （＞ ）｛ ＊ ｈｅ ｉ ０ ／ 安置第 ｉ ｌ 行上的皇后 ＊ （ ／ ※※）
Ａ ｉ＋＋； ｌＪ
定理 １ 设 ｘ Ａ １Ａ ２ ．Ａ Ｎ ∈ＳＮ ， ＝Ｂ １Ｂ ２ ． Ｂ Ｎ ∈Ｓ ＝ ［］ ［］． ［ ］ （ ）ｙ ［］ ［］． ［ ］ ・ －
２０ 年 ６ ０５ 期
（） ｎ ｘ ＝ ， Ａ １ ＜『Ｎ＋１／］ ３若 （） ｙ则 ［］ （ ）２当且仅当Ｂ １ ＞『Ｎ ）２ ［］ （ ＋１／］
以上结论比较明显， 限于篇幅所限， 笔者不在此对其进行证明。
（ ※※※）
ｗｉ（ｋ ｈｅ（ ＜＝ｉ １＆ （Ａ ｉ－ ［］ ＊（ ｓＡ ｉ－ ［］一ａｓｉ ｌ 一 ）＆ （ ［］ Ａ ｋ） ａ （ ［ Ａ ｋ） ｂ（ ｂ ］
摘要 ： 文在分析 Ｎ皇后 问题解的结构的基础 上， 化 了利用回溯 法求解 Ｎ皇后 问题 的算法的循环 结束 条件 ， 本 优 借助 于矩 阵改进 了互不攻 击的条件 检测方法 。 避免 了求解复杂的逻辑表 述式， 大大地减少 了比较次数， 使得 算法的运行效率更高。
关 键 词 ： 皇后 问题 ； 不 攻 击 的布 局 ； Ｎ元 互 回溯 算 法
Ｎ个皇后互不攻击的所有布局， 该问题便称为 Ｎ皇后问题， 该问题是计算 局 ＊ ／
机科学领域的有代表性的典型实例之一 ， 为解此问题， 可用一个一维数组 Ａ记录Ｎ皇后问题的一个布局， Ａ ｉ（＝ ，， ） 其中 ［ ｉ １２…， 表示第 ｉ ］ 行上的
皇后所在的列号， 则一个互不攻击的布局必须满足以下两个条件：
／ 将所有皇后放于第０ ＊ 列
ｆ （＝１ｉ Ｎ ｉ ｏ ｉ ；＜＝ ； ＋＋） Ａ ｉ＝ ； ｒ ［ ０ ］
ｆ
［ ］Ａ １Ａ ２…Ａ Ｎ 为 Ｎ Ｎ ｌ ［］ ［３ ［ ］ 元皇后问题的互不攻击的布局｝对任意的ｘ ， ∈
ＳＮ ， Ｘ （ ）将 水平翻转 而得到ｙ记着：＝ （）显然， Ｓ Ｎ 上的一个 ， ｙ Ｈｘ， Ｈ是 （ ）
中图分类号： Ｐ０ ． Ｔ ３ １６
文献标识码 ： Ａ
文章编号 ：６ １ ３ ５２ｏ ）６ ０ ４ ３ １７ —５６ （０ ６ｏ —０６ —０
０ 引 言
ｉ ＋＋；
／ 不攻击 ， ＊ 安置下一行的皇后 ＊ ／
在由Ｎ 个方块排成 Ｎ行 Ｎ ２ 列的正方形棋盘（ 以下简称为： Ｎ元棋盘） 上放置 Ｎ个皇后， 如果某两个皇后位于Ｎ元棋盘上的同一行、 同一列或同
维普资讯
６ ４
第６ 期
Ｎ ． Ｏ６
宜宾学院学报
Ｊ ｒ ｌ ｆ ｉｎＵ ｉ ｒ ｔ ｏｎ Ｙｂ ｎ ｅ ｉ ｕ ａ ０ ｉ ｖ ｓｙ
Ｊｎ ． ０ ｕｅ２ ６ Ｏ
Ｎ皇后 问题 回溯 算法探讨
张 万 军
（ 宜宾卫生学校 ， 四川布局？
Ｉ 算法改进
ＩＩ 循环结束条件 的改进 ．
由上述的描述可知 ， Ｎ皇后问题的每一互不攻击的布局均唯一对应
于 Ｉ２３…、 、，、 Ｎ的一个排列 Ａ １Ａ ２ ．Ａ Ｎ ， Ｓ Ｎ ：｛ ［］ ［］ ・ ［］ ［］ ・ ［ ］设 （ ） Ａ １Ａ ２ ．Ａ ． ．
ｌ
ｉ －Ｎ：
｝ ｓ｛ ［ ＝ ； 一一； ｅｅ Ａ ｉ ０ ｉ ｌ ］ ｝ ｝
（） ［ ≠ ［ （ ｊ １ Ａｉ Ａｊ ｉ ） ］ ］ ≠
（） Ａ ｉ一 ［ ）（— ） ２ （ ［ Ａｊ ／ ｉ ｊ≠±１即 ｌ［ 一 ［ ｌ ｉ ｊ≠ （ ） ］ ］ ， Ａ ｉ Ａ ｊ ～ｌ ｌ ０ ｉ ］ ］ — ≠ｊ 可将上述不等式归结为一个复合不等式： （ ［ 一 ［ ） １［ 一 ［ ｌ ｉ ｊ） Ａｉ Ａ ｊ （Ａ ｉ Ａ ｊ —ｌ— １Ｓ０ （≠ ） ※） ］ ］ ］ ］ ｉｊ （
一
ｉｉ Ｎ ｃ ｔｕ； ＊ ｆ ＜＝ ） ｎｎｅ／ 未安置好 Ｎ行的皇后， （ ｏｉ 继续 ＊ ／ Ｏｔ ｔＡ ； ＊ ｕ ｕ ）／ 找到一个解， ｐ（ 输出 ＊ ／ ＡＮ ＋＋； ＊ ［］ ／ 最后一行的皇后后移一位， 继续找下一互不攻击的布
斜线（ 斜率为± ） 则 １ 上， 称它们在互相攻击。 要求 找出使 Ｎ 元棋盘上的
ｉｋ ｆ ＜＝ｉ ） ｃ ｔｕ； （ 一１ ｏ ｉ ｅ ｎｎ 皇后相互攻击 ＊ ／
收 稿 日期 ：Ｏ ６—０ ２０ ５—０ ８
ｃ ｎ［ ＝ ｏ ｔ ｏ ｔｉ ｃｕ ［ ＋１，＝１ ， Ｎ ｕ ］ ｎ Ｎ—ｉ ］ｉ ， …， ２
作者简介 ： 张万军（９３一） 男， １６ ， 讲师。
维普资讯
这便是 Ｎ皇后问题的数学模型， 通过解上述复合不等式便可求出 Ｎ 皇后问题的所有解， 解该问题的回溯算法见算法一。 算法一： Ｎ皇后问题的回溯算法 求解
ｎｕｅ Ｎ ｛ ｑｅ ｓ（ ） ｎ
上述算法其效率相当低， 文献［］ Ｉ对上述算法作了一些改进， 但当问 题的规模 Ｎ 较大时， 其效率仍然很低， 能否再对其进行改进， 使之能尽快
—
ｋ ）！ ＝ ） ）） ０
ｋ ＋： ＋
定理 ２ 对于Ｎ皇后问题， ｃ ｎ ［ 表示所有互不攻击的布局中以 用 ｏ ｔｉ ｕ ］ ｉ 开头的互不攻击的布局数， 即集合｛ ｌ］ ［Ｂ ［ ］ ［］ ［３ ［ ］ Ａ １Ａ ２…Ａ Ｎ Ａ １Ａ２ …Ａ Ｎ
／＊ ｉ 第 行上的皇后与第 ｋ 行上的 ∈ＳＮ ， Ａ １＝ｉ （ ）且 ［］ ｝ 的基数， ： 则有
（ ）则 Ｎ，
ｉＡ ｉ＜＝Ｎ ｛＊ ｆ ［ （ ］ ）／ 检测第 ｉ 行上的皇后是否与前 ｉ 行上的皇后 一１ 相互攻击 ＊ ／
ｋ ： ＝１
（） １变换 Ｈ无不动点， ｎ ｘ ≠ ； 即 （） ｘ
（）（ ＝ｙ 仅当Ｂｉ＝ — ［ ＋ ， １ ， Ｎ ２ｎｘ ） 当且 ［ Ｎ Ａｉ １ｉ ， …，； ］ ］ ＝ ２