C/C++面试(6)——N皇后问题

八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

常规做法：http://blog.youkuaiyun.com/justme0/article/details/7540425

//  N皇后问题  （递归，回溯）
  
#include <iostream>  
using namespace std;  
  
#define N 8  
  
int matrix[N + 1][N + 1] = {0};  
//  matrix[0][j]为空，matrix[i][0]中放第i行的皇后的列坐标（从1开始记）  
  
bool IsLegal(const int &i, const int &j)  
{  
    //  判断前面的i-1个棋子（坐标是matrix[m][n]）与matrix[i][j]是否冲突，i为1时合法  
    for (int m = 1; m <= i - 1; ++m) {  
        int n = matrix[m][0];  
        if (  n == j || abs(i - m) == abs(j - n) )  
            return false;  
    }  
    return true;  
}  
  
void Print(void)  
{  
    static int count = 1;  
    printf("Case %d:\n", count++);  
    for (int i = 1; i <= N; i++) {  
        for (int j = 1; j <= N; j++) {  
            matrix[i][j] == 1 ? printf("%c ", 2) : printf(". ");  
        }  
        cout << endl;  
    }  
    cout << endl;  
}  
  
void Trial(const int &i)  
{  
    //  进入本函数时，在N*N的棋盘前i-1行已放置了互不攻击的i-1个棋子  
    //  现从第i行起继续为后续棋子选择合适位置  
  
    if (i > N)   //  输出当前的合法布局  
        Print();  
    else  
        for (int j = 1; j <= N; ++j) {  
            matrix[i][j] = 1;  
            if ( IsLegal(i, j) ) {  
                matrix[i][0] = j;  
                Trial(i + 1);  
            }  
            matrix[i][j] = 0;  
        }  
}  
  
int main(void)  
{  
    Trial(1);  
  
    return 0;  
}  

目前公认最高效的做法：http://blog.youkuaiyun.com/hackbuteer1/article/details/6657109

使用位运算来求解N皇后的高效算法

   核心代码如下：

[cpp]  view plain copy

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

完整的代码如下：

[cpp]  view plain copy

1. /* 
2. ** 目前最快的N皇后递归解决方法 
3. ** N Queens Problem 
4. ** 试探-回溯算法，递归实现 
5. */  
6. #include "iostream"  
7. using namespace std;  
8. #include "time.h"  
9.   
10. // sum用来记录皇后放置成功的不同布局数；upperlim用来标记所有列都已经放置好了皇后。  
11. long sum = 0, upperlim = 1;       
12.   
13. // 试探算法从最右边的列开始。  
14. void test(long row, long ld, long rd)  
15. {  
16.     if (row != upperlim)  
17.     {  
18.         // row，ld，rd进行“或”运算，求得所有可以放置皇后的列,对应位为0，  
19.         // 然后再取反后“与”上全1的数，来求得当前所有可以放置皇后的位置，对应列改为1  
20.         // 也就是求取当前哪些列可以放置皇后  
21.         long pos = upperlim & ~(row | ld | rd);   
22.         while (pos)    // 0 -- 皇后没有地方可放，回溯  
23.         {  
24.             // 拷贝pos最右边为1的bit，其余bit置0  
25.             // 也就是取得可以放皇后的最右边的列  
26.             long p = pos & -pos;                                                
27.   
28.             // 将pos最右边为1的bit清零  
29.             // 也就是为获取下一次的最右可用列使用做准备，  
30.             // 程序将来会回溯到这个位置继续试探  
31.             pos -= p;                             
32.   
33.             // row + p，将当前列置1，表示记录这次皇后放置的列。  
34.             // (ld + p) << 1，标记当前皇后左边相邻的列不允许下一个皇后放置。  
35.             // (ld + p) >> 1，标记当前皇后右边相邻的列不允许下一个皇后放置。  
36.             // 此处的移位操作实际上是记录对角线上的限制，只是因为问题都化归  
37.             // 到一行网格上来解决，所以表示为列的限制就可以了。显然，随着移位  
38.             // 在每次选择列之前进行，原来N×N网格中某个已放置的皇后针对其对角线  
39.             // 上产生的限制都被记录下来了  
40.             test(row + p, (ld + p) << 1, (rd + p) >> 1);                                
41.         }  
42.     }  
43.     else     
44.     {  
45.         // row的所有位都为1，即找到了一个成功的布局，回溯  
46.         sum++;  
47.     }  
48. }  
49.   
50. int main(int argc, char *argv[])  
51. {  
52.     time_t tm;  
53.     int n = 16;  
54.   
55.     if (argc != 1)  
56.         n = atoi(argv[1]);  
57.     tm = time(0);  
58.   
59.     // 因为整型数的限制，最大只能32位，  
60.     // 如果想处理N大于32的皇后问题，需要  
61.     // 用bitset数据结构进行存储  
62.     if ((n < 1) || (n > 32))                   
63.     {  
64.         printf(" 只能计算1-32之间\n");  
65.         exit(-1);  
66.     }  
67.     printf("%d 皇后\n", n);  
68.   
69.     // N个皇后只需N位存储，N列中某列有皇后则对应bit置1。  
70.     upperlim = (upperlim << n) - 1;           
71.   
72.     test(0, 0, 0);  
73.     printf("共有%ld种排列, 计算时间%d秒 \n", sum, (int) (time(0) - tm));  
74.     system("pause");  
75.     return 0;  
76. }  

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

        算法的核心：使用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语言的好处，详见代码注释。