递归回溯算法解决八皇后问题

函数递归调用，本质还是依托于栈，栈具有后进先出的特点，可以很好的实现回溯。

八皇后问题是典型的运用回溯思为解决问题的例子。

code：

#include <stdio.h>

#define N 8

typedef struct _tag_Pos
{
    int ios;
    int jos;
} Pos;

static char board[N+2][N+2];
static Pos pos[] = { {-1, -1}, {-1, 0}, {-1, 1} };
static int count = 0;

void init(void)
{
    int i = 0;
    int j = 0;
    
    for(i=0; i<N+2; i++)
    {
        board[0][i] = '#';//横边界
        board[N+1][i] = '#';//横边界
        board[i][0] = '#';//竖边界
        board[i][N+1] = '#';//竖边界
    }
    
    for(i=1; i<=N; i++)
    {
        for(j=1; j<=N; j++)
        {
            board[i][j] = ' ';//棋盘用空格
        }
    }
}

void display()
{
    int i = 0;
    int j = 1;
    
    for(i=0; i<N+2; i++)
    {
        for(j=0; j<N+2; j++)
        {
            printf("%c", board[i][j]);
        }
        
        printf("\n");
    }
}

int check(int i, int j)
{
    int ret = 1;
    int p = 0;
    
    for(p=0; p<3; p++)
    {
        int ni = i;
        int nj = j;
        
        while( ret && (board[ni][nj] != '#') )//3个方向，不是边界
        {
            ni = ni + pos[p].ios;
            nj = nj + pos[p].jos;
            
            ret = ret && (board[ni][nj] != '*');//不是皇后
        }//如果满足，返回1，表示该点可以放置皇后
    }
    
    return ret;
}

void find(int i)
{
    int j ;
    
    if( i > N )
    {
        count++;
        
        printf("Solution: %d\n", count);
        
        display();
        
        //getchar();
    }
    else
    {
        for(j=1; j<=N; j++)
        {
            if( check(i, j) )
            {
                board[i][j] = '*';//第一步：放置皇后，如果放置符合要求，递归会把正确的打印出来
                
                find(i+1);
                
                board[i][j] = ' ';//第二步 ：如果第一步放置的位置符合要求，把之前放置皇后的位置清空，因为皇后的位置已经通过递归正确的display了，这里清除不影响，
                                 //如果第一步放置的皇后位置不正确，这里的清空就是回溯

            }
        }
    }
}

int main()
{
    init();
    find(1);
    
    return 0;
}

一共92种解法。

首先为八皇后自设定了边界，所以二维数组的大小为 [N+2]  [N+2].然后直角坐标系以左上方开始。

判断皇后是否可以放置，即为三个方向的判断：

 

 所以，如果判断左上方，坐标是（-1，-1），依次循环可以无限延伸左上方，直到边界或者有皇后停止，

同理，正上方就是（-1，0），右上方就是（-1，1）。

我们可以更改默认棋盘的空格为数字1-8，这样可以显示的观察皇后的位置：

 

find函数加入一个缓存变量：

输出结果：

使用递归回溯是解决八皇后问题的有效方法，这样的代码比较简短易懂。

使用递归的方式，就要有递归的思想，不要陷入递归的细节无法自拔。