八皇后问题及解答
算法——八皇后问题（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课程设计目的：深入理解数据结构的基本理论，掌握数据存储结构的设计方法，掌握基于数据结构的各种操作的实现方法，训练对基础知识和基本方法的综合运用能力，增强对算法的理解能力，提高软件设计能力。
- 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