八皇后&N皇后问题（回溯，位处理）

                                          N皇后问题

       在N*N的棋盘上放置N个皇后，使得他们不会相互攻击（每个皇后的攻击范围为同行同列和同对角线），要求找出所有解，如图所示：

                                                        

       解的个数：

    

         这个问题是比较经典的问题，也是学习计算机专业一定要掌握的问题，下面我将用两种方法来解释这个问题：

     一、回溯算法

                   在本行依次放置皇后，如果满足条件，那么再进入下一行从头开始进行放置。否则，如果不满足条件，则在本行的下一个位置放置皇后。

                   我们可以放到树里面理解，每个节点有八个子节点，我们从根节点开始往下遍历，如果遇到一个不符合要求的子节点，那么，我们往回走，也就是回到这个子节点的

          父节点，接着，我们从这个父节点继续往下走，走到的也就是所述前面的子节点的兄弟节点。当走到了叶子节点还是符合要求，那么我们就将总数加一。

                    那么判断的步骤该怎么写呢？一般来说我们有两种方法：

  （1）用一个 c[ ] 数组存储每一行的皇后的列坐标，接着在判断的时候从第一行往下找，如果有一行不符合要求，那么回溯；否则，匹配成功

 代码：

                                           

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
int n,c[26],sum;
bool isTrue(int row,int col)
{
    for(int i = 1; i < row; i++)   //从第一列往已经添加的数的前一列检索，如果又不合适的，返回false，否则，返回true
        if(c[i] == col || abs(i - row) == abs(c[i] - col))//分别是列和对角线
            return false;
    return true;

}
void dfs(int i)
{
    if(i==n+1)//已经到了最底层的下一层，说明全部通过
        sum++;
    for(int j=1; j<=n; j++)//每行的每个元素的检索
    {
        if(isTrue(i,j))
        {
            c[i]=j;
            dfs(i+1);
        }
    }
}

int main()
{
    while(scanf("%d",&n)&&n)
    {
        sum = 0;
        memset(c,-1,sizeof(c));
        dfs(1);
        printf("%d\n",sum);
    }
}

（2）与上述（1）思路相同，但是在判断上面有所不同，这次我们记录下来每个放下的皇后的横坐标以及两条对角线对应的目标，在进行判断时，只需要判断使

 用的位置是否已经被用过即可，无需再从头往后寻找，但是时间复杂度与（1 )相同，问题应该出在给vis[ ]数组赋值的时候。

 代码：

                                         

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int n,vis[3][42],c[22],sum;
void dfs(int i)
{
    if(i==n+1)
        sum++;
    for(int j=1; j<=n; j++)
    {
        if(!vis[0][j]&&!vis[1][i+j-1]&&!vis[2][i-j+n])
        {
            c[i]=j;
            vis[0][j]=vis[1][i+j-1]=vis[2][i-j+n]=1;
            dfs(i+1);
            vis[0][j]=vis[1][i+j-1]=vis[2][i-j+n]=0;
        }
    }
}
int main()
{
    while(scanf("%d",&n)&&n)
    {
        sum=0;
        memset(vis,0,sizeof(vis));
        memset(c,0,sizeof(c));
        dfs(1);
        printf("%d\n",sum);
    }
}

    二、位处理

        算法的核心：使用bit数组来代替以前由int或者bool数组来存储当前格子被占用或者说可用信息，从这可以看出N个皇后对应需要N位表示。         巧妙之处在于：以前我们需要在一个N*N正方形的网格中挪动皇后来进行试探回溯，每走一步都要观察和记录一个格子前后左右对角线上格子的信息；采用bit位进行信息存储的话，就可以只在一行格子也就是（1行×N列）个格子中进行试探回溯即可，对角线上的限制被化归为列上的限制。

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

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

       所有下一个位置的试探过程都是通过位操作来实现的

       代码：

            

<pre name="code" class="cpp">#include "iostream"
using namespace std;
#include "time.h"
#include <cstdio>
#include <cstdlib>

// sum用来记录皇后放置成功的不同布局数；maxL用来标记所有列都已经放置好了皇后。
long sum = 0, maxL = 1;

// 试探算法从最右边的列开始。
void test(long row, long ld, long rd)
{
    if (row != maxL)
    {
        // row，ld，rd进行“或”运算，求得所有可以放置皇后的列,对应位为0，
        // 然后再取反后“与”上全1的数，来求得当前所有可以放置皇后的位置，对应列改为1
        // 也就是求取当前哪些列可以放置皇后
        long pos = maxL & ~(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;
    scanf("%d",&n);

    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。
    maxL = (maxL << n) - 1;

    test(0, 0, 0);
    printf("共有%ld种排列, 计算时间%d秒 \n", sum, (int) (time(0) - tm));
    return 0;
}

      位运算的方法很难理解，但是效率可以快很多！