八皇后问题及解答
算法——八皇后问题(eightqueenpuzzle)之回溯法求解
算法——⼋皇后问题(eightqueenpuzzle)之回溯法求解⼋皇后谜题是经典的⼀个问题,其解法⼀共有92种!其定义:1. ⾸先定义⼀个8*8的棋盘2. 我们有⼋个皇后在⼿⾥,⽬的是把⼋个都放在棋盘中3. 位于皇后的⽔平和垂直⽅向的棋格不能有其他皇后4. 位于皇后的斜对⾓线上的棋格不能有其他皇后5. 解出能将⼋个皇后都放在棋盘中的摆法这个问题通常使⽤两种⽅法来求解:1. 穷举法2. 回溯法(递归)本⽂章通过回溯法来求解,回溯法对⽐穷举法⾼效许多,让我们学习如何实现吧!实现思想:1. 我们先在棋盘的第0⾏第1个棋格放下第⼀个皇后2. 下⼀⾏寻找⼀个不冲突的棋格放下下⼀个皇后3. 循环第2步4. 如果到某⼀⾏全部8个格⼦都⽆法放下皇后,回溯到前⼀⾏,继续寻找下⼀个不冲突的棋格5. 把8个皇后都放在棋盘之后,输出或存储摆法,结束实现(Java)算法:定义棋盘我们通过⼀个⼆维整型数组表⽰⼀个棋盘数组内为1是放下了的皇后,0则是空⽩的棋格我们下下⾯定义⼀个⽅法:通过检查棋格是否为1来知道是不是有皇后1// 定义⼀个棋盘2static int chessboard[][] = new int[8][8];检查冲突这个⽅法⽤来检查冲突:在⽔平垂直⽅向、斜⾓上的棋格有⽆其他皇后,传⼊的(x,y)是需要检查的棋格,如检查棋格(1,0)即棋盘的第2⾏第1个,是否能放下皇后。
1// 检查是否符合规则2private static boolean checked(int x,int y){3for(int i = 0;i<y;i++){4// 检查⽔平垂直⽅向5if(chessboard[x][i]==1)return false;6// 检测左斜⾓7if((x-y+i>=0)&&chessboard[x-y+i][i]==1)return false;8// 检查右斜⾓9if((x+y-i<=7)&&chessboard[x+y-i][i]==1)return false;10 }11return true;12 }放下皇后我们在每⼀⾏都执⾏以下步骤,通过从第1个棋格到第8个遍历寻找可以放下皇后的棋格如果放下了皇后,我们就可以继续放下下⼀个了,将⾏数+1,我们递归调⽤这个⽅法1public static boolean solve(int y){2// 将⼀⾏的8种情况都扫描⼀次3for(int i = 0;i<8;i++){4// 每次检测前都将当前⾏清空,避免脏数据5for(int k = 0;k<8;k++)chessboard[k][y]=0;6if(checked(i, y)){7 chessboard[i][y] = 1;8// 当前⼀⾏已经获得解法,进⼊下⼀⾏9 solve(y+1);10 }11 }12return false;13 }算法边界当我们放下了所有8个皇后后,需要⼀个终⽌条件,我们在⾏数y=8时,结束算法同时你可以输出⼀个棋盘摆法了!恭喜你已经把这个经典问题解决了!1// 当y=8时,已经找到⼀种解决⽅法2if(y == 8){3return true;4 }以下是完整的算法1public class EightQueen{2// 定义⼀个棋盘3static int chessboard[][] = new int[8][8];4// 计数器5static int count = 0;67// 解题⽅法8public static boolean solve(int y){9// 当y=8时,已经找到⼀种解决⽅法,计数器加⼀并输⼊摆法10if(y == 8){11 System.out.println("solved!");12 show();13 count++;14return true;15 }16// 将⼀⾏的8种情况都扫描⼀次17for(int i = 0;i<8;i++){18// 每次检测前都将当前⾏清空,避免脏数据19for(int k = 0;k<8;k++)chessboard[k][y]=0;20if(checked(i, y)){21 chessboard[i][y] = 1;22// 当前⼀⾏已经获得解法,进⼊下⼀⾏23 solve(y+1);24 }25 }26return false;27 }28// 检查是否符合规则29private static boolean checked(int x,int y){30for(int i = 0;i<y;i++){31// 检查垂直⽅向32if(chessboard[x][i]==1)return false;33// 检测左斜⾓34if((x-y+i>=0)&&chessboard[x-y+i][i]==1)return false;35// 检查右斜⾓36if((x+y-i<=7)&&chessboard[x+y-i][i]==1)return false;37 }38return true;39 }40// 输出棋盘摆法41public static void show(){42for(int i = 0;i<8;i++){43for(int j = 0;j<8;j++){44 System.out.print(chessboard[j][i]+" ");45 }46 System.out.println("");47 }48 }49 }在执⾏这个算法后:have 92 ways to sovle it!我们获得了92种棋盘摆法!。
八皇后问题
八皇后问题:在国际象棋里面皇后可以横走,竖走,斜走。
我们现在有一个8*8的棋盘,怎样摆放8个皇后,而使彼此不冲突,也就是怎样使在同一行,同一列,斜对角线上只存在一个皇后。
解决办法:回溯法回溯法:回溯法有“通用的解题法”之称。
应用回溯法解问题时,首先应该明确问题的解空间。
一个复杂问题的解决往往由多部分构成,即,一个大的解决方案可以看作是由若干个小的决策组成。
很多时候它们构成一个决策序列。
解决一个问题的所有可能的决策序列构成该问题的解空间。
解空间中满足约束条件的决策序列称为可行解。
一般说来,解任何问题都有一个目标,在约束条件下使目标值达到最大(或最小)的可行解称为该问题的最优解。
在解空间中,前k 项决策已经取定的所有决策序列之集称为k 定子解空间。
0 定子解空间即是该问题的解空间。
C语言代码:#include<stdio.h>int count=0;/*计数*/int fit(int (*Q)[8],int i,int j)/*判断是否适合摆放皇后*/{int t,e;for(t=i,e=0;e<8;e++)if(Q[t][e]==1&&e!=j) return 0;/*pan duan hang*/for(e=j,t=0;t<8;t++)if(Q[t][e]==1&&t!=i) return 0 ;/*pan duan lie*/for(e=j,t=i;e>0&&t>0;e--,t--)/*pan duan left up */if(Q[t][e]==1) return 0;for(e=j,t=i;e<8&&t<8;e++,t++)if(Q[t][e]==1) return 0; /*pan duan right down*/for(e=j,t=i;e<8&&t>0;e++,t--)if(Q[t][e]==1) return 0;/*pan duan right up*/for(e=j,t=i;e>0&&t<8;e--,t++)if(Q[t][e]==1) return 0;/*pan duan left down*/return 1;/*if all the conditions are the wrong ,then we will get 1 ,so the queenfunction will be told to make the Q[i][j]=1.we will put a queen on Q[i][j].*/}void queen(int (*Q)[8],int j)/*求8皇后问题的解*/{ int i,k;if(j==8)/*递归判断,当j=8,说明Q【】【7】中摆放了皇后,所以得到一个解*/{for(i=0;i<8;i++){for(k=0;k<8;k++)printf(" %d",Q[i][k]);/*统计摆放的种类,以及输出结果;*/printf("\n");}printf("\n");count++;return;}for(i=0;i<8;i++){if(fit(Q,i,j)>0)/*在生成解空间树的同时进行深度搜索,从而实现减枝*/{Q[i][j]=1;queen(Q,j+1);Q[i][j]=0;/*进行回溯,因为每次会形成不同的基点,然后沿着各基点进行深度搜索,所以每次搜索完要回到例外基点,所以前面搜索的基点必然要归为零*/}}}main(){int Q[8][8],i,j;for(i=0;i<8;i++)for(j=0;j<8;j++)Q[i][j]=0;queen(Q,0);printf("%d",count);}运行的部分结果:。
八皇后问题(经典算法-回溯法)
⼋皇后问题(经典算法-回溯法)问题描述:⼋皇后问题(eight queens problem)是⼗九世纪著名的数学家⾼斯于1850年提出的。
问题是:在8×8的棋盘上摆放⼋个皇后,使其不能互相攻击。
即任意两个皇后都不能处于同⼀⾏、同⼀列或同⼀斜线上。
可以把⼋皇后问题扩展到n皇后问题,即在n×n的棋盘上摆放n个皇后,使任意两个皇后都不能互相攻击。
思路:使⽤回溯法依次假设皇后的位置,当第⼀个皇后确定后,寻找下⼀⾏的皇后位置,当满⾜左上、右上和正上⽅向⽆皇后,即矩阵中对应位置都为0,则可以确定皇后位置,依次判断下⼀⾏的皇后位置。
当到达第8⾏时,说明⼋个皇后安置完毕。
代码如下:#include<iostream>using namespace std;#define N 8int a[N][N];int count=0;//判断是否可放bool search(int r,int c){int i,j;//左上+正上for(i=r,j=c; i>=0 && j>=0; i--,j--){if(a[i][j] || a[i][c]){return false;}}//右上for(i=r,j=c; i>=0 && j<N; i--,j++){if(a[i][j]){return false;}}return true;}//输出void print(){for(int i=0;i<N;i++){for(int j=0;j<N;j++){cout<<a[i][j]<<" ";}cout<<endl;}}//回溯法查找适合的放法void queen(int r){if(r == 8){count++;cout<<"第"<<count<<"种放法\n";print();cout<<endl;return;}int i;for(i=0; i<N; i++){if(search(r,i)){a[r][i] = 1;queen(r+1);a[r][i] = 0;}}}//⼊⼝int main(){queen(0);cout<<"⼀共有"<<count<<"放法\n"; return 0;}。
八皇后问题详细的解法
若无法放下皇后则回到上一行, 即回溯
当n行的皇后都已确定后,我们 就找到了一种方案
check2 (int a[ ],int n)
queen21(例) 1 b加约束的枚举算法{//i多nt次i; 被调用,只是一重循环
{int a[9]; for (a[1]=1;a[1]<=8;a[1]++) for (a[2]=1;a[2]<=8;a[2]++)
八皇后问题
1
1八皇后问题背景 2盲目的枚举算法 3加约束的枚举算法 4回溯法及基本思想 5 回溯法应用 6八皇后问题的递归回溯算法 7八皇后问题的非递归回溯算法
2
【背景】 八皇后问题是一个以国际象棋为背
景的问题: 如何能够在 8×8 的国际象棋棋盘上
放置八个皇后,使得任何一个皇后都 无法直接吃掉其他的皇后?为了达到 此目的,任两个皇后都不能处于同一 条横行、纵行或斜线上。
for(a[8]=1;a[8]<=8;a[8]++) 此算法可读性很好,
{if (check(a,8)==0)continue; 体现了“回溯”。但
else for(i=1;i<=8;i+nt(a[i]); }
题,而不能解决任意
}}}}}}}
的n皇后问题。
18
2 回溯法应用-算法说明
按什么顺序去搜? 目标是没有漏网之鱼,尽量速度快。
5
2 【问题设计】盲目的枚举算法
a 盲目的枚举算法
通过8重循环模拟搜索空间中的88个状态;
按枚举思想,以DFS的方式,从第1个皇后在第1列开 始搜索,枚举出所有的“解状态”:
从中找出满足约束条件的“答案状态”。
八皇后问题
二.问题分析
• 显然,每一行可以而且必须放一个皇后,所以n皇后问题
的解可以用一个n元向量X=(x1,x2,.....xn)表示,其中, 1≤ i≤ n且1≤ xi≤ n,即第n个皇后放在第i行第xi列上。 由于两个皇后不能放在同一列上,所以,解向量X必须满 足的约束条件为:xi≠ xj; • 若两个皇后的摆放位置分别是(i,xi)和(j,xj),在棋盘 上斜率为-1的斜线上,满足条件i-j=xi-xj;在棋盘上斜率为1 的斜线上,满足条件i+j=xi+xj;
else {
x[k]=0;//重置x[k],回溯 k=k-1;
}
} }
void main() { int n; printf("输入皇后个数n:\n"); scanf("%d",&n); queue(n); }
ห้องสมุดไป่ตู้
• 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;//搜索下一列 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) k=k+1;//放置下一个皇后
八皇后算法分析
八皇后问题是一个古老而著名的问题,是回溯算法的典型例题。
该问题是十九世纪著名的数学家高斯1850年提出:在8X8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法。
高斯认为有76种方案。
1854年在柏林的象棋杂志上不同的作者发表了40种不同的解,后来有人用图论的方法解出92种结果。
现代教学中,把八皇后问题当成一个经典递归算法例题。
——引用自百度百科首先,可归纳问题的条件为,8皇后之间需满足:1.不在同一行上2.不在同一列上3.不在同一斜线上4.不在同一反斜线上这为我们提供一种遍历的思路,我们可以逐行或者逐列来进行可行摆放方案的遍历,每一行(或列)遍历出一个符合条件的位置,接着就到下一行或列遍历下一个棋子的合适位置,这种遍历思路可以保证我们遍历过程中有一个条件是绝对符合的——就是下一个棋子的摆放位置与前面的棋子不在同一行(或列)。
接下来,我们只要判断当前位置是否还符合其他条件,如果符合,就遍历下一行(或列)所有位置,看看是否继续有符合条件的位置,以此类推,如果某一个行(或列)的所有位置都不合适,就返回上一行(或列)继续该行(或列)的其他位置遍历,当我们顺利遍历到最后一行(或列),且有符合条件的位置时,就是一个可行的8皇后摆放方案,累加一次八皇后可行方案的个数,然后继续遍历该行其他位置是否有合适的,如果没有,则返回上一行,遍历该行其他位置,依此下去。
这样一个过程下来,我们就可以得出所有符合条件的8皇后摆放方案了。
这是一个深度优先遍历的过程,同时也是经典的递归思路。
接下来,我们以逐列遍历,具体到代码,进一步说明。
首先,从第一列开始找第一颗棋子的合适位置,我们知道,此时第一列的任何一个位置都是合适的,当棋子找到第一个合适的位置后,就开始到下一列考虑下一个合适的位置,此时,第二列的第一行及第二行显然就不能放第二颗棋子了,因为其与第一个棋子一个同在一行,一个同在一条斜线上。
回溯算法-八皇后
回溯算法一般描述
• 可用回溯法求解的问题P,通常要能表达为:对于已知的 由n元组(x1, x2,…,xn)组成的一个状态空间 E={(x1,x2,…,xn)∣xi∈Si ,i=1,2,…,n},给 定关于n元组中的一个分量的一个约束集D,要求E中满足 D的全部约束条件的所有n元组。其中Si是分量xi的定义域, 且 |Si| 有限,i=1,2,…,n。我们称E中满足D的全部约 束条件的任一n元组为问题P的一个解。 • 解问题P的最朴素的方法就是枚举法,即对E中的所有n元 组逐一地检测其是否满足D的全部约束,若满足,则为问 题P的一个解。但显然,其计算量是相当大的。
• • •
回溯的一般流程
• 在用回溯法求解有关问题的过程中,一般是一边建树,一 边遍历该树。在回溯法中我们一般采用非递归方法。下面, 我们给出回溯法的非递归算法的一般流程:
– 一般要用到栈的数据结构。这时,不仅可以用栈来表示正在遍历 的树的结点,而且可以很方便地表示建立孩子结点和回溯过程。 – 例如在组合问题中,用一个一维数组Stack[ ]表示栈。开始栈空, 则表示了树的根结点。如果元素1进栈,则表示建立并遍历(1) 结点;这时如果元素2进栈,则表示建立并遍历(1,2)结点;元 素3再进栈,则表示建立并遍历(1,2,3)结点。这时可以判断 它满足所有约束条件,是问题的一个解,输出(或保存)。这时 只要栈顶元素(3)出栈,即表示从结点(1,2,3)回溯到结点 (1,2)。
N皇后问题算法思想
• 为使程序在检查皇后配置的合理性方面简易方便,引入以下三个工作数 组: (1) 数组a[ ],a[k]表示第k行上还没有皇后; (2) 数组b[ ],b[k]表示第k列右高左低斜线上没有皇后;(次对角线) (3) 数组 c[ ],c[k]表示第k列左高右低斜线上没有皇后;(主对角线) • 棋盘中同一右高左低斜线上的方格,他们的行号与列号之和相同;同一 左高右低斜线上的方格,他们的行号与列号之差均相同。 • 初始时,所有行和斜线上均没有皇后,从第1列的第1行配置第一个皇后 开始,在第m列col[m]行放置了一个合理的皇后后,准备考察第m+1列时, 在数组a [ ]、b[ ]和c[ ]中为第m列,col[m]行的位置设定有皇后标志;当 从第m列回溯到第m-1列,并准备调整第m-1列的皇后配置时,清除在数 组a[ ]、b[ ]和c[ ]中设置的关于第m-1列,col[m-1]行有皇后的标志。一个 皇后在m列,col[m]行方格内配置是合理的,由数组a[ ]、b[ ]和c[ ]对应位 置的值都为1来确定。
八皇后问题-Read
一.八皇后问题八皇后背景知识国际象棋中皇后威力很大,它可以象“车”一样沿直线上下或左右移动;也可以如同“象”那样沿着斜线移动。
双方的皇后是不能在同一行或同一列或同一斜线上对持的。
那么,在一张空白的国际象棋盘上最多可以放上几个皇后并且不让它们互相攻击呢?这个问题是伟大数学家高斯在十九世纪中期提出来的,并作了部分解答。
高斯在棋盘上放下了八个互不攻击的皇后,他还认为可能有76种不同的放法,这就是有名的“八皇后”问题。
现在我们已经知道八皇后问题有92个解答。
那么你能试着找出几种方法吗?如果你动手试试,就一定会发现开头几颗皇后很容易放置,越到后来就越困难。
由于我们的记忆有限,很可能在某个位置放过子后来证明不行取消了,但是以后又重新放上子去试探,这样就会不断地走弯路,花费大量的精力。
因此,必须找到一个简易有效、有条不紊的法则才行。
1.1分析1.1.1问题描述:八皇后问题是想把八个皇后放在一个棋盘上,并且她们之间不会相互攻击。
按照国家象棋的规则,皇后可以吃掉任何一个和她处在同一行、同一列、或同一斜线(包括两条对角线)上的其他棋子。
如图下所示,皇后所在的行、列及对角线(如图中斜线所示)对其他棋子都是不安全的,而其他地方的棋子则不会受到皇后的威胁。
因此,一个皇后放好以后,它所在的列、行、两条对角线上的地方都不能放其他棋子。
根据这个规则,我们可以利用一个函数来判断某个位置是否安全,安全的位置说明它所在的同一行、同一列或两条线上都没有放置过皇后,因此不会出现皇后互相攻击的情况;否则该位置不安全。
其具体实现过程是找出所有放置的皇后,将他们的位置与该位置进行比较判断。
又注意到同一行只能放一个皇后,因此,只需要对前面的各行逐行扫描皇后,就可以找出所有皇后的位置。
下图是其中一种摆放皇后的方法:1.1.2基本要求:编写实现八皇后问题的非递归解法,输出八皇后问题的中所有摆放皇后的方法,使它可以满足条件。
1.2课程设计目的:深入理解数据结构的基本理论,掌握数据存储结构的设计方法,掌握基于数据结构的各种操作的实现方法,训练对基础知识和基本方法的综合运用能力,增强对算法的理解能力,提高软件设计能力。
八皇后问题的解决方案
算法总结
3
解决八皇后问题常用算法
3.1
枚举法解决八皇后问题
3.2
非递归回溯法解决八皇后问题
3.3
递归回溯法解决八皇后问题
3.0
八皇后问题约束条件
a( i ) 1 2 3 4 5 6 7 8 a( 1) 2 0 -1 3 -2 4 -3 5 -4 6 -5 7 -6 8 -7 9
a( 2 ) a( 3 ) a( 4) a( 5 ) a( 6) a( 7 ) a( 8)
9 3 10 2 11 1 12 0 13 -1 14 -2
9 5 10 4 11 3 12 2 13 1 14 0 15 -1
9 7 10 6 11 5 12 4 13 3 14 2 15 1 16 0
3.0
八皇后问题约束条件
a( i ) =j 第i行j列放置皇后
判断不同列 a(i)≠a(j) 判断不同对角线 i-a(i)≠j-a(j) 判断不同反对角线 i+a(i)≠j+a(j)
取下一个………………
取下一个q (1)
用语言编程
For q1 = 1 To 8 For q2 = 1 To 8 For q3 = 1 To 8 For q4 = 1 To 8 For q5 = 1 To 8 For q6 = 1 To 8 For q7 = 1 To 8 For q8 = 1 To 8 q(q1) = q1 : q(q2) = q2 : q(q3) = q3 : q(q4) = q4 q(q5) = q5 : q(q6) = q6 : q(q7) = q7 : q(q8) = q8 If putdown(q)=1 Then printstr(q) Next q8 Next q7 Next q6 Next q5 Next q4 Next q3 Next q2 Next q1
8皇后问题分析与解法
递归算法——八皇后问题1、背景问题描述八皇后问题是一个古老而著名的问题,该问题的目标是在8×8的国际象棋棋盘上放置八个皇后,使得任意两个皇后都不在同一行,或同一列或同一对角线上。
如图1所示就是八皇后问题的一个解。
图1 八皇后问题的一个解1854年在柏林的象棋杂志上不同的作者发表了40种不同的解。
大数学家高斯认为有76种不同的方案。
后来有人用图论的方法算出92种不同的解。
能否利用程序算出所有满足条件的解的数目呢?2、抽象表示及存储对于这种矩形排列的棋盘而言,用二维数组存储棋盘的状况是最容易想到的方法。
可以设置一个8*8的二维数组,令有棋子的位置为1,无棋子的部分为0。
事实上,由于8个皇后中任意两个皇后都不在同一行,因此8个皇后只能各自占据一行。
不妨认为8个皇后编号为0、1、……、7,它们各自占据棋盘的第1行、第2行、……、第8行。
从而可以使用长度为8一维数组表示棋盘状态,数组元素的下标表示棋子所在行,数组元素的值表示各个棋子所在的列。
使用的存储方式不同,其采用的算法已有很大区别。
3、问题分析及算法设计假定用二维数组A存储棋盘的情况,可以考虑下面两种思路。
思路一:不考虑任何限制的穷举法。
用8×8的二维数组存储棋盘,若在(i,j)处有子,则令A[i][j]=1,否则A[i][j]=0。
于是8个棋子第1个有64种摆放方法,第2个有63种放法,……,第8个有57种放法,则所有摆放方法有64×63×62×…×57种。
可以列举每一种摆法,而后考察每种方法是否符合条件。
这个计算量非常大。
思路二:考虑经过优化的穷举法(二维数组方案)。
若8个棋子位于8行8列的棋盘中,要求任意两个不同行、不同列,则任一解必然是各行、各列只包含一个棋子,其它情况必然不是解。
于是可以做个8重循环,把每个皇后安排在每行的每个位置都试一遍。
算法如下:将整个棋盘数组赋值为0;for(1号皇后从1行1列到1行8列){将1号皇后能控制的线路(横向、竖线、斜线)全部设为1;for(2号皇后从2行1列到2行8列){if(2号皇后控制的线路全部为0){将2号皇后能控制的线路(横向、竖线、斜线)全部设为2;for(3号皇后从3行1列到3行8列){if(3号皇后控制的线路全部为0){将3号皇后能控制的线路全部设为3;……for(8号皇后从8行1列到8行8列){if(8号皇后控制的线路全部为0){将8号皇后能控制的线路全部设为8;记录该棋盘为一个解;}将8号皇后控制的线路全部恢复为0;}……}将3号皇后控制的线路全部恢复为0;}}将2号皇后控制的线路全部恢复为0;}将1号皇后控制的线路全部恢复为0}上述算法中的多重循环虽易于理解,但程序嵌套结构较为复杂,形式死板,不易扩展。
皇后问题详细的解法
for(a[7]=1;a[7]<=8;a[7]++} )
for(a[8]=1;a[8]<=8;a[8]++){
if (check(a,8)=0) continue;
else
for(i=1;i<=8;i++)print(a[i]);
}
10
}
1 回溯法
有“通用的解题法”之称。 回溯法的基本做法是搜索,或是一种组织得井井有条
枚举得有个顺序,否则 轻则有漏的、重复的; 重则无法循环表示。
6
1.按什么顺序去查找所有的解 a.盲目的枚举算法
void main() {
int x[100]; for (x[1]=1;x[1]<=10;x[1]++) for (x[2]=1;x[2]<=10;x[2]++)
for (x[3]=1;x[3]<=10;x[3]++) for (x[4]=1;x[4]<=10;x[4]++) for (x[5]=1;x[5]<=10;x[5]++) for (x[6]=1;x[6]<=10;x[6]++) for (x[7]=1;x[7]<=10;x[7]++) for (x[8]=1;x[8]<=10;x[8]++) if (check(x)==0) { printf(x); }
}
该如何解决冲突的问题呢?
1.行;我们是按照行枚举的,保证了一行一个皇后; 2.列:判断是否存在x[i]=x[j] 3.对角线:主对角线的i-j与从对角线的i+j存在特殊关系,如 图:
八皇后问题
八皇后问题1、问题描述八皇后问题是一个古老而著名的问题,该问题是由十九世纪著名的数学家高斯1850年提出的。
在国际象棋中,皇后是最有权利的一个棋子,只要别的棋子在它的同一行或同一列或同一斜线(正斜线或反斜线)上时,它就能把对方棋子吃掉。
所以高斯提出了一个问题:在8*8格的国际象棋上摆放八个皇后,使其不能相互攻击,即任意两个皇后都不能处于同一列、同一行、同一条斜线上面,问共有多少种解法。
2、设计思路1)解决行、列、斜线的冲突行:当第i行被某个皇后占领后,则同一行上的所有空格都不能再放皇后,还要把以i为下标的位置标记为已占领列:规定每一列放置一个皇后,保证不会造成列上的冲突对角线:对角线有正对角线和反对角线两个方向。
当第i个皇后占领了第j列后,要同时把以(i+j)、(i-j)为下标的位置标记为已占领2)数据结构的实现数组a[i]:a[i]表示第i个皇后放置的列(1<=i<=8)对角线数组:b[j](正对角线),c[j](反对角线),根据程序决定正反对角线是否放入皇后3、数据结构设计int Count=0;/*记录解的序号*/int Site[QUEENS]; /*记录皇后放置在各行的位置*/void Queen(int n);/*递归求解函数*/{ int i;if(n==QUEENS){ Output();return;}}void Output();/*输出一个解法*/{ int i;for(i=0;i<QUEENS;i++)/*依次输出各行上皇后的位置*/}int IsValid(int n); /*判断第n个皇后放后,是否有冲突*/ { int i;for(i=0;i<n;i++) /*将第n个皇后和前面n-1个皇后比较*/ { if(Site[i]==Site[n])/*两个皇后在同一列上,返回0*/return 0;if(abs(Site[i]-Site[n])==(n-i))/*两个皇后在同一对角线上,返回0*/return 0;}return 1; /*没有冲突,返回1*/}4、功能函数设计1)求解函数void Queen(int n):递归放置第n个皇后,判断第n个皇后放上去之后,是否无冲突。
八皇后问题
一、八皇后问题设计程序完成如下要求:在8×8的国际象样棋盘上,放置8个皇后,使得这8个棋子不能互相被对方吃掉。
要求:1)依次输出各种成功的放置方法。
2)最好能画出棋盘的图形形式,并在其上动态地演示试探过程。
1、总思想:显然,棋盘的每一行可以且必须摆放一个皇后,可以用向量(x1,x2,……,xn)表示n皇后问题的解,即第i个皇后摆放在第i行第xi列的位置(1<=i<=n,且1<=xi<=n)。
由于两个皇后不能位于同一列,所以n皇后问题的解向量必须满足约束条件xi!=xj。
可以将n皇后问题的n*n棋盘看成是矩阵,设皇后i和皇后j的摆放位置分别是(i,xi)和(j,xj),则在棋盘上斜率为-1的同一条斜线上,满足条件i-xi=j-xj,在棋盘上斜率为1的同一条斜线上,满足条件i+xi=j+xj,综合上述两种情况,n皇后问题必须满足约束条件|i-j|!=|xi-xj|。
设函数Queue实现任意N皇后问题,皇后k摆放在第k行第x[k]列的位置。
算法的伪代码描述如下:算法:Queue(n)输入:皇后的个数n输出:n皇后问题的解x[n]初始化k=0 ,初始化解向量x[n]={-1} ;(1)重复执行下述操作,摆放皇后k ;①把皇后k摆放在下一列的位置,即x[k]++ ;②如果皇后k摆放在x[k]位置发生冲突,则x[k]++试探下一列,直到不冲突或者x[k]出界;③如果x[k]没出界且所有皇后都摆放完毕,则输出一个解;④如果x[k]没出界但尚有皇后没摆放,则k++,转(1)摆放下一个皇后;⑤如果x[k]出界,则回溯,x[k]=-1,k--,转(1)重新摆放皇后k。
注:本题只考虑八皇后问题。
2、代码:#include<stdio.h>#include<math.h>const int N = 8 ;int x[N] = {-1} ;int Place(int k){for(int i=0 ;i<k ;i++)if(x[i]==x[k]||abs(i-k) == abs(x[i]-x[k]))//违反约束条件return 1 ;return 0 ;}int main(){int k = 0,num = 0 ;while(k >= 0){x[k]++ ;while(x[k]<8 && Place(k) == 1)x[k]++ ;if(x[k]<8 && k == 7){printf("第%d个解是:",++num) ;for(int i =0 ;i<8 ;i++)printf("<%d,%d>\t",i+1,x[i]+1) ;printf("\n") ; }elseif(x[k]<8 && k<7)//上有皇后未摆放k = k+1 ;elsex[k--] = -1 ;//重置x[k],回溯,重新摆放皇后k }return 0 ; }结果:3、各模块功能说明:(1)Place:放置皇后的位置。
数据结构八皇后问题
目录一需求分析 (1)1.1程序的功能: (1)1.2程序的输入输出要求: (1)二概要设计 (3)2.1程序的主要模块: (3)2.2程序涉及: (3)三详细设计 (3)3.1相关代码及算法 (4)3.1.1 定义相关的数据类型如下:....................... 错误!未定义书签。
3.1.2 主模块类C码算法: (4)3.1.3 画棋盘模块类C码算法 (5)3.1.4 画皇后模块类C码算法: (5)3.1.5 八皇后摆法模块(递归法): (6)3.1.6 初始化模块 (7)3.1.7 输出摆放好的八皇后图形(动态演示): (7)3.2相关流程图 (9)四调试分析 (12)五设计体会 (13)六附录 (13)七参考文献 (17)一需求分析1.1 程序功能:八皇后问题是一个古老而著名的问题。
该问题是十九世纪著名的数学家高斯1850年提出的。
八皇后问题要求在一个8*8的棋盘上放上8个皇后,使得每一个皇后既攻击不到另外七个皇后,也不被另外七个皇后所攻击.按照国际象棋的规则,一个皇后可以攻击与之处在同一行或同一列或同一斜线上的其他任何棋子,问有多少种不同的摆法?并找出所有的摆法。
因此,八皇后问题等于要求八个皇后中的任意两个不能被放在同一行或同一列或同一斜线上。
本程序通过对子函数void qu(int i)的调用,将八皇后的问题关键通过数据结构的思想予以了实现。
虽然题目以及演算看起来都比较复杂,繁琐,但在实际中,只要当一只皇后放入棋盘后,在横与列、斜线上没有另外一只皇后与其冲突,再对皇后的定位进行相关的判断。
即可完成。
如果在这个程序中,我们运用的是非递归的思想,那么将大量使用if等语句,并通过不断的判断,去推出答案,而且这种非递归的思想,大大的增加了程序的时间复杂度。
如果我们使用了数据结构中的算法后,那么程序的时间复杂度,以及相关的代码简化都能取得不错的改进。
这个程序,我运用到了数据结构中的栈、数组,以及树和回溯的方法。
八皇后问题(递归+非递归)
八皇后问题(递归+非递归)Xredman posted @ 2009年6月04日 21:15 in 以前博文 , 442 阅读一.问题描述在8×8格的国际象棋棋盘上放置八个皇后,使得任意两个皇后不能互相攻击,即任何行、列或对角线(与水平轴夹角为45°或135°的斜线)上不得有两个或两个以上的皇后。
这样的一个格局称为问题的一个解。
请用递归与非递归两种方法写出求出八皇后问题的算法。
二.解题思路描述一个正确的解应当是每一列,每一行,每一条斜线上均只有一个皇后。
对于递归算法,本人才有模拟的方式进行,而且,我觉得开辟一个二维数组更显而易见。
首先,从空棋盘开始摆放,保证第m行m个皇后互不攻击,然后摆放第m+1个皇后。
当然对于第m+1个皇后可能有多种摆放方法,由此,我必须一一枚举,采用回溯策略是可行且合乎逻辑的。
而对于非递归算法,我只是借助于书本上一个递归改为非递归的框架,依次搭建而已。
在此过程中,我采用一维数组,一位对于八皇后问题,每一行不可能存在二个及二个以上的皇后,board[i]表示第i行棋盘摆放的位置为第board[i]列。
递归方法借助于系统提供的栈,而我非递归算法的实现,仅仅是自己构造一个栈而已。
递归解法#include <iostream>#include <cstdio>#include <sys/timeb.h>using namespace std;const int MAX_SIZE = 100;enum flag {blank ='X',queen = 1};char Chess[MAX_SIZE][MAX_SIZE];//棋盘图int n;//解决n皇后问题int total;//用于计摆放方式void Init(){//对棋牌进行初始化for(int i = 0; i < n; i++)for(int j = 0; j < n; j++)Chess[i][j] = blank;total = 0;//初始时有零中摆放方式}bool Judge(int r,int c){//判断(r,c)位置是否可放置int i,j;for(i = r + 1; i < n; i++)if(Chess[i][c] == queen)return false;//说明c列上已有一皇后for(i = c + 1; i < n; i++)if(Chess[r][i] == queen)return false;//说明r行上已有一皇后for(i = r + 1, j = c + 1; (i < n) && (j < n); i++, j++)if(Chess[i][j] == queen)return false;//45度斜线上已有一皇后for(i = r + 1, j = c - 1; (i <n) && (j >= 0); i++, j--)if(Chess[i][j] == queen)return false;//135度斜线上已有一皇后return true;//排除四种情况后,说明(r,c)点可放置皇后}void Backtrack(int k,int cnt){//回溯算法主程序if(k < 0 || cnt == n)//棋牌摆放完毕 or 以摆满n后{if(cnt == n){printf("No.%d:\n",++total);for(int i = 0; i < n; i++){for(int j = 0; j < n; j++)printf(" %c ",Chess[i][j]);putchar('\n');}putchar('\n');}}else{int r = k / n, c = k % n;if(Judge(r,c)){//可放置一皇后Chess[r][c] = queen;Backtrack(k-1,cnt+1);Chess[r][c] = blank;}Backtrack(k-1,cnt);}}int main(){//此为主函数timeb t1,t2;long kk;cout<<"输入皇后个数:";while(cin>>n){Init();ftime(&t1);Backtrack(n*n-1,0);ftime(&t2);cout<<"计算"<<n<<"后问题总共可有"<<total<<"种摆法!"<<endl;kk = (t2.time-t1.time)*1000 +litm;cout<<"本次回溯耗时:"<<kk<<"毫秒"<<endl;system("PAUSE");cout<<"输入皇后个数:";}return0;}非递归解法#include <iostream>#include <sys/timeb.h>#define N 100using namespace std;int board[N];int n,sum;void init(){for(int i = 1; i <= n; i++)board[i] = 0;}void display(){int i,j;cout<<"No."<<sum<<endl;for(i = 1; i <= n; i++){for(j = 1; j <= n; j++)if(board[i] == j)cout<<"Q ";elsecout<<"X ";cout<<endl;}cout<<endl;}bool canPut(int k){for(int i = 1; i < k; i++)if((abs(k - i) == abs(board[k] - board[i])) || board[i] == board[k])return false;//1.是否在同一斜线;2.是否位于同一列return true;}void Backtrack(){board[1] = 0;int k = 1;while(k > 0){board[k]++;while((board[k] <= n) && !(canPut(k)))board[k] += 1;if(board[k] <= n)if(k == n){sum++;display();}else{k++;board[k] = 0;}elsek--;}}int main(){timeb t1,t2;long kk;cout<<"输入皇后个数:";while(cin>>n){init();sum = 0;ftime(&t1);Backtrack();ftime(&t2);cout<<"总共排列方式为:"<<sum<<endl;kk = (t2.time-t1.time)*1000 + litm; cout<<"本次回溯耗时:"<<kk<<"毫秒"<<endl;system("PAUSE");cout<<"输入皇后个数:";}return0;}。
八皇后问题详细的解法
1
1八皇后问题背景 2盲目的枚举算法 3加约束的枚举算法 4回溯法及基本思想 5 回溯法应用 6八皇后问题的递归回溯算法 7八皇后问题的非递归回溯算法
2
【背景】 八皇后问题是一个以国际象棋为背
景的问题: 如何能够在 8×8 的国际象棋棋盘上
放置八个皇后,使得任何一个皇后都 无法直接吃掉其他的皇后?为了达到 此目的,任两个皇后都不能处于同一 条横行、纵行或斜线上。
}
}
23
20
2 回溯法应用-算法框架-递归算法框架
int a[n]; Queens(int k) { if (k>n) 即表示最后一个皇后摆放完毕,输出结果;
else for(i=下界 ; i<=上界; i++) //枚举K个皇后所有可能的路径 {依次从列顶端开始搜索,一直到列底端,直到找到合适位置,如
果未找到,自动返回上层递归
的,能避免不必要搜索的穷举式搜索法。这种方法适 用于解一些组合数相当大的问题。 回溯法在问题的解空间树中,按深度优先策略,从根 结点出发搜索解空间树。算法搜索至解空间树的任意 一点时,先判断该结点是否包含问题的解。如果肯定 不包含,则跳过对该结点为根的子树的搜索,逐层向 其祖先结点回溯;否则,进入该子树,继续按深度优 先策略搜索。
for(a[8]=1;a[8]<=8;a[8]++) 此算法可读性很好,
{if (check(a,8)==0)continue; 体现了“回溯”。但
else for(i=1;i<=8;i++) 它只能解决八皇后问
print(a[i]); }
题,而不能解决任意
}}}}}}}
八皇后问题
八皇后问题一、问题描述八皇后问题是一个古老而著名的问题,是回溯算法的典型例题。
该问题是十九世纪著名的数学家高斯1850年提出:在8X8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上,问有多少种摆法。
二、问题分析在一个8×8的棋盘里放置8个皇后,要求每个皇后两两之间不相"冲"(在每一横列竖列斜列只有一个皇后)。
1、冲突。
包括行、列、两条对角线:(1)列:规定每一列放一个皇后,不会造成列上的冲突;(2)行:当第I行被某个皇后占领后,则同一行上的所有空格都不能再放皇后,要把以I为下标的标记置为被占领状态;(3)对角线:对角线有两个方向。
在同一对角线上的所有点(设下标为(i,j)),要么(i+j)是常数,要么(i-j)是常数。
因此,当第I个皇后占领了第J列后,要同时把以(i+j)、(i-j)为下标的标记置为被占领状态。
三、基本解决思路八皇后问题主要靠回溯的方法实现, 与迷宫的实现相似, 但又困难了一些. 如迷宫的路径不因为上一步而改变, 八皇后的每一步都受约束于以前的步数, 并且, 迷宫只要找出一条路径就行,但八皇后则有很多的解法.基本思想是从n列开始摆放第n个皇后(因为这样便可以符合每一竖列一个皇后的要求),先测试当前位置(n,m)是否等于0(未被占领):如果是,摆放第n个皇后,并宣布占领(记得要横列竖列斜列一起来哦),接着进行递归;如果不是,测试下一个位置(n,m+1),但是如果当n<=8,m=8时,却发现此时已经无法摆放时,便要进行回溯。
1.回溯算法的实现(1)为解决这个问题,我们把棋盘的横坐标定为i,纵坐标定为j,i和j的取值范围是从1到8。
当某个皇后占了位置(i,j)时,在这个位置的垂直方向、水平方向和斜线方向都不能再放其它皇后了。
用语句实现,可定义如下三个整型数组:a[8],b[15],c[24]。
其中:a[j-1]=1 第j列上无皇后a[j-1]=0 第j列上有皇后b[i+j-2]=1 (i,j)的对角线(左上至右下)无皇后b[i+j-2]=0 (i,j)的对角线(左上至右下)有皇后c[i-j+7]=1 (i,j)的对角线(右上至左下)无皇后c[i-j+7]=0 (i,j)的对角线(右上至左下)有皇后(2)为第i个皇后选择位置的算法如下:for(j=1;j<=8;j++) /*第i个皇后在第j行*/if ((i,j)位置为空))/*即相应的三个数组的对应元素值为1*/{占用位置(i,j)/*置相应的三个数组对应的元素值为0*/if (i<8)为i+1个皇后选择合适的位置;else 输出一个解}2.图形存取在Turbo C语言中,图形的存取可用如下标准函数实现:size=imagesize(x1,y1,x2,y2) ;返回存储区域所需字节数。
八皇后问题详细的解法
2021/5/27
3
八皇后问题
要在8*8的国际象棋棋盘中放8个皇后,使任意两个皇 后都不能互相吃掉。规则:皇后能吃掉同一行、同一 列、同一对角线的任意棋子。求所有的解。
八皇后的两组解
18
2 回溯法应用-算法说明
八皇后问题中的核心代码: 遍历过程函数; check函数。
解决此类问题的核心内容: 解空间树的搜索算法; 估值/判断函数:判断哪些状态适合继续扩展,或者作 为答案状态。
2021/5/27
19
2 回溯法应用-n皇后问题
介绍过的方法: c递归回溯算法; d非递归回溯算法;
}
2021/5/27
7
该如何解决冲突的问题呢?
1.行;我们是按照行枚举的,保证了一行一个皇后; 2.列:判断是否存在x[i]=x[j] 3.对角线:主对角线的i-j与从对角线的i+j存在特殊关系,如 图:
2021/5/27
8
盲目的枚举算法
约束条件? 不在同一列:xi≠xj; 不在同一主对角线上:xi-i ≠ xj-j; 不在同一负对角线上:xi+i ≠ xj+j。
八皇后问题
2021/5/27
1
1八皇后问题背景 2盲目的枚举算法 3加约束的枚举算法 4回溯法及基本思想 5 回溯法应用 6八皇后问题的递归回溯算法 7八皇后问题的非递归回溯算法
2021/5/27
2
【背景】 八皇后问题是一个以国际象棋为背
景的问题: 如何能够在 8×8 的国际象棋棋盘上
果未找到,自动返回上层递归
a[k]=i; if (check(a,k)) //满足限界函数和约束条件,不冲突 //递归摆放下一个皇后Queens (k+ 1);} } }
1213:八皇后问题
1213:⼋皇后问题⾸先可以试图去简化问题,将问题转化为为每⼀列确定⼀个有效的⾏号。
因为同⼀列只能有⼀个皇后,并且需要在⼋列中确定⼋个皇后,即每⼀列都必定有且只有⼀个皇后。
经过简化后,显然,通过⼀个⼀维数组即可以确定⼀组有效解。
关于check:不为同⼀⾏或同⼀列的判定⽐较简单(这⾥省略)(i1,j1)与(i2,j2)在同⼀条斜线上的判定:i1-i2==j1-j2 || i1-i2==j2-j1问题经过这样⼀次抽丝剥茧后,剩余的思路⼤致就是深度搜索、临界输出。
特别重复:a[j]表⽰第j列的皇后所在的⾏数1 #include<iostream>2 #include<cstdio>3using namespace std;45const int N=10;6int ans,a[N];7void print(){8 printf("No. %d\n",++ans);9for(int i=1;i<=8;i++){10for(int j=1;j<=8;j++)11if(a[j]==i)printf("1 ");12else printf("0 ");13 printf("\n");14 }15 }16bool check(int x,int d){17for(int i=1;i<d;i++){18if(a[i]==x||x-a[i]==d-i||x-a[i]==i-d)19return0;20 }21return1;22 }23void solve(int d){24if(d==9){25 print();26return;27 }28for(int i=1;i<=8;i++){29if(check(i,d)){30 a[d]=i;31 solve(d+1);32 }33 }34 }35int main(){36 solve(1);37return0;38 }。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
*(queenArray+countSum+1)=0;}else{
*(queenArray+countSum--)=0;
if(*(queenArray+countSum)<queenSum) ++*(queenArray+countSum);
placequeen
(0);
System.out.println("\n\n\n八皇后共有"+oktimes+"个解法made by yifi 2003");}
publicstaticvoidplacequeen(intnum){//num为现在要放置的行数inti=0;
booleanqsave[]=newboolean[QueenMax];
++*(queenArray+countSum);}continue;}}
else {
++*(queenArray+countSum);
continue;}}
queenPosition++;
for(printCount=1;printCount<=queenSum;printCount++)
printf("%3d%",*(queenArray+printCount));
posArray2[deep] = j;
deep++;
FindQuePos(posArray2,queen_num,deep);
deep--;
free(posArray2);}}}}
int main(int argc,char **argv){int *posArray;
if(argc < 2)
FindQuePos(posArray,8,0);
for(;i<QueenMax;i++)qsave[i]=true;
//下面先把安全位数组完成
i=0;//i是现在要检查的数组值
while(i<num){
qsave[chess[i]]=false;
intk=num-i;
if((chess[i]+k>=0)&&(chess[i]+k<QueenMax))qsave[chess[i]+k]=false;
if((chess[i]-k>=0)&&(chess[i]-k<QueenMax))qsave[chess[i]-k]=false;
i++;}//下面历遍安全位
for(i=0;i<QueenMax;i++){
if(qsave[i]==false)continue;
if(num<QueenMax-1){
d=y-i;
//检查新皇后是否与以前的皇后能相互攻击
if((j==x)||(j==x-d)||(j==x+d))
break;}if(i>=y)
break;//不攻击}if(x==SIZE)//没有合适的位置{if(0==y){//回朔到了第一行
Console.WriteLine("Done");
break;//结束}//回朔
#include "stdio.h"
int attacked(int *array,int position){
int flag=-1;
float step;
if(position==1) return flag;
for(step=
1.00;step<position;step++){
if(*(array+(int)step)==*(array+position)||step==position) return
1;
if(((*(array+(int)step)-*(array+position))/(step-position))==1||((*
(array+(int)step)-*(array+position))/(step-position))==-1){
flag=1;
break;}}
return flag;}void main(void){
static final int QueenMax = 8;
static int oktimes = 0;
static int chess[] = new int[QueenMax];//每一个Queen的放置位置
public static void main(String args[]){
for (int i=0;i<QueenMax;i++)chess[i]=-1;
Stringrow="第"+(i+1)+"行:
";
if(chess[i]==0);
else
for(intj=0;j<chess[i];j++)row+="--";
ቤተ መጻሕፍቲ ባይዱrow+="++";
intj=chess[i];
while(j<QueenMax-1){row+="--";j++;}
System.out.println(row);}}}//历遍完成就停止}}
else
FindQuePos(posArray,atoi(argv[1]),0);
printf("Have %d cases !\n",NUM);}//8 Queen递归算法
//如果有一个Q为chess[i]=j;
//则不安全的地方是k行j位置,j+k-i位置,j-k+i位置
class Queen8{
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){
printf("the %d queen's sum is %d\n",queenSum,queenPosition);}--
谁能告诉我!!现在完成一件耗日持久的事后,不再象以前有轻松的感觉??
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int NUM = 0;
void FindQuePos(int *posArray, int queen_num,int deep){int i;
if(deep == queen_num){for(i = 0;i < queen_num;i++)
printf("(%d,%d) ",i+1,posArray[i]+1);
++*(queenArray+(++countSum));}else{
if(attacked(queenArray,countSum)==1){
if(*(queenArray+countSum)>=queenSum){
if(*(queenArray+countSum-1)<queenSum){
++*(queenArray+(--countSum));
chess[num]=i;
placequeen(num+1);}else{//numislastone
chess[num]=i;
oktimes++;
System.out.println("这是第"+oktimes+"个解法如下:
");
System.out.println("第n行:");
for(i=0;i<QueenMax;i++){
if(Queen[i]==j)
Console.Write('Q');
else
Console.Write('.');
Console.WriteLine();}y=SIZE-1;//回朔}}}}}八皇后有解92个。
else{
if(countSum==1&&*(queenArray+countSum)==queenSum) break;
*(queenArray+countSum--)=0;
++*(queenArray+countSum);}}}else
++*(queenArray+countSum);}else
if(printCount>=queenSum) printf("\n");
if(*(queenArray+countSum)>=queenSum){
++*(queenArray+(--countSum)); //the "++" priority is different