N皇后問題的兩個最高效的演算法

        N皇后問題是一個經典的問題，在一個N*N的棋盤上放置N個皇后，每行一個並使其不能互相攻擊（同一行、同一列、同一斜線上的皇后都會自動攻擊）。

一、 求解N皇后問題是演算法中回溯法應用的一個經典案例

       回溯演算法也叫試探法，它是一種系統地搜尋問題的解的方法。回溯演算法的基本思想是：從一條路往前走，能進則進，不能進則退回來，換一條路再試。

      在現實中，有很多問題往往需要我們把其所有可能窮舉出來，然後從中找出滿足某種要求的可能或最優的情況，從而得到整個問題的解。回溯演算法就是解決這種問題的“通用演算法”，有“萬能演算法”之稱。N皇后問題在N增大時就是這樣一個解空間很大的問題，所以比較適合用這種方法求解。這也是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皇后的解。上面說過該問題是回溯法的經典應用，所以可以使用回溯法來解決該問題，具體實現也有兩個途徑，遞迴和非遞迴。遞迴方法較為簡單，大致思想如下：

     void queen(int row)

    {

              if (n == row)      //如果已經找到結果，則列印結果

                    print_result();

              else {

                          for (k=0 to N) { //試探第row行每一個列

                                  if (can_place(row, k) { 

                                          place(row, k);   //放置皇后

                                         queen(row + 1);  //繼續探測下一行

                                  }

                         }

             }

    }

        該方法由於在探測第i行後，如果找到一個可以放置皇后的位置j後，則會遞迴探測下一行，結束後則會繼續探測i行j+1列，故可以找到所有的N皇后的解。

        但是一般來說遞迴的效率比較差，下面重點討論一下該問題的非遞迴實現。

        非遞迴方法的一個重要問題時何時回溯及如何回溯的問題。程式首先對N行中的每一行進行探測，尋找該行中可以放置皇后的位置，具體方法是對該行的每一列進行探測，看是否可以放置皇后，如果可以，則在該列放置一個皇后，然後繼續探測下一行的皇后位置。如果已經探測完所有的列都沒有找到可以放置皇后的列，此時就應該回溯，把上一行皇后的位置往後移一列，如果上一行皇后移動後也找不到位置，則繼續回溯直至某一行找到皇后的位置或回溯到第一行，如果第一行皇后也無法找到可以放置皇后的位置，則說明已經找到所有的解程式終止。如果該行已經是最後一行，則探測完該行後，如果找到放置皇后的位置，則說明找到一個結果，列印出來。但是此時並不能再此處結束程式，因為我們要找的是所有N皇后問題所有的解，此時應該清除該行的皇后，從當前放置皇后列數的下一列繼續探測。

完整的代碼如下：

/*** 回溯法解N皇后問題* 使用一個一維數組表示皇后的位置* 其中數組的下標表示皇后所在的行* 數組元素的值表示皇后所在的列* 這樣設計的棋盤，所有皇后必定不在同一行，於是行衝突就不存在了* date  : 2011-08-03 * author: liuzhiwei**/#include <stdio.h>#include <stdlib.h>#include <math.h>#define QUEEN 8     //皇后的數目#define INITIAL -10000   //棋盤的初始值int a[QUEEN];    //一維數組表示棋盤void init()  //對棋盤進行初始化{int *p;for (p = a; p < a + QUEEN; ++p) {*p = INITIAL;}} int valid(int row, int col)    //判斷第row行第col列是否可以放置皇后{int i;for (i = 0; i < QUEEN; ++i)   //對棋盤進行掃描{if (a[i] == col || abs(i - row) == abs(a[i] - col))   //判斷列衝突與斜線上的衝突return 0;}return 1;} void print()    //列印輸出N皇后的一組解{int i, j;for (i = 0; i < QUEEN; ++i){for (j = 0; j < QUEEN; ++j){if (a[i] != j)      //a[i]為初始值printf("%c ", '.');else                //a[i]表示在第i行的第a[i]列可以放置皇后printf("%c ", '#');}printf("\n");}for (i = 0; i < QUEEN; ++i)printf("%d ", a[i]);printf("\n");printf("--------------------------------\n");}void queen()      //N皇后程式{int n = 0;int i = 0, j = 0;while (i < QUEEN){while (j < QUEEN)        //對i行的每一列進行探測，看是否可以放置皇后{if(valid(i, j))      //該位置可以放置皇后{a[i] = j;        //第i行放置皇后j = 0;           //第i行放置皇后以後，需要繼續探測下一行的皇后位置，所以此處將j清零，從下一行的第0列開始逐列探測break;}else{++j;             //繼續探測下一列}}if(a[i] == INITIAL)         //第i行沒有找到可以放置皇后的位置{if (i == 0)             //回溯到第一行，仍然無法找到可以放置皇后的位置，則說明已經找到所有的解，程式終止break;else                    //沒有找到可以放置皇后的列，此時就應該回溯{--i;j = a[i] + 1;        //把上一行皇后的位置往後移一列a[i] = INITIAL;      //把上一行皇后的位置清除，重新探測continue;}}if (i == QUEEN - 1)          //最後一行找到了一個皇后位置，說明找到一個結果，列印出來{printf("answer %d : \n", ++n);print();//不能在此處結束程式，因為我們要找的是N皇后問題的所有解，此時應該清除該行的皇后，從當前放置皇后列數的下一列繼續探測。//_sleep(600);j = a[i] + 1;             //從最後一行放置皇后列數的下一列繼續探測a[i] = INITIAL;           //清除最後一行的皇后位置continue;}++i;              //繼續探測下一行的皇后位置}}int main(void){init();queen();system("pause");return 0;}

        下面的代碼跟上面的代碼差不多，只是稍微做了一些變化。。上面函數判斷棋盤某個位置合法性的時候，valid函數裡面的QUEEN可以修改為row的，只需要將前面row行與第row行進行比較就可以了，不需要將所有行都與第row進行比較的。。。下面的代碼中的check函數中迴圈次數是k而不是皇后的個數就是這個原因。。。

#include "iostream"#include "cmath"using namespace std;#define Max 20      //定義棋盤的最大值int a[Max];int show(int S)    //定義輸出函數{int i,p,q;int b[Max][Max]={0};     //定義並初始化b[][]輸出數組for(i=1;i<=S;i++)    //按橫列i順序輸出a[i]數組座標{b[i][a[i]]=1;printf("(%d,%d)\t",i,a[i]);}printf("\n");for(p=1;p<=S;p++)     //按棋盤的橫列p順序標明皇后的位置{for(q=1;q<=S;q++){if(b[p][q]==1)     //在第p行第q列放置一個皇后棋子printf("●");elseprintf("○");}printf("\n");}return 0;}int check(int k)    //定義check函數{int i;for(i=1;i<k;i++)    //將第k行與前面的第1~~k-1行進行判斷{if((a[i]==a[k]) || (a[i]-a[k]==k-i) || (a[i]-a[k]==i-k))    //檢查是否有多個皇后在同一條直線上{return 0;}}return 1;}void check_m(int num)    //定義函數{int k=1,count=0;printf("The possible configuration of N queens are:\n");a[k]=1;while(k>0){if(k<=num && a[k]<=num)    //從第k行第一列的位置開始，為後續棋子選擇合適位子{if(check(k)==0)    //第k行的a[k]列不能放置皇后{a[k]++;        //繼續探測當前行的下一列：a[k]+1}else{k++;         //第K行的位置已經確定了，繼續尋找第k+1行皇后的位置a[k]=1;      //從第一列開始尋找}}else{if(k>num)     //若滿足輸出數組的要求則輸出該數組{count++;printf("[%d]:  ",count);show(num);    //調用輸出函數show()}//如果k>num會執行下面兩行代碼，因為雖然找到了N皇后問題的一個解，但是要找的是所有解，需要回溯，從當前放置皇后的下一列繼續探測//如果a[k]>num也會執行下面兩行代碼，就是說在當前行沒有找到可以放置皇后的位置，於是回溯，從上一行皇后位置的下一列繼續探測k--;      //棋子位置不符合要求，則退回前一步a[k]++;   //繼續試探下一列位置}}printf("The count is: %d \n",count);}int main(void){int N,d;//system("color 2a");do{printf("********************N皇后問題系統*********************\n\n");printf("                  1. 四皇后問題                        \n");printf("                  2. 八皇后問題                        \n");printf("                  3. N 皇后問題(N<20)                  \n");printf("                  4. 退出                              \n");printf("******************************************************\n");printf("\n    從數字1-4之間的數選擇需要的操作\n\n"); /*提示輸入選項*/printf("      請輸入你要選擇的功能選項:__\n");scanf("%d",&d); switch(d){case 1:check_m(4);      //4皇后問題break; case 2:check_m(8);     //8皇后問題break; case 3:printf("請輸入N的值：_");fflush(stdin);      //清除緩衝scanf("%d",&N);printf("\n");if(N>0&&N<20){check_m(N);    //N皇后問題break;}else{printf("輸入錯誤，請從新輸入：");printf("\n\n");break; }case 4:exit(0);     //程式結束}}while(1);system("pause");return 0;}

        遞迴解法：

#include <stdio.h>#include <stdlib.h>const int N=20;   //最多放皇后的個數int q[N];         //各皇后所在的行號int cont = 0;     //統計解得個數//輸出一個解void print(int n){int i,j;cont++;printf("第%d個解：",cont);for(i=1;i<=n;i++)printf("(%d,%d) ",i,q[i]);printf("\n");for(i=1;i<=n;i++)        //行{                for(j=1;j<=n;j++)    //列{if(q[i]!=j)printf("x ");else printf("Q "); }printf("\n");}}//檢驗第i行的k列上是否可以擺放皇后int find(int i,int k)  {int j=1;while(j<i)  //j=1~i-1是已經放置了皇后的行{//第j行的皇后是否在k列或(j,q[j])與(i,k)是否在斜線上if(q[j]==k || abs(j-i)==abs(q[j]-k)) return 0;j++;}return 1;}//放置皇后到棋盤上void place(int k,int n)  {int j;if(k>n)print(n);else{for(j=1;j<=n;j++)   //試探第k行的每一個列{if(find(k,j)){q[k] = j;place(k+1,n);  //遞迴總是在成功完成了上次的任務的時候才做下一個任務}}}}int main(void){int n;printf("請輸入皇后的個數(n<=20),n=:");scanf("%d",&n);if(n>20)printf("n值太大，不能求解!\n");else{printf("%d皇后問題求解如下(每列的皇后所在的行數):\n",n);place(1,n);        //問題從最初狀態解起printf("\n");}system("pause");return 0;}

    二、使用位元運算來求解N皇后的高效演算法

   核心代碼如下：

void test(int row, int ld, int rd){int pos, p;if ( row != upperlim ){pos = upperlim & (~(row | ld | rd ));while ( pos ){p = pos & (~pos + 1);pos = pos - p;test(row | p, (ld | p) << 1, (rd | p) >> 1);}}else++Ans;}

        初始化：　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個皇后全放進去了，找到的解的個數加一。

註：
        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 0 0 1 1

        取反 1 1 1 1 0 1 1 1    取反 1 0 1 0 1 1 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  0 0 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 已經完成任務了還要減去p 是因為？
        while 迴圈是因為？
        在進行到某一層的搜尋時，pos中儲存了所有的可放位置，為了求出所有解，必須遍曆所有可放的位置，而每走過一個點必須要刪掉它，否則就成死迴圈啦！

         這個是目前公認N皇后的最高效演算法。

完整的代碼如下：

/*** 目前最快的N皇后遞迴解決方案** N Queens Problem** 試探-回溯演算法，遞迴實現*/#include "iostream"using namespace std;#include "time.h"// sum用來記錄皇后放置成功的不同布局數；upperlim用來標記所有列都已經放置好了皇后。long sum = 0, upperlim = 1;     // 試探演算法從最右邊的列開始。void test(long row, long ld, long rd){if (row != upperlim){// row，ld，rd進行“或”運算，求得所有可以放置皇后的列,對應位為0，// 然後再取反後“與”上全1的數，來求得當前所有可以放置皇后的位置，對應列改為1// 也就是求取當前哪些列可以放置皇后long pos = upperlim & ~(row | ld | rd); while (pos)    // 0 -- 皇后沒有地方可放，回溯{// 拷貝pos最右邊為1的bit，其餘bit置0// 也就是取得可以放皇后的最右邊的列long p = pos & -pos;                                              // 將pos最右邊為1的bit清零// 也就是為擷取下一次的最右可用列使用做準備，// 程式將來會回溯到這個位置繼續試探pos -= p;                           // row + p，將當前列置1，表示記錄這次皇后放置的列。// (ld + p) << 1，標記當前皇后左邊相鄰的列不允許下一個皇后放置。// (ld + p) >> 1，標記當前皇后右邊相鄰的列不允許下一個皇后放置。// 此處的移位操作實際上是記錄對角線上的限制，只是因為問題都化歸// 到一行網格上來解決，所以表示為列的限制就可以了。顯然，隨著移位// 在每次選擇列之前進行，原來N×N網格中某個已放置的皇后針對其對角線// 上產生的限制都被記錄下來了test(row + p, (ld + p) << 1, (rd + p) >> 1);                              }}else   {// row的所有位都為1，即找到了一個成功的布局，回溯sum++;}}int main(int argc, char *argv[]){time_t tm;int n = 16;if (argc != 1)n = atoi(argv[1]);tm = time(0);// 因為整型數的限制，最大隻能32位，// 如果想處理N大於32的皇后問題，需要// 用bitset資料結構進行儲存if ((n < 1) || (n > 32))                 {printf(" 只能計算1-32之間\n");exit(-1);}printf("%d 皇后\n", n);// N個皇后只需N位儲存，N列中某列有皇后則對應bit置1。upperlim = (upperlim << n) - 1;         test(0, 0, 0);printf("共有%ld種排列, 計算時間%d秒 \n", sum, (int) (time(0) - tm));system("pause");return 0;}

        上述代碼還是比較容易看懂的，但我覺得核心的是在針對試探－回溯演算法所用的資料結構的設計上。
        程式採用了遞迴，也就是借用了編譯系統提供的自動回溯功能。

        演算法的核心：使用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來說仍能較大地提升效率！
       位操作－－對最佳化演算法有了個新的認識

　　這個是在csdn找到的一個N皇后問題最快的演算法，看了好一會才明白，這演算法巧妙之處我認為有２個：

       １、以前都是用數組來描述狀態，而這演算法採用是的位來描述，運算速度可以大大提升，以後寫程式對於描述狀態的變數大家可以借鑒這個例子，會讓你的程式跑得更快　　　　　　　　　　　　　　　　　　　　　　　　

       ２、描述每行可放置的位置都是只用row,ld,rd這３個變數來描述，這樣使得程式看起來挺簡潔的。