回溯法-排列树-n皇后问题

N皇后问题: 在一个N*N的棋盘上放置N个皇后，每行一个并使其不能互相攻击（同一行、同一列、同一斜线上的皇后都会自动攻击）。

思路:首先要确定皇后间位置合法的检验表达式。

((abs(i-k)==abs(x[i]-x[k]))||x[i]==x[k])     //x[i]表示i皇后在第x[i]列;abs(i-k)==abs(x[i]-x[k])表示两皇后在同一对角线上。

然后每第i皇后在第i行有n个列位置供选择。检验其位置是否合法。合法将第i皇后位置确定下来。探索下一皇后位置。当所有皇后探索完后,若能到达叶子节点(t>n), 则确定一种排列情况。依次回溯讨论所有的排列情况。(PS:这里用递归写出,文章最后介绍一种解n皇后问题的高效方法)

代码:

/**
   @回溯法-n皇后问题
*/
#include<iostream>
#include<algorithm>
#define MAX 100
int n;           //皇后个数
int x[MAX];     //列号     x[i]:表示第i个皇后在第i行,x[i]列
long sum = 0;  //可行解个数
using namespace std;
int place(int k){
   for(int i = 1;i<k;i++){      //排除皇后在同行,同列,对角线情况
       if((abs(i-k)==abs(x[i]-x[k]))||x[i]==x[k]){
           return 0;
       }
   }
   return 1;
}
void backpack(int t){
    if(t>n){                         //到达"叶子"节点,确定一种排列情况
        sum++;
        /*输出可行的皇后排列*/
        int a[MAX][MAX] = {0};    
        for(int i = 1;i<=n;i++){
            a[i][x[i]] = x[i];      //将i皇后在第i行,x[i]列标记在a矩阵中
        }
        cout<<"排列情况"<<sum<<"为:"<<endl;
        for(int i = 1;i<=n;i++){
           for(int j = 1;j<=n;j++){
               cout<<a[i][j]<<" ";
           }
               cout<<endl;
        }
        cout<<endl;
    }else{
        for(int i = 1;i<=n;i++){       //t皇后在第t行有(1~n)列供选择
           x[t] = i;                    
           if(place(t)){              //第t皇后的排列可行,深度探索下一皇后
               backpack(t+1);  
           }
        }
    }
}
int main(){
    cout<<"输入皇后个数:"<<endl;
    cin>>n;
    backpack(1);
    cout<<n<<"皇后排列总有"<<sum<<"种"<<endl;
    return 0;
}

参考博客:https://blog.csdn.net/hacker00011000/article/details/51582300

#include "iostream"
#include "time.h"
#include "cstdio"
#include "cstdlib"
using namespace std;
// sum用来记录皇后放置成功的不同布局数；upperlim用来标记所有列都已经放置好了皇后。
long sum = 0;
long upperlim = 1;
// 试探算法从最右边的列开始。
void test(long row, long ld, long rd)
{
    if (row != upperlim)
    {
        // row，ld，rd进行“或”运算，求得所有可以放置皇后的列,对应位为0，
        // 然后再取反后“与”上全1的数，来求得当前所有可以放置皇后的位置，对应列改为1
        // 也就是求取当前哪些列可以放置皇后
        long pos = upperlim & ~(row | ld | rd);
        while (pos)    // 0 -- 皇后没有地方可放，回溯
        {
            // 拷贝pos最右边为1的bit，其余bit置0
            // 也就是取得可以放皇后的最右边的列
            long p = pos & -pos;

            // 将pos最右边为1的bit清零
            // 也就是为获取下一次的最右可用列使用做准备，
            // 程序将来会回溯到这个位置继续试探
            pos -= p;

            // row + p，将当前列置1，表示记录这次皇后放置的列。
            // (ld + p) << 1，标记当前皇后左边相邻的列不允许下一个皇后放置。
            // (ld + p) >> 1，标记当前皇后右边相邻的列不允许下一个皇后放置。
            // 此处的移位操作实际上是记录对角线上的限制，只是因为问题都化归
            // 到一行网格上来解决，所以表示为列的限制就可以了。显然，随着移位
            // 在每次选择列之前进行，原来N×N网格中某个已放置的皇后针对其对角线
            // 上产生的限制都被记录下来了
            test(row + p, (ld + p) << 1, (rd + p) >> 1);
        }
    }
    else
    {
        // row的所有位都为1，即找到了一个成功的布局，回溯
        sum++;
    }
}

int main(int argc, char *argv[])
{
    time_t tm;
    int n  = 14;

    if (argc != 1)
        n = atoi(argv[1]);
    tm = time(0);

    // 因为整型数的限制，最大只能32位，
    // 如果想处理N大于32的皇后问题，需要
    // 用bitset数据结构进行存储
    if ((n < 1) || (n > 32))
    {
        printf(" 只能计算1-32之间\n");
        exit(-1);
    }
    printf("%d 皇后\n", n);
    // N个皇后只需N位存储，N列中某列有皇后则对应bit置1。
    upperlim = (upperlim << n) - 1;
    test(0, 0, 0);
    printf("共有%ld种排列, 计算时间%d秒 \n", sum, (int) (time(0) - tm));
    system("pause");
    return 0;
}

回溯法-排列树-n皇后问题

猜你喜欢