<LeetCode> 题33：N皇后问题

题目描述：

n -皇后 问题就是正确的在棋盘上面放置皇后的位置，从而使得任意两个皇后之间都无法攻击对方，攻击的方式是同行、同列或对角线。
给定 n ，要求返回n-皇后问题的所有解。每个解决方案包含一个明确的n皇后放置布局，其中“Q”和“x”分别表示一个女王和一个空位置。

思路：回溯法

1) 算法开始, 清空棋盘，当前行设为第一行，当前列设为第一列
2) 在当前行，当前列的位置上判断是否满足条件(即保证经过这一点的行,列与斜线上都没有两个皇后)，若不满足，跳到第4步
3) 在当前位置上满足条件的情形：
–>在当前位置放一个皇后，若当前行是最后一行，记录一个解；
–>若当前行不是最后一行，当前行设为下一行，当前列设为当前行的第一个待测位置；
–>若当前行是最后一行，当前列不是最后一列，当前列设为下一列；
–>若当前行是最后一行，当前列是最后一列，回溯，即清空当前行及以下各行的棋盘，然后，当前行设为上一行，当前列设为当前行的下一个待测位置；
–>以上返回到第2步
4) 在当前位置上不满足条件的情形：
–>若当前列不是最后一列，当前列设为下一列，返回到第2步;
–>若当前列是最后一列了，回溯，即，若当前行已经是第一行了，算法退出，否则，清空当前行及以下各行的棋盘，然后，当前行设为上一行，当前列设为当前行的下一个待测位置，返回到第2步;

回溯法思想：

程序首先对N行中的每一行进行探测，寻找该行中可以放置皇后的位置，具体方法是对该行的每一列进行探测，看是否可以放置皇后，如果可以，则在该列放置一个皇后，然后继续探测下一行的皇后位置。如果已经探测完所有的列都没有找到可以放置皇后的列，此时就应该回溯，把上一行皇后的位置往后移一列，如果上一行皇后移动后也找不到位置，则继续回溯直至某一行找到皇后的位置或回溯到第一行，如果第一行皇后也无法找到可以放置皇后的位置，则说明已经找到所有的解程序终止。如果该行已经是最后一行，则探测完该行后，如果找到放置皇后的位置，则说明找到一个结果，打印出来。但是此时并不能再此处结束程序，因为我们要找的是所有N皇后问题所有的解，此时应该清除该行的皇后，从当前放置皇后列数的下一列继续探测。

完整代码：

写法一：

/**
* 回溯法解N皇后问题
* 使用一个一维数组表示皇后的位置
* 其中数组的下标表示皇后所在的行
* 数组元素的值表示皇后所在的列
* 这样设计的棋盘，所有皇后必定不在同一行，于是行冲突就不存在了
**/
#include <iostream>
#include <math.h>

#define QUEEN 4     //皇后的数目
#define INITIAL -10000   //棋盘的初始值

using namespace std;

int a[QUEEN];    //一维数组表示棋盘

void init()  //对棋盘进行初始化
{
    int *p;
    for (p = a; p < a + QUEEN; ++p) 
    {
        *p = INITIAL;
    }
} 

int valid(int row, int col)    //判断第row行第col列是否可以放置皇后
{
    int i;
    for (i = 0; i < QUEEN; ++i)   //对棋盘进行扫描
    {
        if (a[i] == col || abs(i - row) == abs(a[i] - col))   //判断列冲突与斜线上的冲突
            return 0;
    }
    return 1;
} 

void print()    //打印输出N皇后的一组解
{
    int i, j;
    for (i = 0; i < QUEEN; ++i)
    {
        for (j = 0; j < QUEEN; ++j)
        {
            if (a[i] != j)      //a[i]为初始值
                cout << "." ;
            else                //a[i]表示在第i行的第a[i]列可以放置皇后
                cout << "#" ;
        }
        cout << endl;
    }
    for (i = 0; i < QUEEN; ++i)
    {
        cout << a[i] ;
    }
    cout << endl;
    cout << "--------------------------------" << endl;
}

void queen()      //N皇后程序
{
    int n = 0;
    int i = 0, j = 0;
    while (i < QUEEN)
    {
        while (j < QUEEN)        //对i行的每一列进行探测，看是否可以放置皇后
        {
            if(valid(i, j))      //该位置可以放置皇后
            {
                a[i] = j;        //第i行放置皇后
                j = 0;           //第i行放置皇后以后，需要继续探测下一行的皇后位置，所以此处将j清零，从下一行的第0列开始逐列探测
                break;
            }
            else
            {
                ++j;             //继续探测下一列
            }
        }
        if(a[i] == INITIAL)         //第i行没有找到可以放置皇后的位置
        {
            if (i == 0)             //回溯到第一行，仍然无法找到可以放置皇后的位置，则说明已经找到所有的解，程序终止
                break;
            else                    //没有找到可以放置皇后的列，此时就应该回溯
            {
                --i;
                j = a[i] + 1;        //把上一行皇后的位置往后移一列
                a[i] = INITIAL;      //把上一行皇后的位置清除，重新探测
                continue;
            }
        }
        if (i == QUEEN - 1)          //最后一行找到了一个皇后位置，说明找到一个结果，打印出来
        {
            cout << "answer:" << ++n << endl;
            print();
            //不能在此处结束程序，因为我们要找的是N皇后问题的所有解，此时应该清除该行的皇后，从当前放置皇后列数的下一列继续探测。
            //_sleep(600);
            j = a[i] + 1;             //从最后一行放置皇后列数的下一列继续探测
            a[i] = INITIAL;           //清除最后一行的皇后位置
            continue;
        }
        ++i;              //继续探测下一行的皇后位置
    }
}

