n皇后问题

n皇后问题是递归和回溯法的一个典型应用。问题描述如下：对于一个n×n的棋盘，要求在其中放入互不攻击的n个皇后。皇后的攻击范围包括：

1) 同一行

2) 同一列

3) 同一对角线（包括两个方向）

分析后可见，皇后之间互不攻击当且仅当满足下列条件：

1) 每一行只能有一个皇后

2) 每一列只能有一个皇后

3) 任意条对角线上面只能有一个皇后

若按照从左到右从上到下的顺序手动摆放皇后，会发现算法遵循的是回溯法的思想。于是我们遵循top-down design的顺序来设计整个算法和程序。

采用OOP的思想，先假设存在一个·表示棋盘格局的类queens，则定义回溯函数solve_from(queens configuration)，configuration表示当前棋盘格局，算法不断扩展棋盘的当前格局（找到下一个非冲突位置），当找到一个解决方案时打印该方案。该递归函数采用回溯法求出所有解。main函数调用solve_from时传递的实参是一个空棋盘。

对于模拟棋盘的queens类，我们可以定义三个数据成员：

1) size：棋盘的边长，即大小

2) count：已放置的互不冲突的皇后数

3) array[][]：布尔矩阵，true表示当前格有皇后

这里需要稍加思考以便稍后可以简化程序：因为每行只能放一个皇后，从上到下，从左到右放，那么count个皇后占用的行为0——count－1。所以count还表示下一个皇后应该添加在哪一行。这样，add和remove操作的入口参数就只需要提供列号就行了，降低了耦合度：）

为了模拟棋盘操作，应该至少提供以下方法：

1) 初始化一个size大小的空棋盘queens(int size)

2) 插入一个非冲突的皇后add( int col )

3) 删除最新插入的皇后remove( int col )

4) 判断要插入的皇后是否与已存在的棋盘格局相冲突bool guarded( int col )

5) 判断是否棋盘已满bool finished( )

6) 若棋盘已满则打印棋盘格局print()

于是solve_from定义如下：

void solve_from( queens &configuration )

