N皇后问题的二进制优化详细思路

题目啊常规解法(DFS)在此就不赘述了。。。

直接进入正题

众所周知，N皇后是NP完全类问题，n稍微大了点求解过程就会变得很长。

算法方面很难再有质的效率突破，但这不妨在其他细节上下下功夫。

揆诸常规解法，采用了数组来做mark,以行为每一层进行回溯算法，每个操作周期中无非就做了下面这些事情：

更新元素

判定元素

做出反应

更新元素这上面基本上想不到能有啥提升空间了（一次更新多个？？似乎更加复杂了不谈不谈）。。。

做出反应嘛也同样没啥可以进步的地方（做出预判类反应？？也复杂了，不谈不谈）。。。

很显然，有提升空间的就是判定元素环节了。

首先，从存储上考虑：

我们采用了三个数组来分别mark两个斜线和一列的占用情况（这里用"占用情况"表示此处是否能落子，如果被‘占用了’，则不能放棋子）

可不可以并成一个数组呢？那么这一个数组就要能够表示三个信息:当前位置一列两斜线的占用情况。有时即使能表示了，但是当移动到下一个位置的时候又得获得新的信息。。似乎不可行。

（于是我们又开始无聊地在纸上模拟算法过程了。。。。）

诶，然后就会发现，当进行DFS的时候，比如进行到第k层，放下了一个棋子，然后我们就要到下面一层去继续判定，此刻我们用到的信息是第k+1层的占用情况,而k+1的占用情况受到第k层情况的直接影响，如下图：

 我们会发现第三层涂色的三个位置就不能放棋子了， 

而除了第k层的影响，前k-1层也对第k+1层有着制约:

再回来看经典算法，每一次标记直接就否定了一条线上的位置，我们跳出这个思维，可不可以“步步为营”，进入到下一行的同时更新出下一行的占用信息？如果这样的话，一个数组足矣。　　

再思考，都已经一个数组了（相当于一串数字），而且每个格子就两个状态：有棋子，没棋子。

显然，二进制是不二选择！而且二进制运算的效率比较高！

大概的思路出来了，还有最后一个难点，就是前k-1层的占用信息如何安全过度到第k+1行。。

动手尝试了就不难发现这个规律：一个棋子会产生三种影响效果，斜向影响的，到下一层“占用”会斜向相应的方向偏移一格；垂直影响的，到下一层“占用”依旧在相应位置。

如图：

这时候就出现了三种类型的信息更新，一串二进制就难以实现了。。。那就三串呗，比起数组仍然不亏了。

大的逻辑疙瘩在脑子里基本上解开了，下面开始改代码:

首先，咱不用数组，改成int就够了。其次，考虑到每次信息更新的特点，我们可以用函数的形参来传递，省的搞个全局变量让人不爽。

函数头这亚子：

void Dfs(int i,int left,int col,int right)//分别是 层数  反斜杠mark  一列mark  斜杠mark 

然后仍然是一般DFS解法的框架，只需要把其中用bool数组mark判断的地方用二进制方法进行替换即可。 

放代码：

void Dfs(int i,int left,int col,int right)//分别是 层数  反斜杠mark  一列mark  斜杠mark
{
    if (i > N)              //判断是否已经枚举完了N行
    {
        showOneSolution();  //枚举完了就输出（此刻我们处于N+1行）
        return;             //返回到第N行
    }
    for (int j = N-1; j >=0; --j) //为啥J倒过来数呢？方便下面if中的偏移判断
    {
        if (!(((left|col|right)>>j)&1))//(自己解读，有助于提升能力 (好吧我懒）)
        {
            ans[i] = N-j;
            Dfs(i + 1,(left|(1<<j))<<1,(col|(1<<j)),(right|(1<<j))>>1);  //更新“占用信息”的工作就放在参数传递这里了
                                              //这样子的好处就是，回溯的时候不用做什么恢复处理，
                                              //因为这一层的东西基本没变动
        }
    }
}

这么多括号嵌套的。。哎呀我知道这可读性差，不提倡不提倡！

但是咱们现在是学习又不是工作，尽量读一些奇怪的代码有助于提高读代码能力（可着劲找借口··）

好了下面放上完整代码：

#include<iostream>

using namespace std;

int total = 0;
int N = 0;
int ans[64] = { 0 }; //结果还是要用数组存滴
void showOneSolution()//用来显示一个解
{
    total++;
    for (int i = 1; i<=N; ++i)
    {
        cout << ans[i] << " ";
    }
        cout << endl;
}
void Dfs(int i,int left,int col,int right)//分别是 层数  反斜杠mark  一列mark  斜杠mark
{
    if (i > N)              //判断是否已经枚举完了N行
    {
        showOneSolution();  //枚举完了就输出（此刻我们处于N+1行）
        return;             //返回到第N行
    }
    for (int j = N-1; j >=0; --j) //为啥J倒过来数呢？方便下面if中的偏移判断
    {
        if (!(((left|col|right)>>j)&1))//(自己解读，有助于提升能力 )
        {
            ans[i] = N-j;
            Dfs(i + 1,(left|(1<<j))<<1,(col|(1<<j)),(right|(1<<j))>>1);  //更新“占用信息”的工作就放在参数传递这里了
                                              //这样子的好处就是，回溯的时候不用做什么恢复处理，
                                              //因为这一层的东西基本没变动
        }
    }
}

int main()
{
    cin >> N;
    Dfs(1,0,0,0);
    cout << total;
    system("pause");
    return 0;
}

---

总结：

　　巧妙运用位运算可以达到锦上添花的效果（装逼），不过大多数人看到位运算&|^<<>>啥的就打哈欠。

　　但是恰巧就有那么一些问题，能够完美契合二进制和位运算的特殊性质（不是指这个==)，当你遇到的时候，你就会惊异于0101010···的奇妙。  

---

后记：

　　当年还是太年轻，其实既然都用了位运算，为何不用用这个绝妙的性质呢？

　　　　x & (−x) 可以获得 x 的二进制表示中的最低位的 1 的位置；

　　　　x & (x−1) 可以将 x 的二进制表示中的最低位的 1 置成 0。