N皇后问题 --递归及回溯解决方案

一：介绍

n 皇后等价于要求在一个 n*n 的棋盘上放置 n 个皇后，使得任何两个皇后都不能被放在同一行或同一列或同一斜线上。

二：算法设计

对于 n 后问题，我们用 n 元组 x[1:n] 表示它的解。其中 x[i] 表示皇后放在棋盘的第 i 行的第 x[i] 列。

由于左上角到右下角的主对角线及其平行线上(斜率为-1)，元素2个下标值的差(行号-列号)相等。同理，斜率为+1的斜线上，元素的2个下标值的和(行号+列号)相等。

因此，若两个皇后位置分别为(i, j)和(k,l)，且 i - j = k - l 或 i + j = k + l，则说明两个皇后出于同一斜线上。以上两个方程式等价于 i - k = j - l 或 i - k = l - j。

由此可知，只要 |i - k| = |j - l|成立，就表明两个皇后位于同一斜线上。

三:代码实现

#include <iostream>
#include <assert.h>
using namespace std;

const int N_QUEEN = 8;

class queen{
    friend int n_queen(int num);             //设为友元函数
private:                                     //方法为私有，增加安全性
    bool place(int k); 
#ifdef _USE_RECURSION_
    void back_track(int t); 
#else
    void back_track();
#endif
    void show()const;
private:
    int  num;
    int  *x; 
    long count;
};

bool queen::place(int k)     //检测能否放置
{
    for(int i=1; i<k; ++i){     //此处不能等于k，因为是根据之前已经放置好了的皇后判断
        if((abs(i-k) == abs(x[i]-x[k])) || (x[i] == x[k]))   //第一个条件检测是否在斜线上，第二个检测是否在同一列
            return false;
    }   
    return true;
}

#ifdef _USE_RECURSION_
void queen::back_track(int t)       //递归方法
{
    if(t > num){
        ++count;
        show();
    }   

    for(int i=1; i<=num; ++i){      //下标统一从1开始，便于处理
        x[t] = i;         
        if(place(t))
            back_track(t+1);
    }   
}
#else
void queen::back_track()
{
    x[1] = 0;                 //初始化为0是一个技巧
    int k = 1;
    while(k > 0){ 
        x[k] += 1;
        while((x[k] <= num) && (!place(k)))   //如果小于边界，且不能放置，继续向下找
            x[k] += 1;
        if(x[k] <= num){
            if(k == num){      //如果到了第八行，成功找到一种情况
                ++count;
                show();
            }
            else{
                ++k;
                x[k] = 0;
            }
        }
        else
            --k;
    }   
}
#endif

void queen::show()const               //打印每种情况的图
{
    for(int i=1; i<=num; ++i){
        for(int j=1; j<=num; ++j){
            if(x[i] == j)
                cout<<'@'<<' ';
            else
                cout<<'#'<<' ';
        }
        cout<<endl;
    }   
    cout<<endl;
}

int n_queen(int num)
{
    queen que;
    que.num = num;
    que.count = 0;
    
    int *new_base = new int[num+1];
    assert(new_base != NULL);
    que.x = new_base;

#ifdef _USE_RECURSION_
    que.back_track(1);
#else
    que.back_track();
#endif

    delete []new_base;
    return que.count;
}

int main()
{
    int res = n_queen(N_QUEEN);
    cout<<res<<endl;
    return 0;
}

部分测试结果如下：