每日一题17：八皇后问题

八皇后问题是由国际西洋棋棋手马克斯·贝瑟尔于1848年提出的：在8X8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。解题的思路如下：从棋盘的第一行起，先选择第一个格子作为第一个皇后的位置，然后在第二行中从第一个格子开始试探一个合适的位置放置第二个皇后，接下来在第三行从第一个格子开始试探一个合适的位置放置第三个皇后…以此类推，知道第八个皇后找到合适的位置。至此第一个满足要求的摆法出现。因为在每一行都是从第一个格子开始往后搜索的，为了穷尽所有的摆法，将最后一个皇后在最后一行中继续后挪，检查是否还有满足要求的摆法。当最后一行探测完毕，返回到上一行，将第七个皇后往后探测是否还有合适的位置，如果在第七行找到另一个满足要求的位置，那么又来到第八行，从第一个格子开始往后探测是否有放置第八个皇后的位置；如果第七行没有找到另一个合适的位置，那么程序转入第六行，将第六个皇后依次往后挪，探测另一个能够放置第六个皇后的位置…依次类推，这也就是回溯所要表达的意思：从某点A开始往前走了几步，当问题得到求解或不能得到解，再回到点A，朝其他方向继续往前走，探测问题的解或更多的解。
检查某个位置B是否可以放置一个皇后时，由于程序对棋盘是从上往下一行一行遍历的，所以只需要检查该位置以上的格子上是否有使得该位置不能放置一个皇后的格子：1）B位置以上同列的格子；2）B位置左斜对角线上方的格子；3）B位置右斜对角线上方的格子；行不用检测，因为一行只能放置一个皇后，如果已经存在一个皇后与B同行，该检查不会进行。

棋盘数据结构与创建棋盘的代码

#include "stdafx.h"

#include <iostream>

using namespace std;


const int candidate_pos = 0;
const int legal_pos = 1;

struct chessboard
{
    int size;
    int *board;
};

chessboard* create(int size)
{
    chessboard* cb = new chessboard;
    cb->size = size;
    cb->board = new int[size*size];
    memset(cb->board,0,size*size*sizeof(int));
    return cb;
}

打印棋盘的代码：

void print(chessboard* cb)
{
    int size = cb->size;
    for(int i = 0; i < size; ++i)
    {
        for(int j = 0; j < size; ++j)
            cout<<cb->board[i*size + j]<<‘ ‘;
        cout<<endl;
    }
    cout<<endl;
}

检查某位置是否合适放置一个皇后的代码：

bool check(chessboard* cb,int row,int col)
{
    int size = cb->size;
    int* board = cb->board;

    //检查列
    int* p = &board[col];
    for (int i = 0; i < row; ++i)
    {
        if(*p) return false;
        p += size;
    }

    //检查从左往右下降的对角线
    for (int i = row - 1,j = col - 1; i >= 0 && j >= 0; --i,--j)
    {
        if(board[i*size + j]) return false;
    }

    //检查从右往左下降的对角线
    for (int i = row - 1,j = col + 1; i >= 0 && j < size; --i,++j)
    {
        if(board[i*size + j]) return false;
    }
    return true;
}

搜索八皇后位置的代码：

void _solve(chessboard** cb,int i,int j,int &count)
{
    //在行或列的维度上，任一维到了尽头，则本行搜索结束，返回上一行
    if(i >= (*cb)->size || j >= (*cb)->size) return;
    int size = (*cb)->size;
    int* board = (*cb)->board;

    //找到一个可以放置皇后的位置后
    if(check(*cb,i,j))
    {
        //将该位置设为1，表示放置了一个皇后
        board[i*size + j] = legal_pos;

        //如果是最后一行，那表示得到了一个解喽
        if(i == size - 1)
        {
            ++count;
            print(*cb);
        }
        //否则往下一行搜索下一个皇后的位置
        else _solve(cb,i + 1,0,count);

        //不管后面的搜索找到几个解，都需要把在本行刚
        //才找到皇后挪开，回溯过程才可能是正确的
        board[i*size + j] = candidate_pos;
    }
    //对于每一行中的j位置，不管它是一个可以或不可以放置
    //皇后的位置，都要继续往后搜索，以穷尽所有的解
    _solve(cb,i,j + 1,count);
}

int solve_eightqueen(int size)
{
    int count = 0;
    chessboard* cb = create(size);
    //从第一个位置开始搜索喽
    _solve(&cb,0,0,count);
    return count;
}

测试代码：

int _tmain(int argc, _TCHAR* argv[])
{
    cout<<"=============1============"<<endl;
    int count = solve_eightqueen(1);
    cout<<"Total:"<<count<<endl;

    cout<<"=============2============"<<endl;
    count = solve_eightqueen(2);
    cout<<"Total:"<<count<<endl;

    cout<<"=============3============"<<endl;
    count = solve_eightqueen(3);
    cout<<"Total:"<<count<<endl;

    cout<<"=============4============"<<endl;
    count = solve_eightqueen(4);
    cout<<"Total:"<<count<<endl;

    cout<<"=============5============"<<endl;
    count = solve_eightqueen(5);
    cout<<"Total:"<<count<<endl;
    return 0;
}

程序运行截图：


棋盘取1到5时，得到的结果。
由于当棋盘大小为8*8时，结果太多，有92个，所以只截取4个结果作为示例：

实际上，上面的算法是一种暴力解法，试图探索所有的排列。按照每行一个皇后的排法一共有8^8种排列，也就是2^24 = 16777216个，这是一个很大的数，但是程序却可以才很短的时间内得到答案，这主要是因为前面行的搜索共同限制了后面行中一些位置的搜索，这使得许许多多的排列不用去考察，因而使得问题可以快速求解。可以把棋盘大小设为12，那么总的搜索空间大小变为：8916100448256（八万亿），而使用的时间呢：

这并不是说回溯法多么好，而是问题如此，它前面的搜索结果深刻影响了后面的搜索，而回溯法只是恰好适合解决这类问题，这是一种比较自然地思维方式而已。