【八皇后问题】 回溯算法

回溯算法：
回溯算法实际上是一个类似枚举的搜索尝试方法，它的思想是在搜索尝试中寻找问题的解，当发现不满足求解条件时，就“回溯”返回，尝试别的路径。之前介绍的基础算法中的贪婪算法，动态规划等都具有“无后效性”，也就是在分段处理问题时，某状态一旦确定，将不再改变。而多数问题很难找到"无后效性”的阶段划分和相应决策，而是通过深入搜索尝试和回溯操作完成的。

八皇后问题：8*8的国际象棋棋盘中放八个皇后，是任意两个皇后不能互相吃掉。规则：皇后能吃掉同一行，同一列，同一对角线的任意棋子。

模型建立：不妨设八个皇后分别在第i行，那么解空间就是一个八个皇后所在列的序号，为n元一维向量（x1，x2，x3，x4，x5，x6，x7，x8），搜索空间是1<=Xi<=8,共8^8个状态。但正如之前所说，回溯法采用“走不通就掉头”，故实际算法不必搜索那么多的状态，例如，（1，1，x3，x4，x5，x6，x7，x8）的状态共有8^6个，由于1,2皇后不能在同一列，那么这8^6个状态是不会搜索的。

算法设计1：加约束条件的枚举算法
约束条件有三个：
不在同一列（Xi不等于Xj）
不在同一主对角线（Xi-i不等于Xj-j）
不在同以负对角线（Xi+i不等于Xj+j）
后两项可合并为fabs（Xi-Xj）不等于fabs(i-j)
那么直接贴代码了（此处代码较多，故以4皇后为例）

#include <iostream>
#include <cmath>
#include <cstdio>
using namespace std;
int check(int a[],int n);
int main()
{
    int a[9],i;
    for(a[1]=1;a[1]<=4;a[1]++)
    {
        for(a[2]=1;a[2]<=4;a[2]++)
        {
            if(check(a,2)==0)continue;
            for(a[3]=1;a[3]<=4;a[3]++)
            {
                if((check(a,3)==0))continue;
                for(a[4]=1;a[4]<=4;a[4]++)
                {
                    if(check(a,4)==0)continue;
                    else {for(i=1;i<=4;i++)
                             cout << a[i]<< ‘ ‘;
                             cout << endl;}
                }
            }
        }
    }
    return 0;
}
int check(int a[],int n)
{
    int i;
    for(i=1;i<=n-1;i++)
    {
        if(fabs((double)(a[i]-a[n]))==fabs((double)(i-n))||a[i]==a[n])return 0;
    }
    return 1;
}

运行结果：
2  4  1  3
3  1  4  2

八皇后问题模版（非递归回溯算法）

#include <iostream>
#include <cmath>
using namespace std;
int a[20],n,cnt=0;
void backdate(int n);
int check(int k);
void output(int);
int main()
{
    cin >> n;
    backdate(n);
    return 0;
}
void backdate(int n)
{
    int k;
    a[1]=0;
    k=1;
    while(k>0)
    {
        a[k]++;
        while( (a[k]<=n) && (check(k)==0) ) //为第k个皇后搜索位置
        {
            a[k]++;
        }
        if(a[k]<=n)
        {
            if(k==n)    //找到一组解
                output(n);
            else
            {
                k=k+1;    //前k个皇后找到位置，继续为第k+1个皇后找到位置
                a[k]=0;    //注意下一个皇后一定要从头开始搜索
            }
        }
        else k=k-1;      //回溯（务必留意，此算法精华尽在于此！）
    }
}
int check(int k)
{
    int i;
    for(i=1;i<=k-1;i++)
    {
        if(fabs((double)(a[i]-a[k]))==fabs((double)(i-k))||a[i]==a[k])
            return 0;
    }
    return 1;
}
void output(int)
{
    int i;
    cnt++;  //测试用格外加的计数器
    for(i=1;i<=n;i++)
    {
        cout << a[i] << ‘ ‘;
    }
        cout << cnt << endl;
}

运行结果：
4（enter|）
2  4  1  3
3  1  4  2