简单的8皇后问题。
目录：
1. 八皇后问题的递归解法。
2. 八皇后问题的非递归解法。 回溯法
3. 跳马问题的递归解法。
八皇后和跳马问题都属于AI（人工智能）范畴，这两个问题比较简单，属于计算机穷举。
而且这两个问题又都属于搜索问题。就是试探并记录下试探的步伐，最后输出正确的结果。
先分析一下八皇后问题。
题目一看就是递归，因为问题描述可以表示为在第k层放好的情况下，放第k+1个皇后，使与
前面的不相冲突。
好，现在分析第k+1层。
1. 若k+1层==9， 表示搜索已经结束，打印结果，返回。
2. 否则，在8个行上试探，若本行，无皇后，正对角线无皇后，斜对角线无皇后，在该处放置皇后。
3. 递归到下一层。
问题虽然描述清了，但还不能写代码，还要继续分析细化。
1. 打印结果，那么结果是什么 ？ 我们可以用1个2维数组来表示棋盘，当放上皇后用1表示，不放
皇后用0表示，很形象，对吗。打印的时候，你甚至可以打出图形来。
2. 怎样判断a[i][j]这个点能否放皇后，这是问题的关键。
四个条件，本行，本列，对角线和反对角线
可以简化为3个条件，把本列去掉，因为我们只在这列放一个。这列放不下，我们就回溯。我们
还要在这1到8行上逐一试探。
1. 要保证本列上无皇后。应该是调用一个函数。whether_this_row_has_queen(column). 返回布尔值。
不过这个函数还是要查寻一个数组，如果这个数组元素值为1，返回true, 否则，返回false.
这个数组，叫ROW_OCCUPY 数组。 8 个元素。 当本行放置皇后时，要置位该元素。
2. 更复杂的是要保证对角线上无皇后。 它可以通过调用whether_reverse_diagonal_has_queen(row,column)
先看反对角线吧。考察普通笛卡尔坐标下的棋盘。（0，0）第一条线
（1，0）（0，1）第二条线 （2，0）（1，1）（0，2）第三条线...(7,0)..(0,7)第8条线
row+column 是常数，继续（7，1）..(1,7)为第9条线,第（7，7）为第15条线。
所以，我们可以用一个reverse_diagonal[15] 来表示，谁占用了，把相应的标志位置上。
3. 正对角线。看函数whether_the_diagonal_has_queen(row,column)
看（0，0）（1，1）。。(7,7)构成一条线。这是中间。row=column, row-column=0
向两边扩散也有2n-1条对角线。左上（0，7），然后（0，6）（1，7）... 直到（6，0）（7，1）最后
（7，0）.row-column 从-7 变到0再到+7， 为防止序号出现负数，可以加上一个基数7.
所以也可以设一个数组diagonal[15],占用了该对角线，
在该数组置标志。
3. 递归到下一层。 简单，层数加一就可以了，这个层数，可以用行号代替。
补充，逐行放而非逐列放是调试方便
据以上分析，整理数据结构和逻辑关系，可以写出c代码程序如下：
只有逻辑清楚，才能调试递归程序！！
错误的疏漏，会影响程序的逻辑！ 不调试的程序，full of mistake and wrong typewords etc.
/* author: hjjdebug
* date : 2009
*/
#include <stdio.h>
#include <stdlib.h>
int ans[8][8];
int col_occupy[8];
int diagonal_occupy[15];
int r_diagonal_occupy[15];
void queen(int row);
int main(void)
{
queen(0);
system("pause");
return 0;
}
void queen(int row)
{
int i,j;
if(row==8)
{
char c;
for(i=0;i<8;i++)
{ //print result (diagraph)
for(j=0;j<8;j++)
{
printf("%c ",c=(ans[i][j]==1) ? '*':'-');
}
printf("/n");
}
printf("Quit(q) ? ");
c=getchar();
if(c=='q')
exit(1);
return ;
}
//try 8 position
int column;
for(column=0;column<8;column++)
{// if this position is valid,hold it, recursive to next layer
if(col_occupy[column]==0&&diagonal_occupy[7+column-row]==0&&r_diagonal_occupy[row+column]==0)
{
ans[row][column]=1;
col_occupy[column]=1;
diagonal_occupy[7+column-row]=1;
r_diagonal_occupy[row+column]=1;
queen(row+1);
// back state to try next position
ans[row][column]=0;
col_occupy[column]=0;
diagonal_occupy[7+column-row]=0;
r_diagonal_occupy[row+column]=0;
}
}
// when all try, return;
}
递归实际上属于深度优先搜索算法。可以利用函数栈存储数据和利用函数返回实现自动回退。
; --------------------------------------------------------------------------------------
递归是使用了函数栈，实际上是隐含回溯。 这里给一个不用递归用循环的程序，看其怎样实现回溯，如下例：
是的，非递归不如递归简洁。 但其进退之间别有一番情趣！ 而且它还可以实现2级深度退却（依题意条件）。
还是迷宫退的深啊。
循环的退出条件是column 被逼回0，而不是通常的for 1 to 8 的结构，
有点新意， (有时间将详细介绍回溯的方法和思想） 下面程序不是很好，聊作参考吧。（有空再整理）
#include <stdio.h>
#include <stdlib.h>
#define MAXN 20
int good;
int ans[MAXN+1];
int a[MAXN+1];
int b[2*MAXN+1];
int c[2*MAXN+1];
int main()
{
int j;
int column=1;
int last_column=8;
for (j=0;j<=last_column;j++) a[j]=1;
for (j=0;j<=2*last_column;j++) b[j]=c[j]=1;
ans[1]=1;good=1;ans[0]=0;
do{
if (good)
{
if (column==last_column)
{ // print result
for (j=1;j<=last_column;j++)
{
printf("%d ",ans[j]);
}
printf("/n");
while (ans[column]==last_column)
{
column--; /*清除关于第column列，ans[column]行有皇后标志*/
a[ans[column]]=b[column+ans[column]]=c[last_column+column-ans[column]]=1;
}
ans[column]++; /*调整第column列的皇后配置*/
}
else /*在第column列，ans[column]行位置设定有皇后标志*/
{
a[ans[column]]=b[column+ans[column]]=c[last_column+column-ans[column]]=0;
ans[++column]=1; /*第column+1列，从第1行开始配置*/
}
}
else
{
while (ans[column]==last_column)
{
column--; /*清除关于第column-1列、ans[column-1]行有皇后标志*/
a[ans[column]]=b[column+ans[column]]=c[last_column+column-ans[column]]=1;
}
ans[column]++; /*调整第column列的皇后配置*/
}
good=a[ans[column]]&&b[column+ans[column]]&&c[last_column+column-ans[column]];
} while (column!=0); //column 从第1行开始，最后被逼回0行，表示完全搜索结束。
system("pause");
return 0;
}