你知道八皇后嘛？就是那个八皇后

说起八皇后，其实这是一个古老而著名的问题。该问题是19世纪著名的数学家高斯1850年提出：在一个8*8国际象棋盘上，有8个皇后，每个皇后占一格；要求皇后之间不会出现相互“攻击”的现象，即不能有两个皇后处在同一行、同一列或同一对角线上。问共有多少种不同的方法？
这个问题的解法有很多，不过比较常见的就是递归算法和回溯算法。
什么是回溯算法呢？
回溯算法其实也叫做试探法，它是一种搜索问题的解的方法。
它的的基本思想是在一个包含所有解的解空间树中，按照深度优先的策略，从根结点出发搜索解空间树。算法搜索至解空间树的任意结点时，总是先判断该结点是否肯定不包含问题的解。如果肯定不包含，则跳过对以该结点为根的子树的系统搜索，逐层向其祖先结点回溯。否则，进入该子树，继续按深度优先的策略进行搜索。
而回溯算法在用来求问题的所有解时，要回溯到根，且根结点的所有子树都已被搜索遍才结束。
那什么又是递归算法呢？
递归算法说白了就是一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法。
而递归算法的本质及时递归函数，递归函数就是直接或间接调用自身的函数，也就是自身调用自己；是不是有点乱套啊，可能对于刚接触递归的同学，可能难以理解递归，难以理解的点可能很多。我们以后慢慢来学，不着急。
介绍完这两种算法之后，我们再来具体看下如何用这两种算法来处理八皇后问题。
我们先来看回溯算法，也就是非递归算法的示例代码：

#include <iostream>
using std::cout;
using std::endl;
 
#include <iomanip>
using std::setw;
 
#include <cmath>
//非递归算法解决八皇后问题。求出可能的92种。
// using std::abs;
 
int main()
{
    static int queen[9];
    static int count=1;
 
    for (int A=1;A<=8;A++)
    {
        for (int B=1;B<=8;B++)
        {
            if (B==A)
            {
                continue;
            }
 
            queen[2]=B;
            if ((abs(B-A))==1)
            {
                continue;
            }
            queen[1]=A;
             
            for (int C=1;C<=8;C++)
            {
                if ((C==B) || (C==A))
                {
                    continue;
                }
 
                if ((abs(C-B)==1)||(abs(C-A)==2))
                {
                    continue;
                }
                queen[3]=C;
 
                for (int D=1;D<=8;D++)
                {
                    if ((D==C)||(D==B)||(D==A))
                    {
                        continue;
                    }
 
                    if ((abs(D-C)==1)||(abs(D-B)==2)||(abs(D-A)==3))
                    {
                        continue;
                    }
                    queen[4]=D;
 
                    for (int E=1;E<=8;E++)
                    {
                        if ((E==D)||(E==C)||(E==B)||(E==A))
                        {
                            continue;
                        }
 
                        if ((abs(E-D)==1)||(abs(E-C)==2)||(abs(E-B)==3)||(abs(E-A)==4))
                        {
                            continue;
                        }
                        queen[5]=E;
 
                        for (int F=1;F<=8;F++)
                        {
                            if ((F==E)||(F==D)||(F==C)||(F==B)||(F==A))
                            {
                                continue;
                            }
 
                            if ((abs(F-E)==1)||(abs(F-D)==2)||(abs(F-C)==3)||(abs(F-B)==4)||(abs(F-A)==5))
                            {
                                continue;
                            }
                            queen[6]=F;
 
                            for (int G=1;G<=8;G++)
                            {
                                if ((G==F)||(G==E)||(G==D)||(G==C)||(G==B)||(G==A))
                                {
                                    continue;
                                }
 
                                if ((abs(G-F)==1)||(abs(G-E)==2)||(abs(G-D)==3)||(abs(G-C)==4)||(abs(G-B)==5)||(abs(G-A)==6))
                                {
                                    continue;
                                }
                                queen[7]=G;
 
                                for (int I=1;I<=8;I++)
                                {
                                    if ((I==G)||(I==F)||(I==E)||(I==D)||(I==C)||(I==B)||(I==A))
                                    {
                                        continue;
                                    }
 
                                    if ((abs(I-G)==1)||(abs(I-F)==2)||(abs(I-E)==3)||(abs(I-D)==4)||(abs(I-C)==5)
                                        ||(abs(I-B)==6)||(abs(I-A)==7))
                                    {
                                        continue;
                                    }
                                    queen[8]=I;
 
                                    cout<<"  NO."<<setw(2)<<count<<": ";
                                    for (int i=1;i<=8;i++)
                                    {
                                        cout<<setw(3)<<queen[i];
                                    }
                                    count++;
                                    cout<<endl;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    return 0;

上面就是具体的示例代码，大家可以自己在自己的电脑上调试下，我们再来看下用递归算法怎么处理这个问题：

#include <iostream>
using namespace std;
//递归算法解决八皇后问题。总共有92种解法。
int c[20], n=8, cnt=0;
void print(){

    for(int i=0; i<n; ++i){
        for(int j=0; j<n; ++j){
            if(j == c[i]) cout<<"1 ";
            else cout<<"0 ";
        }
        cout<<endl;
    }
    cout<<endl;
}
void search(int r){
    if(r == n){
        print();
        ++cnt;
        return;
    }
    for(int i=0; i<n; ++i){
        c[r] = i;
        int ok = 1;
        for(int j=0; j<r; ++j)
            if(c[r]==c[j] || r-j==c[r]-c[j] || r-j==c[j]-c[r]){
                ok = 0;
                break;
            }
        if(ok) search(r+1);
    }
}
int main(){
    search(0);
    cout<<cnt<<endl;
    return 0;
}

上面这部分这是递归算法的代码，看着是不是比回溯算法的代码少很多，具体可以在自己的电脑上试试。
好了，这个著名的问题我们就先聊到这里，希望大家能够支持。