{

if( configuration.finished() )

configuration.print();

else

for( int i=0; i

if( !configuration.guarded( i ) )

{

configuration.add( i );

solve_from(configuration);

configuration.remove( i );

}

}

queens的方法实现如下：

static const int MAX_SIZE = 20

queens::queens( const int & size )

{

for( int i=0; i

for( int j=0; j

array[ i ][ j ] = false;

this->size = size;

count = 0;

}

void queens::add( const int & col )

{

array[ count++ ][ col ] = true;

}

void queens::remove( const int & col )

{

array[ --count ][ col ] = false;

}

关于guarded还有一点说明：

由于回溯法中的剪枝函数configuration.remove保证了每行只有一个皇后，我们是需要判断列冲突与对角线冲突的情况。而且由递归的顺序是从上到下从左到右，所以我们也不需要判断下方的列和对角线，也就是说只要判断三个方向：

current——top

current——upper-left

current——upper-right

工作量就减少了一半以上。

bool queens::guarded( const int & col )

{

bool gu = false;

// current——top

for( int i=0; !gu&&i

gu = array[ i ][ col ];

// current——up-left

for( i=1; !gu&&(count-i>=0)&&(col-i>=0); i++ )

gu = array[ count-i ][ col-i ];

// current——up-right

for( i=1; !gu&&(count-i>=0)&&(col+i<=size; i++ ) gu = array[ count-i ][ col+i ];

return gu;

}

bool queens::finished()

{

return count

}

bool queens::print()

{

static int num = 0;

++num;

cout<<"solution "<

for( int i=0; i

{

for( int j=0; j

cout<

cout<

}

cout<

}

#include

#include

#include

#define QUEENS 8

//!记录解的序号的全局变量。

int iCount = 0;

//!记录皇后在各列上的放置位置的全局数组。

int Site[QUEENS];

//!递归求解的函数。

void Queen(int n);

//!输出一个解。

void Output();

//!判断第n个皇后放上去之后，是否有冲突。

int IsValid(int n);

/*----------------------------Main：主函数。----------------------------*/

void main()

{

//!从第0列开始递归试探。

Queen(0);

//!按任意键返回。

getch();

}

/*-----------------Queen：递归放置第n个皇后，程序的核心!----------------*/

void Queen(int n)

{

int i;

//!参数n从0开始，等于8时便试出了一个解，将它输出并回溯。

if(n == QUEENS)

{

Output();

return;

}

//!n还没到8，在第n列的各个行上依次试探。

for(i = 1 ; i <= QUEENS ; i++)

{

//!在该列的第i行上放置皇后。

Site[n] = i;

//!如果放置没有冲突，就开始下一列的试探。

if(IsValid(n))

Queen(n + 1);

}

}

/*------IsValid：判断第n个皇后放上去之后，是否合法，即是否无冲突。------*/ int IsValid(int n)

{

int i;

//!将第n个皇后的位置依次于前面n－1个皇后的位置比较。

for(i = 0 ; i < n ; i++)

{

//!两个皇后在同一行上，返回0。

if(Site[i] == Site[n])

return 0;

//!两个皇后在同一对角线上，返回0。

if(abs(Site[i] - Site[n]) == (n - i))

return 0;

}

//!没有冲突，返回1。

return 1;

}

/*------------Output：输出一个解，即一种没有冲突的放置方案。------------*/ void Output()

{

int i;

//!输出序号。

printf("No.%-5d" , ++iCount);

//!依次输出各个列上的皇后的位置，即所在的行数。

for(i = 0 ; i < QUEENS ; i++)

printf("%d " , Site[i]);

printf("\n");

}

#include

#include

#include

using namespace std;

int *position; //放置的位置

int queen; //皇后数目

int count; //第N种可能性

//判断第n行是否放置皇后

bool SignPoint(int n)

{

for (int i=0;i

{

if (*(position+i) == *(position+n)) //该列已经放置过皇后了

return false;

if (abs(*(position+i) - *(position+n)) == n-i) //对角线已经放置过了

return false;

}

return true;

}

//设置皇后

void SetQueen(int n=0)

{

if (queen==n)

{

//该处可以改成自己想要的显示方式

printf("NO.%d: ",++count);

printf("\n");

for (int i=0;i

{

for (int j=0;j

{

if (j == position[i])

{

printf("* ");

}

else

{

printf("0 ");

}

}

printf("\n");

}

printf("\n");

return;

}

else

{

for (int i=0;i

{

position[n] = i;

if(SignPoint(n))//如果该位置放置皇后正确的话,则到下一行

{

SetQueen(n+1);

}

}

}

}

int main(int argc, char argv[])

{

cout<<"请输入皇后的总数:"<

cin>>queen;

position = (int*)malloc(sizeof(int));

SetQueen();

cout<<"摆放完毕"<

cin.get();

cin.get();

return 0;

}

八皇后算法c++源程序

#include

using namespace std;

#include

#include

#include

#define QUEENS 8 //改变QUEENS的值可以设置棋盘

int iCount=0; //!记录解的序号的全局变量。

int Site[QUEENS]; //!记录皇后在各列上的放置位置的全局数组。void Queen(int n); //!递归求解的函数。

void Output(); //!输出一个解。

int IsValid(int n); //!判断第n个皇后放上去之后，是否有冲突。

/*----------------------------Main：主函数。

----------------------------*/

void main()

{

Queen(0); //!从第0行开始递归试探。

//getch();

system("pause"); //!按任意键返回。

}

/*-----------------Queen：递归放置第n个皇后，程序的核

心!----------------*/

void Queen(int n)

{

int i;

if(n==QUEENS) //!参数n从0开始，等于8时便试出了一个解，将它输出并回溯。

{

Output();

return;

}

for(i=1;i<=QUEENS;i++) //!n还没到8，在第n行的各个列上依次试探。{

Site[n]=i; //!在该行的第i列上放置皇后。

if(IsValid(n)) //!如果放置没有冲突，就开始下一行的试探。

Queen(n+1);

}

}

/*------IsValid：判断第n个皇后放上去之后，是否合法，即是否无冲突。------*/

int IsValid(int n)

{

int i;

for(i=0;i

{

if(Site[i]==Site[n]) //!两个皇后在同一列上，返回0。

return 0;

if(abs(Site[i]-Site[n])==(n-i)) //!两个皇后在同一对角线上，返回0。

return 0;

}

return 1; //!没有冲突，返回1。

}

/*------------Output：输出一个解，即一种没有冲突的放置方案。

------------*/

void Output()

{

int i;

int j;

int n;

cout<<"输出的结果为：(数字结果显示为每一行的第几列)"<

cout<< endl;

cout<<"No."<<++iCount<<" 解法"<<" ";

for(i=0;i

cout<

cout<< endl;

cout<< endl;

cout<<"按任意键输出图形";

getch();

cout<< endl;

cout<< endl;

for(i=0;i

{

{n=Site[i];

for(j=1;j<=QUEENS;j++)

if(j==n)

cout<<"☆"<<" ";

else cout<<"■"<<" ";

}

cout<

}

cout<< endl;

system("pause");

system("cls"); }