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

   核心程式碼如下：

1. void test(int row, int ld, int rd)  
2. {  
3.     int pos, 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個皇后全放進去了，找到的解的個數加一。

注：
        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皇后的最高效演算法。

完整的程式碼如下：

1. /* 
2. ** 目前最快的N皇后遞迴解決方法 
3. ** N Queens Problem 
4. ** 試探-回溯演算法，遞迴實現 
5. */
6. #include "iostream"
7. usingnamespace std;  
8. #include "time.h"
9. // sum用來記錄皇后放置成功的不同佈局數；upperlim用來標記所有列都已經放置好了皇后。
10. long sum = 0, upperlim = 1;       
11. // 試探演算法從最右邊的列開始。
12. void test(long row, long ld, long rd)  
13. {  
14.     if (row != upperlim)  
15.     {  
16.         // row，ld，rd進行“或”運算，求得所有可以放置皇后的列,對應位為0，
17.         // 然後再取反後“與”上全1的數，來求得當前所有可以放置皇后的位置，對應列改為1
18.         // 也就是求取當前哪些列可以放置皇后
19.         long pos = upperlim & ~(row | ld | rd);   
20.         while (pos)    // 0 -- 皇后沒有地方可放，回溯
21.         {  
22.             // 拷貝pos最右邊為1的bit，其餘bit置0
23.             // 也就是取得可以放皇后的最右邊的列
24.             long p = pos & -pos;                                                
25.             // 將pos最右邊為1的bit清零
26.             // 也就是為獲取下一次的最右可用列使用做準備，
27.             // 程式將來會回溯到這個位置繼續試探
28.             pos -= p;                             
29.             // row + p，將當前列置1，表示記錄這次皇后放置的列。
30.             // (ld + p) << 1，標記當前皇后左邊相鄰的列不允許下一個皇后放置。
31.             // (ld + p) >> 1，標記當前皇后右邊相鄰的列不允許下一個皇后放置。
32.             // 此處的移位操作實際上是記錄對角線上的限制，只是因為問題都化歸
33.             // 到一行網格上來解決，所以表示為列的限制就可以了。顯然，隨著移位
34.             // 在每次選擇列之前進行，原來N×N網格中某個已放置的皇后針對其對角線
35.             // 上產生的限制都被記錄下來了
36.             test(row + p, (ld + p) << 1, (rd + p) >> 1);                                
37.         }  
38.     }  
39.     else
40.     {  
41.         // row的所有位都為1，即找到了一個成功的佈局，回溯
42.         sum++;  
43.     }  
44. }  
45. int main(int argc, char *argv[])  
46. {  
47.     time_ttm;  
48.     int n = 16;  
49.     if (argc != 1)  
50.         n = atoi(argv[1]);  
51.     tm = time(0);  
52.     // 因為整型數的限制，最大隻能32位，
53.     // 如果想處理N大於32的皇后問題，需要
54.     // 用bitset資料結構進行儲存
55.     if ((n < 1) || (n > 32))                   
56.     {  
57.         printf(" 只能計算1-32之間\n");  
58.         exit(-1);  
59.     }  
60.     printf("%d 皇后\n", n);  
61.     // N個皇后只需N位儲存，N列中某列有皇后則對應bit置1。
62.     upperlim = (upperlim << n) - 1;           
63.     test(0, 0, 0);  
64.     printf("共有%ld種排列, 計算時間%d秒 \n", sum, (int) (time(0) - tm));  
65.     system("pause");  
66.     return 0;  
67. }  

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

        演算法的核心：使用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這３個變數來描述，這樣使得程式看起來挺簡潔的。