回溯法，八皇后问题

在国际象棋中，皇后是最强大的一枚棋子，可以吃掉与其在同一行、列和斜线的敌方棋子。比中国象棋里的车强几百倍，比她那没用的老公更是强的飞起（国王只能前后左右斜线走一格）。上图右边高大的棋子即为皇后。

 　　八皇后问题是这样一个问题：将八个皇后摆在一张8*8的国际象棋棋盘上，使每个皇后都无法吃掉别的皇后，一共有多少种摆法？此问题在1848年由棋手马克斯·贝瑟尔提出，岂止是有年头，简直就是有年头，82年的拉菲分分钟被秒的渣都不剩。

　　八皇后问题是典型的回溯法解决的问题，我们以这个问题为例介绍回溯法。

　　所谓回溯法，名字高大上，思想很朴素。设想把你放在一个迷宫里，想要走出迷宫，最直接的办法是什么呢？没错，试。先选一条路走起，走不通就往回退尝试别的路，走不通继续往回退，直到找到出口或所有路都试过走不出去为止。

这里稍微用数学分析一下，用i,j表示当前正在检测的两列（i外层for循环,j内层for循环），那么a[i] ，a[j] 的值就分别表示当前检测列棋子摆放的位置即行（每列只有1个棋子）。


如果两个棋子对角线冲突（正反对角线冲突），则必然有：

abs(a[i]-a[j]) == i-j

优化整理后的冲突判断代码就出炉了，如下所示：

//位置冲突算法 
bool Chongtu(int a[], int n)//a[]位置数组，n皇后个数 
{
    for (int i = 2; i <= n; ++i)//i：位置 
        for (int j = 1; j <= i-1; ++j)//j：位置 
            if ((a[i] == a[j]) || (abs(a[i]-a[j]) == i-j))//1：在一行；2：在对角线上 
                return false;   //冲突 
    return true;//不冲突 
}

关于内层for循环j<=i-1，因为判断第i个棋子是否冲突（摆放是否合理），我们只需要和前面i-1列校对就ok了。这样也保证了,i>j的恒成立。所以对角线冲突了简化了一下。
好了，该说明的都说明了，现在编写第一个八皇后代码~~~~


枚举法：


思想：八重枚举，枚举出所以摆放的情况（不管合理不合理），然后到第八层for里面判断当前枚举出来的情况是否合理~~~~

#include <stdio.h>
#include <math.h>
//位置冲突算法 
bool Chongtu(int a[], int n)//a[]位置数组，n皇后个数 
{
    int i = 0, j = 0;
 
    for (i = 2; i <= n; ++i)//i：位置 
        for (j = 1; j <= i-1; ++j)//j：位置 
            if ((a[i] == a[j]) || (abs(a[i]-a[j]) == i-j))//1：在一行；2：在对角线上 
                return false;   //冲突 
    return true;//不冲突 
}
//八皇后：枚举算法 
void Queens8()
{
    int a[9] = {0}; //用于记录皇后位置：(第0行0列我们不用)。如：a[3] = 4;表示第3列第4行位置有皇后
    int i = 0,count = 0;  //用于计数 
 
    for (a[1] = 1; a[1] <= 8; ++a[1])
        for (a[2] = 1; a[2] <= 8; ++a[2])
            for (a[3] = 1; a[3] <= 8; ++a[3])
                for (a[4] = 1; a[4] <= 8; ++a[4])
                    for (a[5] = 1; a[5] <= 8; ++a[5])
                        for (a[6] = 1; a[6] <= 8; ++a[6])
                            for (a[7] = 1; a[7] <= 8; ++a[7])
                                for (a[8] = 1; a[8] <= 8; ++a[8])
                                {
                                    if (!Chongtu(a,8))//如果冲突，则继续枚举 
                                        continue;
                                    else
                                    {
                                        printf("第%d情况：",++count);
                                        for (i = 1; i <= 8; ++i)
                                            printf("%d ",a[i]);//打印某种情况 
                                        printf("\n");
                                    }
                                }
}
//主函数 
int main()
{
    Queens8();
 
    return 0;
}

回溯法

#include <stdio.h>
#include <math.h>
 
int a[9] = {0};
int n = 8, count = 0;
 
//位置冲突算法 
bool Chongtu(int a[], int n)//a[]位置数组，n皇后个数 
{
    int i = 0, j = 0;
 
    for (i = 2; i <= n; ++i)//i：位置 
        for (j = 1; j <= i-1; ++j)//j：位置 
            if ((a[i] == a[j]) || (abs(a[i]-a[j]) == i-j))//1：在一行；2：在对角线上 
                return false;   //冲突 
    return true;//不冲突 
}
 
//八皇后问题：回溯算法（递归版） 
void Queens8(int k) //参数k：递归摆放第k个皇后 
{
    int i = 0;
 
    if (k > n)      //k>n：即k>8表示最后一个皇后摆放完毕 
    {
        printf("第%d种情况：",++count);
        for (i = 1; i <= n; ++i)
            printf("%d ",a[i]);//打印情况 
        printf("\n");
    }
    else   //8个皇后未全部摆放完毕        
    {
        for (i = 1; i <= n; ++i)//摆放第k个皇后时（转下一行） 
        {       //依次从列顶端开始搜索，一直到列底端，直到找到合适位置,如果未找到，自动返回上层递归(回溯) 
            a[k] = i;               
            if (Chongtu(a,k))//不冲突 
                Queens8(k+1);//递归摆放下一个皇后
        }
    }
    return;
}
 
//主函数 
int main()
{
    Queens8(1);//参数1：表示摆放第1个皇后 
 
    return 0;
}

//  N皇后问题  
  
#include <iostream>  
using namespace std;  
  
#define N 8  
  
bool matrix[N + 1][N + 1] = {0};  
  
bool IsLegal(bool matrix[N + 1][N + 1], const int &i, const int &j)  
{  
    //  判断前面的i-1个棋子与matrix[i][j]是否冲突，i为1时合法  
  
    for (int m = 1; m <= i - 1; ++m) {  
        for (int n = 1; n <= N; ++n) {   //  实际每一行只有一个棋子  
            if (matrix[m][n] == 1) {  
                if ( n == j || abs(i - m) == abs(j - n) )   //  key, not bad  
                    return false;  
            }  
        }  
    }  
    return true;  
}  
  
void Print(bool matrix[N + 1][N + 1])  
{  
    static int count = 1;  
    printf("Case %d:\n", count++);  
    for (int i = 1; i <= N; i++) {  
        for (int j = 1; j <= N; j++) {  
            matrix[i][j] == 1 ? printf("%c ", 2) : printf(". ");  
        }  
        cout << endl;  
    }  
    cout << endl;  
}  
  
void Trial(const int i)  
{  
    //  进入本函数时，在N*N的棋盘前i-1行已放置了互不攻击的i-1个棋子  
    //  现从第i行起继续为后续棋子选择合适位置  
  
    if (i > N)   //  输出当前的合法布局  
        Print(matrix);  
    else  
        for (int j = 1; j <= N; ++j) {  
            matrix[i][j] = 1;  
            if ( IsLegal(matrix, i, j) )  
                Trial(i + 1);  
            matrix[i][j] = 0;  
        }  
}  
  
int main(void)  
{  
    Trial(1);  
  
    return 0;  
}  

?关于内层for循环j<=i-1，因为判断第i个棋子是否冲突（摆放是否合理），我们只需要和前面i-1列校对就ok了。这样也保证了,i>j的恒成立。所以对角线冲突了简化了一下