int main(void)
{

    init();
    queen();
    system("pause");
    return 0;
}

写法二：
下面的代码跟上面的代码差不多，只是稍微做了一些变化。。上面函数判断棋盘某个位置合法性的时候，valid函数里面的QUEEN可以修改为row的，只需要将前面row行与第row行进行比较就可以了，不需要将所有行都与第row进行比较的。。。下面的代码中的check函数中循环次数是k而不是皇后的个数就是这个原因。。。

#include "iostream"
#include "cmath"
using namespace std;

#define Max 20      //定义棋盘的最大值
int a[Max];
int show(int S)    //定义输出函数
{
    int i,p,q;
    int b[Max][Max]={0};     //定义并初始化b[][]输出数组

    for(i=1;i<=S;i++)    //按横列i顺序输出a[i]数组坐标
    {
        b[i][a[i]]=1;
        printf("(%d,%d)\t",i,a[i]);
    }
    printf("\n");
    for(p=1;p<=S;p++)     //按棋盘的横列p顺序标明皇后的位置
    {
        for(q=1;q<=S;q++)
        {
            if(b[p][q]==1)     //在第p行第q列放置一个皇后棋子
                printf("●");
            else
                printf("○");
        }
        printf("\n");
    }
    return 0;
}

int check(int k)    //定义check函数
{
    int i;
    for(i=1;i<k;i++)    //将第k行与前面的第1~~k-1行进行判断
    {
        if((a[i]==a[k]) || (a[i]-a[k]==k-i) || (a[i]-a[k]==i-k))    //检查是否有多个皇后在同一条直线上
        {
            return 0;
        }
    }
    return 1;
}

void check_m(int num)    //定义函数
{
    int k=1,count=0;
    printf("The possible configuration of N queens are:\n");
    a[k]=1;
    while(k>0)
    {
        if(k<=num && a[k]<=num)    //从第k行第一列的位置开始，为后续棋子选择合适位子
        {
            if(check(k)==0)    //第k行的a[k]列不能放置皇后
            {
                a[k]++;        //继续探测当前行的下一列：a[k]+1
            }
            else
            {
                k++;         //第K行的位置已经确定了，继续寻找第k+1行皇后的位置
                a[k]=1;      //从第一列开始查找
            }
        }
        else
        {
            if(k>num)     //若满足输出数组的要求则输出该数组
            {
                count++;
                printf("[%d]:  ",count);
                show(num);    //调用输出函数show()
            }
            //如果k>num会执行下面两行代码，因为虽然找到了N皇后问题的一个解，但是要找的是所有解，需要回溯，从当前放置皇后的下一列继续探测
            //如果a[k]>num也会执行下面两行代码，就是说在当前行没有找到可以放置皇后的位置，于是回溯，从上一行皇后位置的下一列继续探测
            k--;      //棋子位置不符合要求，则退回前一步
            a[k]++;   //继续试探下一列位置
        }
    }
    printf("The count is: %d \n",count);
}

int main(void)
{
    int N,d;
    //system("color 2a");
    do
    {
        printf("********************N皇后问题系统*********************\n\n");
        printf("                  1. 四皇后问题                        \n");
        printf("                  2. 八皇后问题                        \n");
        printf("                  3. N 皇后问题(N<20)                  \n");
        printf("                  4. 退出                              \n");
        printf("******************************************************\n");
        printf("\n    从数字1-4之间的数选择需要的操作\n\n"); /*提示输入选项*/
        printf("      请输入你要选择的功能选项:__\n");
        scanf_s("%d",&d); 
        switch(d)
        {
        case 1:
            check_m(4);      //4皇后问题
            break; 
        case 2:
            check_m(8);     //8皇后问题
            break; 
        case 3:
            printf("请输入N的值：_");
            fflush(stdin);      //清除缓冲
            scanf_s("%d",&N);
            printf("\n");
            if(N>0&&N<20)
            {
                check_m(N);    //N皇后问题
                break;
            }
            else
            {
                printf("输入错误，请从新输入：");
                printf("\n\n");
                break; 
            }
        case 4:
            exit(0);     //程序结束
        }
    }while(1);
    system("pause");
    return 0;
}

更详细的描述请参考：N皇后问题的两个最高效的算法