您的位置: 首页  >  文章  >  n皇后解法

n皇后解法

分类: 文章 • 2025-02-22 17:14:28

N皇后问题是一个经典的问题，在一个N*N的棋盘上放置N个皇后，每行一个并使其不能互相攻击（同一行、同一列、同一斜线上的皇后都会自动攻击）。

n皇后问题不算是陈词滥调，也是老生常谈了，作为回溯的经典案例，有递归和非递归两种实现方式，同时，除了回溯算法，最近我在网上查了下看到还可以用位运算来解决这个问题。本次趁着本学期算法课程的期末要求，我将对两种算法的实验效果进行分析。

一、使用回溯解决n皇后问题

首先，我们来看一下回溯算法的基本思想：从一条路往前走，能进则进，不能进则退回来，换一条路再试。正如前所述，使用回溯算法解决n皇后问题分为递归和非递归两种形式。本文都将进行分析。

1.1 使用递归的回溯法解决

下面是用递归的回溯法求解n皇后问题的算法描述，这里用一个N*N的矩阵来存储棋盘：

1) 算法开始, 清空棋盘，当前行设为第一行，当前列设为第一列

2) 在当前行，当前列的位置上判断是否满足条件(即保证经过这一点的行,列与斜线上都没有两个皇后)，若不满足，跳到第4步

3) 在当前位置上满足条件的情形：

在当前位置放一个皇后，若当前行是最后一行，记录一个解；

若当前行不是最后一行，当前行设为下一行, 当前列设为当前行的第一个待测位置；

若当前行是最后一行，当前列不是最后一列，当前列设为下一列；

若当前行是最后一行，当前列是最后一列，回溯，即清空当前行及以下各行的棋盘，然后，当前行设为上一行，当前列设为当前行的下一个待测位置；

以上返回到第2步

4) 在当前位置上不满足条件的情形：

若当前列不是最后一列，当前列设为下一列，返回到第2步；

若当前列是最后一列了，回溯，即，若当前行已经是第一行了，算法退出，否则，清空当前行及以下各行的棋盘，然后，当前行设为上一行，当前列设为当前行的下一个待测位置，返回到第2步;

算法的基本原理是上面这个样子，但不同的是用的数据结构不同，检查某个位置是否满足条件的方法也不同。为了提高效率，有各种优化策略，如多线程，多分配内存表示棋盘等。

在具体解决该问题时，可以将其拆分为几个小问题。首先就是在棋盘上如何判断两个皇后是否能够相互攻击，在最初接触这个问题时，首先想到的方法就是把棋盘存储为一个二维数组，然后在需要在第i行第j列放置皇后时，根据问题的描述，首先判断是在第i行是否有皇后，由于每行只有一个皇后，这个判断也可以省略，然后判断第j列是否有皇后，这个也很简单，最后需要判断在同一斜线上是否有皇后，按照该方法需要判断两次，正对角线方向和负对角线方向，总体来说也不难。但是写完之后，总感觉很笨，因为在N皇后问题中这个函数的使用次数太多了，而这样做效率较差，个人感觉很不爽。上网查看了别人的实现之后大吃一惊，大牛们都是使用一个一维数组来存储棋盘，在某个位置上是否有皇后可以相互攻击的判断也很简单。具体细节如下：

把棋盘存储为一个N维数组a[N]，数组中第i个元素的值代表第i行的皇后位置，这样便可以把问题的空间规模压缩为一维O(N)，在判断是否冲突时也很简单，首先每行只有一个皇后，且在数组中只占据一个元素的位置，行冲突就不存在了，其次是列冲突，判断一下是否有a[i]与当前要放置皇后的列j相等即可。至于斜线冲突，通过观察可以发现所有在斜线上冲突的皇后的位置都有规律即它们所在的行列互减的绝对值相等，即| row – i | = | col – a[i] | 。这样某个位置是否可以放置皇后的问题已经解决。

