八皇后问题

八皇后问题，是一个古老而著名的问题。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。 高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。计算机发明后，有多种计算机语言可以解决此问题。

思路

对于八皇后的求解可采用回溯算法，从上至下依次在每一行放置皇后，进行搜索，若在某一行的任意一列放置皇后均不能满足要求，则不再向下搜索，而进行回溯，回溯至有其他列可放置皇后的一行，再向下搜索，直到搜索至最后一行，找到可行解，输出。

可以使用递归函数实现上述回溯算法。

然而网上给出的代码，太过于粗糙，我用自己的大白话给大家解释一下。

首先呢，该选取什么样是数据结构？

最直接的方式是选用二维数组，用一个二维数组表示一张棋盘，简单而直观，下面看一下二维数组递归求解的代码，我会给出详细飞注解。
。
1.    #include <stdlib.h>
2.    #include <stdio.h>
3.   
4.    int m[8][8] = {0};//表示棋盘，初始为0，表示未放置皇后，1表示该位置放置了一个皇后
5.    int num = 0;//解数目
6.   
7.    //对于棋盘前row-1行已放置好皇后
8.    //检查在第row行、第column列放置一枚皇后是否可行

//直观上，我们该怎样检查，在某一个位置放置一个旗子是否正确？

//由于我们是默认的递归方式，已经确保了每一行中只能放置一个旗子（只能有一个1，不是吗？仔细想想）

//那在仔细想想，我们其他的检查条件是什么？，是不是，检查每一列，斜向上（两种方式）是否只有一个1？

//好，看一下代码中如何体现这种思想？
9.    bool check(int row,int column)
10.   {
11.       if(row==1) return true;
12.       int i,j;
13.       //纵向只能有一枚皇后
14.       for(i=0;i<=row-2;i++)
15.       {
16.           if(m[i][column-1]==1) return false;
17.       }
18.       //左上至右下只能有一枚皇后

//row-column是什么意思？右斜向下，row，和column之间有什么关系？发现规律了吗？

19.       i = row-2;
20.       j = i-(row-column);
21.       while(i>=0&&j>=0)
22.       {
23.           if(m[i][j]==1) return false;
24.           i--;
25.           j--;
26.       }
27.       //右上至左下只能有一枚皇后

//右上至左下，他们的row和column之间有什么规律？发现规律了吗
28.       i = row-2;
29.       j = row+column-i-2;
30.       while(i>=0&&j<=7)
31.       {
32.           if(m[i][j]==1) return false;
33.           i--;
34.           j++;
35.       }
36.       return true;
37.   }
38.  
39.   //当已放置8枚皇后，为可行解时，输出棋盘

//两行for循环，解决问题
40.   void output()
41.   {
42.       int i,j;
43.       num++;
44.       printf("answer %d:\n",num);
45.       for(i=0;i<8;i++)
46.       {
47.           for(j=0;j<8;j++) printf("%d ",m[i][j]);
48.           printf("\n");
49.       }
50.   }
51.  
52.   //采用递归函数实现八皇后回溯算法
53.   //该函数求解当棋盘前row-1行已放置好皇后，在第row行放置皇后
54.   void solve(int row)
55.   {
56.       int j;
57.       //考虑在第row行的各列放置皇后
58.       for (j=0;j<8;j++)
59.       {
60.           //在其中一列放置皇后
61.           m[row-1][j] = 1;
62.           //检查在该列放置皇后是否可行
63.           if (check(row,j+1)==true)
64.           {
65.               //若该列可放置皇后，且该列为最后一列，则找到一可行解，输出
66.               if(row==8) output();
67.               //若该列可放置皇后，则向下一行，继续搜索、求解
68.               else solve(row+1);
69.           }
70.           //取出该列的皇后，进行回溯，在其他列放置皇后

//这一行是回溯，仔细想想
71.           m[row-1][j] = 0;
72.       }
73.   }
74.  
75.   //主函数
76.   int main()
77.   {
78.       //求解八皇后问题
79.       solve(1);
80.       return 0;
81.   }

