八皇后

最新推荐文章于 2020-06-21 17:04:46 发布

原创最新推荐文章于 2020-06-21 17:04:46 发布 · 1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#回溯 #递归

递归||回溯||分治专栏收录该内容

14 篇文章

订阅专栏

本文详细介绍了八皇后问题的回溯算法求解过程，包括递归和非递归两种方法，并通过代码实现展示了如何使用这些算法解决八皇后问题。文中还提供了优化方法和排列树搜索技巧，帮助读者深入理解并应用回溯算法。

八皇后（可以扩展为N皇后问题）

每行每列每个对角线都不允许有两个或两个以上的皇后

回溯，递归求解

#include<iostream>/// 八皇后
#include<cstdio>
using namespace std;
int c[10]; /// 第i行 列为a[i]
int total;
int n;
/// 在一条主对角线上 则它们的 x-y相同   y=x+b
/// 在一条负对角线上 则它们的 x+y相同   y=-x+b
int v[3][100]; /// v[0]列   v[1]主对角线  v[2]负对角线

int dfs_1(int cur) // 填充第cur行
{
    if(cur==n){
            total++;
            //for(int i=0;i<n;i++)
            //    printf("%d %d\n",i,c[i]);
            //puts("\\\\");
    }
    else{
        for(int i=0;i<n;i++){// 列
            int ok=1;
            for(int j=0;j<cur;j++)//行
                if(c[j]==i||cur-j==i-c[j]||cur-j==c[j]-i) // 存在两元素在 同一列 或对角线
                      ok=0;          // or if(c[j]==i||abs(cur-j)==abs(i-c[j]))
            if(ok){//puts("[]");
                c[cur]=i;
                dfs_1(cur+1);
            }
        }
    }
}

/// 优化
int dfs_2(int cur) // 填充第cur行
{
    if(cur==n){
            total++;
            //for(int i=0;i<n;i++)
            //    printf("%d %d\n",i,c[i]);
            //puts("\\\\");
    }
    else{
        for(int i=0;i<n;i++){// 列,即第cur个皇后放在第i列上
            if(!v[0][i]&&!v[1][cur-i+n]&&!v[2][cur+i]){  // 第cur行第i个列的同列，主对角线，副对角线上均没有元素
                v[0][i]=v[1][cur-i+n]=v[2][cur+i]=1;
                c[cur]=i;
                dfs_2(cur+1);
                v[0][i]=v[1][cur-i+n]=v[2][cur+i]=0;
            }
        }
    }
}

void swap_(int a,int b)
{
    int t = c[a];
    c[a] = c[b];
    c[b] = t;
}
/// 排列树搜索八皇后
int dfs_3(int cur) // 填充第cur行
{
    if(cur > n){
        total++;
    }
    else{
        for(int i = cur ; i <= n ; i ++ ) {// 列,即第cur个皇后放在第i列上
            swap_(i , cur) ;
            if(!v[1][cur-c[cur]+n]&&!v[2][cur+c[cur]]){  // 主对角线，副对角线上均没有元素
                v[1][cur-c[cur]+n] = v[2][cur+c[cur]]=1;
                dfs_3(cur+1);
                v[1][cur-c[cur]+n] = v[2][cur+c[cur]]=0;
            }
            swap_(i , cur) ;
        }
    }
}


int main()
{
    total=0;
    n=8;
    dfs_1(0);
    cout<<total<<endl;

    total=0;
    dfs_2(0);
    cout<<total<<endl;

    for (int i = 1 ; i <= n ; i ++ )
        c[i] = i ;
    total=0;
    dfs_3(1);
    cout<<total<<endl;
    return 0;
}

回溯，非递归求解

#include<iostream> // 非递归求解
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
#define MAX 100

int is(int* c,int k)
{
    int i;
    for(i=1;i<k;i++)
        if(c[k]==c[i]||abs(i-k)==abs(c[k]-c[i]))
          return 0;
    return 1;
}


int main()
{
    int c[MAX];
    int N,i,j,k,case_=0;
    puts("输入皇后个数");
    scanf("%d",&N); // N皇后

    for(j=1;j<=N;j++)
        c[j]=0;

    i=1;
    while(i>=1){
        c[i]=c[i]+1;
        while(c[i]<=N&&!is(c,i))
            c[i]=c[i]+1;


        if( c[i]<=N ){// 找到
            if(i==N) {
                printf("Case %d \n",++case_);
                for (k = 1 ; k <= N ; k ++) {
                    for(j = 1 ; j <= N ; j ++) {
                        if (c[k] == j) printf("* ");
                        else printf("- ");
                    }
                puts("");
                }
            }
            else {
                i++;
                c[i] = 0; //从新开始找
            }
        }
        else{//回溯
            i=i-1;
        }
    }
    printf("%d\n",case_);

    return 0;
}