递归的应用（二）

递归与回溯

递归在程序设计中也常用于需要回溯算法的场合。

回溯算法的基本思想：

• 从问题的某一种状态出发，搜索可以到达的所有状态。
• 当某个状态到达后，可向前回退，并继续搜索其它可达状态。
• 当所有状态都到达后，回溯算法结束。

程序设计中可利用函数的活动对象保存回溯算法的状态数据，因此可以利用递归完成回溯算法。

八皇后问题

在一个8×8国际象棋盘上，有8个皇后，每个皇后占一格；要求皇后间不会出现相互“攻击”的现象，即不能有两个皇后处在同一行、同一列或同一对角线上。

例程：

#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() //初始化棋盘 
{
    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] != '#') )
        {
            ni = ni + pos[p].ios;
            nj = nj + pos[p].jos;

            ret = ret && (board[ni][nj] != '*');
        }
    }   
    return ret;
}

void find(int i)
{
    int j = 0;    
    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] = ' ';
                //此处如果不能放皇后，则设为' '，在前面数据已经打印出来了，
                //所以设为' '对'*'无影响 
            }
        }
    }
}

int main()
{
    init();
    find(1);
    //总共 92 种 解决方案 
    return 0;
}

小结

回溯算法是递归应用的重要场合。
利用函数调用的活动对象可以保存回溯算法中重要的变量信息。
递归是回溯算法的重要实现方式。