代码看到这里，相信大部分人都已经看明白了。

然而，网上还有更简单的版本，能不能用一个以为数组表示棋盘呢？答案是肯定的

来，那看一下，更简洁的版本

  a）定义全局堆栈和打印函数

 static int gEightQueen[8] = {0};
 //这个数组是什么意思？加入一个棋盘中，每一个棋子的位置可以用row和column表示
 //row可以用递归的深度表示，column自然可以用一个数组表示，column=gEightQueen[row],
 //在下面代码中，row=index;
 static int gCount = 0;
 //gCount表示找到个数。

 void print()
 {
     int outer;
     int inner;

     for(outer = 0; outer <8; outer ++){
         for(inner = 0; inner < gEightQueen[outer]; inner ++)
             printf("* ");

         printf("# ");

         for(inner = gEightQueen[outer] + 1; inner < 8; inner ++)
             printf("* ");

         printf("\n");
     }

     printf("=====================================\n");
 }

     b）添加位置合法性的函数判断

 int check_pos_valid(int loop, int value)
 {
     int index;
     int data;

     for(index = 0; index < loop; index ++){
         data = gEightQueen[index];

 //有了上面的铺垫，if的判断条件，是什么意思呢？检查每一列是否只有一个1，不是吗？
         if(value == data)
             return 0;
   //是不是和二维数组判断条件，有些相似？
         if((index + data) == (loop + value))
             return 0;
   //这个相信都能看懂
         if((index - data) == (loop - value))
             return 0;
     }

     return 1;
 }

     c） 八皇后遍历

 void eight_queen(int index)
 {
     int loop;

     for(loop = 0; loop < 8; loop++){
         if(check_pos_valid(index, loop)){
             gEightQueen[index] = loop;

             if(7 == index){
                 gCount ++, print();
                 gEightQueen[index] = 0;
                 return;
             }

             eight_queen(index + 1);
             gEightQueen[index] = 0;
         }
     }
 }

总结：

    （1）迭代递归是编程的难点，需要自己好好实践，看别人写一百遍，不如自己写一遍

    （2）递归的时候务必注意函数return的出口

    （3）递归函数中语句的顺序不要随意更换

    （4）递归函数中注意数据的保存和恢复

    （5）递归函数也要验证，可以用程序验证法，也可以用其他函数的结果来验证


ps:

    下面是完整的代码，大家可以直接保存成queue.cpp，直接编译运行即可。可以打印出所有92种情况，

 #include <iostream>
 using namespace std;

 static int gEightQueen[8] = {0};
 static int gCount = 0;


 void print()
 {
     int outer;
     int inner;

     for(outer = 0; outer <8; outer ++){
         for(inner = 0; inner < gEightQueen[outer]; inner ++)
             printf("* ");

         printf("# ");

         for(inner = gEightQueen[outer] + 1; inner < 8; inner ++)
             printf("* ");

         printf("\n");
     }

     printf("=====================================\n");
 }

 int check_pos_valid(int loop, int value)
 {
     int index;
     int data;

     for(index = 0; index < loop; index ++){
         data = gEightQueen[index];

         if(value == data)
             return 0;

         if((index + data) == (loop + value))
             return 0;

         if((index - data) == (loop - value))
             return 0;
     }

     return 1;
 }



 void eight_queen(int index)
 {
     int loop;

     for(loop = 0; loop < 8; loop++){
         if(check_pos_valid(index, loop)){
             gEightQueen[index] = loop;

             if(7 == index){
                 gCount ++, print();
                 gEightQueen[index] = 0;
                 return;
             }

             eight_queen(index + 1);
             gEightQueen[index] = 0;
         }
     }
 }



 int main(int argc, char* argv[])
 {
     eight_queen(0);
     printf("total = %d\n", gCount);
     return 1;
 }