八皇后问题



8皇后问题：如何在8 x 8的国际象棋棋盘上安排8个皇后，使得没有两个皇后能互相攻击？( 如果两个皇后处在同一行、同一列或同一条对角线上，则她们能互相攻击。）

解向量为长度为8的数组，记为solution。因为共有8个皇后，而棋盘刚好为8*8，所以每一行肯定会有一个皇后，那么我们约定solution[i]表示第i+1个皇后放在第i+1行的第几列。solution中的列从1开始记。

回溯算法的思路是对问题的状态空间树进行深度优先搜索，树的每一层节点代表了对解的每一个分量所做的选择。如果该节点表示的选择符合要求，那么继续向下搜索，否则，尝试下一个选择。如果该层的所有选择都已经尝试过，那么我们向上回溯。

递归版本：

01.void eight_queue_recursive( int *solution, int dimension, int row )  
02.{//dimension表示棋盘的维数，row表示放置第几行的皇后  
03.  
04.       if( row > dimension ) return;  
05.        int i;  
06.       for( i = 0; i < dimension; ++i )//尝试每一列  
07.       {  
08.               solution[row-1] = i+1;  
09.               if( if_valid( solution, row ) )//如果合法  
10.               {  
11.                        if( row < dimension )//还有皇后没放  
12.                                eight_queue_recursive( solution, dimension, row+1 );  
13.                       else  
14.                                print( solution, dimension );  
15.               }  
16.               solution[row-1] = 0;  
17.        }  
18.}  

迭代版本

01.void eight_queue( int *solution, int dimension )  
02.{  
03.        int k = 0;//k表示第几个皇后  
04.        while( k >= 0 )//要判断k是否>0  
05.        {     
06.                while( solution[k] < dimension )//判断k是否会超过dimension  
07.                {     
08.                        solution[k]+=1;  
09.                        if( if_valid( solution, k+1 ) )   
10.                        {     
11.                                if( k < (dimension-1) )  
12.                                        ++k;  
13.                                else  
14.                                        print( solution, dimension );  
15.                        }     
16.                }     
17.                solution[k] = 0;//回溯  
18.                --k;  
19.        }     
20.}