C语言解决八皇后问题

 #include <stdio.h>
 #include <stdlib.h>

 /* this code is used to cope with the problem of the eight queens.
  * array borad[9][9] is a virtual borad.
  * line 0 and volumn 0 is ignored.
  * at first we find a place to set a queen on it, then mark this queen's
  * domain. the way of marking domain is add 1 on the board[line][volumn],
  * so the number of board[line][volumn] means this place can attacked by
  * how many queens. after we mark this queen's domain, we move on to next line.
  * if there is no next line, we got a solution */
 /* 这些代码主要用来解决八皇后问题
  * 数组borad[9][9]是一个虚拟的棋盘。
  * 第0行跟第0列被忽略
  * 在最开始时，我们在某一行上找到一个位置，放上皇后后，我们把这个皇后能
  * 攻击的范围都标志起来。我们标志的方法是在board[行][列]上加1，
  * 所以board[行][列]上的值意味着这个位置能被多少个皇后攻击
  * 当我们标志好这个皇后的范围后，我们就跳到下一行去。
  * 如果已经没有下一行了，那么我们就找到一个放置方法了 */

 /* if a place on board have been marked by NONE
  * it means no queen can attack this place, it is a potential place to set a queen */
 /* 如果棋盘上一个位置被设置为NONE，意味着没有皇后能攻击这个位置，这个位置可以被设置为皇后 */
 #define NONE        (0)
 #define QUEEN       (-1)

 #define OCCUPY      (1)
 #define DISOCCUPY   (0)

 void Compute(int line) ;
 void PrintBorad(void) ;
 void operate_borad(int line, int volumn, int function) ;

 int main(void)
 {
     Compute() ;
     return  ;
 }

 /* ignored the first line and the first volumn */
 int borad[][] ;

 /* this is a recursive function.
  * it will find a queen on this line,
  * then fine next one of next line by call itself */
 /* 这是一个递归函数。在某一行上找到皇后的位置，然后调用自己找下一行的皇后 */
 void Compute(int line)
 {
     int i ;
     static int num_of_solution = ;

     for(i = ; i <= ; i++)
         if(borad[line][i] == NONE)
         {
             operate_borad(line, i, OCCUPY) ;
             if(line == ) // find a solution
             {
                 printf("%d\n", ++num_of_solution) ;
                 PrintBorad() ;
             }
             else Compute(line +) ; /* contine to next line */ /* 查找一行的皇后 */
             operate_borad(line, i, DISOCCUPY) ;
         }
 }

 /* function:
  * if function is OCCUPY, then set a flag of queen on borad[line][volumn]
  *   and set a flag on the domain of this queen
  * if function is DISOCCUPY, then clear flag of queen on borad[line][volumn]
  *   and clear the flag on the domain of this queen */
 /* 功能：
  * 如果function变量是OCCUPY，那么在board[line][volumn]上放上皇后，
  * 并设置这个皇后的攻击范围
  * 如果function变量是DISOCCUPY,那么把皇后从board[line][volumn]上清除
  * 并清除这个皇后在其攻击范围上所设置的标志 */
 void operate_borad(int line, int volumn, int function)
 {
     int i, j, *temp, nl, nv ;

     borad[line][volumn] = (function == OCCUPY ? QUEEN : NONE) ;

     /* i and j are used to decide the direction*/
     for(i = -; i <= ; i++)
         for(j = -; j <= ; j++)
             if(i ==  && j == ) continue ;
             else
             for(nl = line +i, nv = volumn +j ;
                 nl >=  && nl <=  && nv >=  && nv <=  ;
                 nl += i, nv += j)
             {
                 temp = &borad[nl][nv] ;
                 /* add one means this place can be attack by another queen */
                 function == OCCUPY ? (*temp)++ : (*temp)-- ;
             }
 }
 /* function: print the board on the screen */
 /* 打印棋盘 */
 void PrintBorad(void)
 {
     int x, y, chess ;

     for(x = ; x <= ; x++)
     {
         for(y = ; y <= ; y++)
         {
             chess = borad[x][y] ;
             if(chess != QUEEN)
                 putchar('*') ;
             else
                 putchar('Q') ;
         }
         putchar('\n') ;
     }
 }