下面要解决的是使用何种方法来找到所有的N皇后的解。上面说过该问题是回溯法的经典应用，所以可以使用回溯法来解决该问题，具体实现也有两个途径，递归和非递归。递归方法较为简单，大致思想如下：

[cpp] view plain copy
  1. void queen(int row) {  
  2. if (n == row)      //如果已经找到结果，则打印结果  
  3.  print_result();  
  4. else {  
  5.    for (k=0 to N) { //试探第row行每一个列  
  6.      if (can_place(row,k) {  
  7.          place(row,k);   //放置皇后  
  8.          queen(row+ 1);  //继续探测下一行  
  9.                         }  
  10.         }  
  11. }  
  12. }  


  该方法由于在探测第i行后，如果找到一个可以放置皇后的位置j后，则会递归探测下一行，结束后则会继续探测i行j+1列，故可以找到所有的N皇后的解。完整的代码如下：

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <time.h>  
  4. const int N=20;   //最多放皇后的个数  
  5. int q[N];         //各皇后所在的行号  
  6. int cont = 0;     //统计解得个数  
  7. //输出一个解  
  8. void print(int n)  
  9. {  
  10.   int i,j;  
  11.   cont++;  
  12.   printf("第%d个解：",cont);  
  13.   for(i=1;i<=n;i++)  
  14.          printf("(%d,%d)",i,q[i]);  
  15.   printf("\n");  
  16.   for(i=1;i<=n;i++)        //行  
  17.   {                 
  18.          for(j=1;j<=n;j++)   //列  
  19.          {  
  20.                 if(q[i]!=j)  
  21.                        printf("x");  
  22.                 else  
  23.                        printf("Q");    
  24.          }  
  25.          printf("\n");  
  26.   }  
  27. }  
  28. //检验第i行的k列上是否可以摆放皇后  
  29. int find(int i,int k)   
  30. {  
  31.   int j=1;  
  32.   while(j<i)  //j=1~i-1是已经放置了皇后的行  
  33.   {  
  34.          //第j行的皇后是否在k列或(j,q[j])与(i,k)是否在斜线上  
  35.          if(q[j]==k ||abs(j-i)==abs(q[j]-k))  
  36.                 return0;  
  37.          j++;  
  38.   }  
  39.   return 1;  
  40. }  
  41. //放置皇后到棋盘上  
  42. void place(int k,int n)   
  43. {  
  44.   int j;  
  45.   if(k>n)  
  46.          print(n);  
  47.   else  
  48.   {  
  49.          for(j=1;j<=n;j++)   //试探第k行的每一个列  
  50.          {  
  51.                 if(find(k,j))  
  52.                 {  
  53.              q[k] = j;  
  54.                 place(k+1,n);  //递归总是在成功完成了上次的任务的时候才做下一个任务  
  55.                 }  
  56.          }  
  57.   }  
  58. }  
  59.    
  60. int main(void)  
  61. {  
  62.  clock_t start,finish;  
  63.   int n;  
  64.   printf("请输入皇后个数：");  
  65.   scanf("%d",&n);  
  66.   start = clock();  
  67.   printf("\n使用非递归回溯法解决 %d 皇后问题时的运行情况\n",n);      
  68.   place(1,n);  
  69.   finish = clock();  
  70.   printf("共有 %d 种不同的排列 计算用时%.2fms \n",count, (double) (finish - start));  
  71.   system("pause");  
  72.   return 0;  
  73. }  


二、使用非递归的回溯法解决n皇后问题

   非递归方法的一个重要问题时何时回溯及如何回溯的问题。程序首先对N行中的每一行进行探测，寻找该行中可以放置皇后的位置，具体方法是对该行的每一列进行探测，看是否可以放置皇后，如果可以，则在该列放置一个皇后，然后继续探测下一行的皇后位置。如果已经探测完所有的列都没有找到可以放置皇后的列，此时就应该回溯，把上一行皇后的位置往后移一列，如果上一行皇后移动后也找不到位置，则继续回溯直至某一行找到皇后的位置或回溯到第一行，如果第一行皇后也无法找到可以放置皇后的位置，则说明已经找到所有的解程序终止。如果该行已经是最后一行，则探测完该行后，如果找到放置皇后的位置，则说明找到一个结果，打印出来。但是此时并不能再此处结束程序，因为我们要找的是所有N皇后问题所有的解，此时应该清除该行的皇后，从当前放置皇后列数的下一列继续探测。

完整的代码如下：

[cpp] view plain copy
  1. #include "iostream"  
  2. #include "cmath"  
  3. using namespace std;  
  4. #define Max 20      //定义棋盘的最大值  
  5. int a[Max];  
  6. int show(int S)    //定义输出函数  
  7. {  
  8.   int i,p,q;  
  9.   intb[Max][Max]={0};     //定义并初始化b[][]输出数组  
  10.   for(i=1;i<=S;i++)    //按横列i顺序输出a[i]数组坐标  
  11.   {  
  12.          b[i][a[i]]=1;  
  13.          printf("(%d,%d)\t",i,a[i]);  
  14.   }  
  15.   printf("\n");  
  16.   for(p=1;p<=S;p++)     //按棋盘的横列p顺序标明皇后的位置  
  17.   {  
  18.          for(q=1;q<=S;q++)  
  19.          {  
  20.                 if(b[p][q]==1)     //在第p行第q列放置一个皇后棋子  
  21.                        printf("●");  
  22.                 else  
  23.                        printf("○");  
  24.          }  
  25.          printf("\n");  
  26.   }  
  27.   return 0;  
  28. }  
  29.    
  30. int check(int k)    //定义check函数  
  31. {  
  32.   int i;  
  33.   for(i=1;i<k;i++)    //将第k行与前面的第1~~k-1行进行判断  
  34.   {  
  35. if((a[i]==a[k]) || (a[i]-a[k]==k-i) || (a[i]-a[k]==i-k)) //检查是否有多个皇后在同一条直线上  
  36.          {  
  37.                 return0;  
  38.          }  
  39.   }  
  40.   return 1;  
  41. }  
  42.    
  43. void check_m(int num)   //定义函数  
  44. {  
  45.   int k=1,count=0;  
  46.   printf("Thepossible configuration of N queens are:\n");  
  47.   a[k]=1;  
  48.   while(k>0)  
  49.   {  
  50.     if(k<=num && a[k]<=num)//从第k行第一列的位置开始，为后续棋子选择合适位子  
  51.          {  
  52.                 if(check(k)==0)    //第k行的a[k]列不能放置皇后  
  53.                 {  
  54.                        a[k]++;        //继续探测当前行的下一列：a[k]+1  
  55.                 }  
  56.                 else  
  57.                 {  
  58.                        k++;        //第K行的位置已经确定了，继续寻找第k+1行皇后的位置  
  59.                        a[k]=1;      //从第一列开始查找  
  60.                 }  
  61.          }  
  62.          else  
  63.          {  
  64.                 if(k>num)     //若满足输出数组的要求则输出该数组  
  65.                 {  
  66.                        count++;  
  67.                        printf("[%d]:  ",count);  
  68.                        show(num);    //调用输出函数show()  
  69.                 }  
  70.                 //如果k>num会执行下面两行代码，因为虽然找到了N皇后问题的一个解，但是要找的是所有解，需要回溯，从当前放置皇后的下一列继续探测  
  71.                 //如果a[k]>num也会执行下面两行代码，就是说在当前行没有找到可以放置皇后的位置，于是回溯，从上一行皇后位置的下一列继续探测  
  72.                 k--;      //棋子位置不符合要求，则退回前一步  
  73.                 a[k]++;   //继续试探下一列位置  
  74.          }  
  75.   }  
  76.   printf("The countis: %d \n",count);  
  77. }  
  78.    
  79. int main(void)  
  80. {  
  81.   clock_t start,finish;  
  82.   int n;  
  83.   printf("请输入皇后个数：");  
  84.   scanf("%d",&n);  
  85.   start = clock();  
  86.   printf("\n使用非递归回溯法解决 %d 皇后问题时的运行情况\n",n);   
  87.   check_m(n);  
  88.   finish = clock();  
  89.   printf(" 计算时间%.2fms \n", (double) (finish - start));  
  90.   system("pause");  
  91.   return 0;  
  92. }  


 

三、 使用位运算求解n皇后问题

  核心代码如下：

[cpp] view plain copy
  1. void test(int row, int ld, int rd)  
  2. {  
  3.          intpos, p;  
  4.          if( row != upperlim )  
  5.          {  
  6.                    pos= upperlim & (~(row | ld | rd ));  
  7.                    while( pos )  
  8.                    {  
  9.                             p= pos & (~pos + 1);  
  10.                             pos= pos - p;  
  11.                             test(row| p, (ld | p) << 1, (rd | p) >> 1);  
  12.                    }  
  13.          }  
  14.          else  
  15.                    ++Ans;  
  16. }  


初始化：　upperlim =  (1 << n)-1;Ans = 0;

调用参数：test(0, 0, 0);

和普通算法一样，这是一个递归函数，程序一行一行地寻找可以放皇后的地方。函数带三个参数row、ld和rd，分别表示在纵列和两个对角线方向的限制条件下这一行的哪些地方不能放。位于该行上的冲突位置就用row、ld和rd中的1来表示。把它们三个并起来，得到该行所有的禁位，取反后就得到所有可以放的位置（用pos来表示）。

p = pos &(~pos + 1)其结果是取出最右边的那个1。这样，p就表示该行的某个可以放子的位置，把它从pos中移除并递归调用test过程。

   注意递归调用时三个参数的变化，每个参数都加上了一个禁位，但两个对角线方向的禁位对下一行的影响需要平移一位。最后，如果递归到某个时候发现row=upperlim了，说明n个皇后全放进去了，找到的解的个数加一。

n皇后解法

n皇后解法

注：

    upperlime：=（1 << n）-1 就生成了n个1组成的二进制数。

     这个程序是从上向下搜索的。

    pos & -pos 的意思就是取最右边的 1 再组成二进制数，相当于 pos &（~pos +1），因为取反以后刚好所有数都是相反的（怎么听着像废话），再加1 ，就是改变最低位，如果低位的几个数都是1，加的这个 1 就会进上去，一直进到 0 ，在做与运算就和原数对应的 1 重合了。举例可以说明：

       原数 0 0 0 0 1 0 0 0    原数 0 1 0 1 00 1 1

       取反 1 1 1 1 0 1 1 1    取反 1 0 1 0 11 0 0

       加1    1 1 1 1 1 0 0 0    加1  1 0 1 0 1 1 0 1

与运算    0 0 0 0 1 0 0 0  and  00 0 0 0 0 0 1   其中，这个取反再加 1 就是补码，and 运算与负数，就是按位和补码与运算。

(ld | p)<< 1 是因为由ld造成的占位在下一行要右移一下；

   (rd| p)>> 1 是因为由rd造成的占位在下一行要左移一下。

   ld rd row 还要和upperlime 与运算一下，这样做的结果就是从最低位数起取n个数为有效位置，原因是在上一次的运算中ld发生了右移，如果不and的话，就会误把n以外的位置当做有效位。

    在进行到某一层的搜索时，pos中存储了所有的可放位置，为了求出所有解，必须遍历所有可放的位置，而每走过一个点必须要删掉它，否则就成死循环了。

    这个是目前公认N皇后的最高效算法。

完整的代码如下：

[cpp] view plain copy
  1. #include "iostream"  
  2. using namespace std;  
  3. #include "time.h"  
  4. // sum用来记录皇后放置成功的不同布局数；upperlim用来标记所有列都已经放置好了皇后。  
  5. long sum = 0, upperlim = 1;      
  6. // 试探算法从最右边的列开始。  
  7. void test(long row, long ld, long rd)  
  8. {  
  9.          if(row != upperlim)  
  10.          {  
  11.                    //row，ld，rd进行“或”运算，求得所有可以放置皇后的列,对应位为0，  
  12. // 然后再取反后“与”上全1的数，来求得当前所有可以放置皇后的位置，对应列改为1  
  13.                    //也就是求取当前哪些列可以放置皇后  
  14.                    longpos = upperlim & ~(row | ld | rd);  
  15.                    while(pos)    // 0 -- 皇后没有地方可放，回溯  
  16.                    {  
  17.                             //拷贝pos最右边为1的bit，其余bit置0  
  18.                             //也就是取得可以放皇后的最右边的列  
  19.                             longp = pos & -pos;                                                
  20.                             //将pos最右边为1的bit清零  
  21.                             //也就是为获取下一次的最右可用列使用做准备，  
  22.                             //程序将来会回溯到这个位置继续试探  
  23.                             pos-= p;                            
  24.                             //row + p，将当前列置1，表示记录这次皇后放置的列。  
  25.                             //(ld + p) << 1，标记当前皇后左边相邻的列不允许下一个皇后放置。  
  26.                             //(ld + p) >> 1，标记当前皇后右边相邻的列不允许下一个皇后放置。  
  27.                             //此处的移位操作实际上是记录对角线上的限制，只是因为问题都化归  
  28.                             //到一行网格上来解决，所以表示为列的限制就可以了。显然，随着移位  
  29.                    //在每次选择列之前进行，原来N×N网格中某个已放置的皇后针对其对角线  
  30.                             //上产生的限制都被记录下来了  
  31.                             test(row+ p, (ld + p) << 1, (rd + p) >> 1);                               
  32.                    }  
  33.          }  
  34.          else    
  35.          {  
  36.                    //row的所有位都为1，即找到了一个成功的布局，回溯  
  37.                    sum++;  
  38.          }  
  39. }  
  40.    
  41. int main(int argc, char *argv[])  
  42. {  
  43.          clock_tstart,finish;  
  44.          intn;  
  45.          printf("请输入皇后个数：");  
  46.          scanf("%d",&n);  
  47.          start= clock();  
  48.          printf("\n使用位运算 %d 皇后问题的运行情况\n",n);  
  49.      test(0, 0, 0);  
  50.          finish= clock();  
  51.          printf("共有%ld种排列, 计算时间%.2fms\n", sum, (double) (finish - start));  
  52.          system("pause");  
  53.          return0;  
  54. }  


    上述代码还是比较容易理解的，但我觉得核心的是在针对试探－回溯算法所用的数据结构的设计上。程序采用了递归，也就是借用了编译系统提供的自动回溯功能。

    算法的核心：使用bit数组来代替以前由int或者bool数组来存储当前格子被占用或者说可用信息，从这可以看出N个皇后对应需要N位表示。

    巧妙之处在于：以前我们需要在一个N*N正方形的网格中挪动皇后来进行试探回溯，每走一步都要观察和记录一个格子前后左右对角线上格子的信息；采用bit位进行信息存储的话，就可以只在一行格子也就是（1行×N列）个格子中进行试探回溯即可，对角线上的限制被化归为列上的限制。

    程序中主要需要下面三个bit数组，每位对应网格的一列，在C中就是取一个整形数的某部分连续位即可。 row用来记录当前哪些列上的位置不可用，也就是哪些列被皇后占用，对应为1。ld，rd同样也是记录当前哪些列位置不可用，但是不表示被皇后占用，而是表示会被已有皇后在对角线上吃掉的位置。这三个位数组进行“或”操作后就是表示当前还有哪些位置可以放置新的皇后，对应0的位置可放新的皇后。如下图所示的8皇后问题求解得第一步：

              row:          [ ][ ][ ][ ][ ][ ][ ][*]

              ld:             [ ][ ][ ][ ][ ][ ][*][ ]

             rd:             [ ][ ][ ][ ][ ][ ][ ][ ]

             --------------------------------------

           row|ld|rd:    [ ][ ][ ][ ][ ][][*][*]

   所有下一个位置的试探过程都是通过位操作来实现的，这是借用了C语言的好处辅来实现的。

关于此算法，如果考虑N×N棋盘的对称性，对于大N来说仍能较大地提升效率！

位操作－－对优化算法有了个新的认识

该算法的巧妙之处我认为有２个：

   １、以前都是用数组来描述状态，而这算法采用是的位来描述，运算速度可以大大提升，以后写程序对于描述状态的变量大家可以借鉴这个例子，会让你的程序跑得更快。　　　　　　　　　　　　　　　　　　　　　　　　

   ２、描述每行可放置的位置都是只用row,ld,rd这３个变量来描述，这样使得程序看起来挺简洁的。

关于n皇后问题不同算法的效果分析：

三种算法的运行结果如下（以10皇后问题为例），为了能准确分析三种算法的效率，每一种排列情况就不打印出来了：

（1）      使用递归的回溯法时的运行情况

n皇后解法n皇后解法

（2）      使用非递归的回溯法时的运行情况

n皇后解法n皇后解法

（3）      使用位运算时的运行情况

n皇后解法n皇后解法

  由以上的运行结果可以看到，用位运算计算n皇后问题最快，其次是非递归的回溯法，处理得最慢的是递归的回溯法。


四、利用索引

  数据结构里面有个比较著名的八皇后问题，其解决方式倒有很多种，而搜索树又算是一个人工智能方面的入门的思想和手段了。下面就说下如何用搜索树来解决N皇后问题

以四皇后问题为例,如图：

 

 

n皇后解法
在第零层，只有一个根节点

在第一层，有四个节点符合符合条件，故根节点有四个子节点

在第二层，各个子节点又具有不同的节点，所以，这棵树继续往下生长，直至长到第4层，也就是说找到了解，那么第四层的节点就是这个四皇后问题的解了。（注意，这里可以采用深度优先搜索与广度优先搜索，各有利弊）

同样的理论和方法，利用这个搜索树可以实现寻找出所有形式的皇后问题的解，下面就附上C++的源代码

 

Cpp代码  n皇后解法
  1. #include <list>  
  2. #include <iostream>  
  3.   
  4. const int SIZE = 8; //这个是皇后问题的个数  
  5. const char Queue = '*'; //表示该点已经存在皇后了  
  6. const char Valid = ' '; //表示该点还可以放置皇后  
  7. const char Invalid = '_'; //表示该点因不符合条件而不能放置皇后  
  8.   
  9. //定义搜索树的节点，这个节点包含节点的高度及盘面状态（利用数组来保存）  
  10. typedef struct _QueueNode  
  11. {  
  12.     char map[SIZE][SIZE];  
  13.     int height;  
  14. } QueueNode;  
  15.   
  16. //根据给定的位置来更新相应节点中的盘面信息  
  17. void updateMapByPosition(QueueNode *node, int position)  
  18. {  
  19.     //此更新横行  
  20.     for (int i = 0; i != SIZE; i++)  
  21.     {  
  22.         if (i != position)  
  23.         {  
  24.             node->map[node->height][i] = Invalid;  
  25.         }  
  26.     }  
  27.     //更新竖行  
  28.     for (int i = 0; i != SIZE; i++)  
  29.     {  
  30.         if (i != node->height)  
  31.         {  
  32.             node->map[i][position] = Invalid;  
  33.         }  
  34.     }  
  35.     //更新斜行  
  36.     for (int i = 0; i != SIZE; i++)  
  37.     {  
  38.         for (int j = 0; j != SIZE; j++)  
  39.         {  
  40.             if (((i + j) == (position + node->height)) && node->map[i][j] == Valid)  
  41.             {  
  42.                 node->map[i][j] = Invalid;  
  43.             }  
  44.             if (((i - j) == (node->height - position)) && node->map[i][j] == Valid)  
  45.             {  
  46.                 node->map[i][j] = Invalid;  
  47.             }  
  48.         }  
  49.     }  
  50. }  
  51. //这个用来搜索子节点并更新queueList  
  52. void collectNextNodes(std::list<QueueNode*> &queueList, QueueNode *node)  
  53. {  
  54.     QueueNode *tempNode = NULL;  
  55.     if (node->height >= SIZE)  
  56.     {  
  57.         return;  
  58.     }  
  59.   
  60.     for (int i = 0; i != SIZE; i++)  
  61.     {  
  62.         if (node->map[node->height][i] == Valid)  
  63.         {  
  64.             tempNode = new QueueNode;  
  65.   
  66.             for (int j = 0; j != SIZE; j++)  
  67.             {  
  68.                 for (int k = 0; k != SIZE; k++)  
  69.                 {  
  70.                     tempNode->map[j][k] = node->map[j][k];  
  71.                 }  
  72.             }  
  73.             tempNode->height = node->height;  
  74.             tempNode->map[tempNode->height][i] = Queue;  
  75.             updateMapByPosition(tempNode, i);  
  76.             tempNode->height++;  
  77.             queueList.push_back(tempNode);  
  78.         }  
  79.     }  
  80. }  
  81.   
  82. int main()  
  83. {  
  84.     std::list<QueueNode*> queueList; //存储中间盘面的节点  
  85.     std::list<QueueNode*> solution;  //存储符合皇后问题的节点  
  86.     queueList.clear();  
  87.     solution.clear();  
  88.     QueueNode *node = new QueueNode;    //创建初始的空盘面节点，其高度为1  
  89.     for (int j = 0; j != SIZE; j++)  
  90.     {  
  91.         for (int k = 0; k != SIZE; k++)  
  92.         {  
  93.             node->map[j][k] = Valid;  
  94.         }  
  95.     }  
  96.     node->height = 0;  
  97.     queueList.push_back(node);  
  98.     while (!queueList.empty())  
  99.     {  
  100.         QueueNode *tempNode = queueList.front();  
  101.         queueList.pop_front();  
  102.         collectNextNodes(queueList, tempNode);  
  103.         //如果高度等于SIZE（即得到解）,则入到solution队列中，否则删除掉，释放资源  
  104.         if (tempNode->height == SIZE)  
  105.         {  
  106.             solution.push_back(tempNode);  
  107.         }  
  108.         else  
  109.         {  
  110.             delete tempNode;  
  111.         }  
  112.     }  
  113.     //这里作为一个数据鉴别，表明一共有多少个符合条件的答案  
  114.     std::cout << solution.size()<<std::endl;  
  115.   
  116.     //这里只是作为一个展示打印出第一个而已，也可以以别的方式处理  
  117.     node = solution.front();  
  118.     if(node != NULL)  
  119.     {  
  120.         for (int j = 0; j != SIZE; j++)  
  121.         {  
  122.             for (int k = 0; k != SIZE; k++)  
  123.             {  
  124.                 std::cout.put(node->map[j][k]).put(' ');  
  125.             }  
  126.             std::cout << std::endl;  
  127.         }  
  128.     }  
  129. }  

 

 赋予SIZE不同的数值就可以得出不同的解，这里我只是打印出了第一个解，其余的解都已经存在于solution中，可以自己去处理下

皇后问题的解依照其问题的大小而不同，而随着数据的增大，其空间复杂度几乎就是呈指数形式的增长，在我的电脑上跑下SIZE=15的时候就挂了....




相关推荐