N皇后问题

 【八皇后问题】

在棋盘上放置8个皇后，使得她们互不攻击，此时每个皇后的攻击范围为同行同列和同对角线，要求找出所有解。

【回溯】：当把问题分成若干步骤并递归求解时，如果当前步骤没有合法选择，则函数将返回上一级递归调用，这种现象称为回溯。递归枚举算法通常被称为回溯法。

#include <stdio.h>

#define QUEEN_N     (8)

int queen[QUEEN_N][QUEEN_N] = {
    {0, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0, 0, 0, 0, 0, 0},
};

int queen_check(int x, int y)
{
    int i;

    for(i = 0; i < QUEEN_N; i++)
    {
        if(queen[i][y] == 1 && i != x) // 检测列
            return 0;
        if(queen[x][i] == 1 && i != y) // 检测行
            return 0;
    }

    // 检测对角线,x正向方向
    for(i = x+1; i < QUEEN_N; i++)
    {
        if(y + i - x < QUEEN_N)
            if(queen[i][y+i-x] == 1)
                return 0;
        if(y - (i - x) >= 0)
            if(queen[i][y-i+x] == 1)
                return 0;
    }
    // 检测对角线,x反向方向
    for(i = x-1; i >=0; i--)
    {
        if(y + (x-i) < QUEEN_N)
            if(queen[i][y+x-i] == 1)
                return 0;
        if(y - (x-i) >= 0)
            if(queen[i][y-x+i] == 1)
                return 0;
    }
    return 1;
}

void queen_print(int queen[QUEEN_N][QUEEN_N]) // 输出棋盘布局
{
    int i, j;

    for(i = 0; i < QUEEN_N; i++)
    {
        for(j = 0; j < QUEEN_N; j++)
        {
            if(queen[i][j] == 1)
            {
                printf("O ");
            }
            else
            {
                printf("x ");
            }
        }
        printf("
");
    }
}

// 输出所有棋盘
void queen_fill(int n)
{
    int i;
    static int iCount = 0;
    if(n >= QUEEN_N) // 递归边界。只要走到了这里，所有皇后必然不冲突。
    {
        printf("queen_print <%d>
", iCount++);
        queen_print(queen);
    }
    else
    {
        for(i = 0; i < QUEEN_N; i++) // 尝试把第n行的皇后放在第i列
        {
            queen[n][i] = 1;
            if(queen_check(n, i) == 1)
            {
                queen_fill(n+1); // 如果合法，则继续递归，放置下一行
            }
            queen[n][i] = 0;
        }
    }
}
// 输出第1个棋盘
int queen_fill_1(int n)
{
    int i;
    if(n >= QUEEN_N)
    {
        queen_print(queen);
        return 1;
    }
    else
    {
        for(i = 0; i < QUEEN_N; i++)
        {
            queen[n][i] = 1;
            if(queen_check(n, i) == 1)
            {
                if(queen_fill_1(n+1) == 1)
                    return 1;
            }
            queen[n][i] = 0;
        }
    }
    return 0;
}

// 对于原始棋盘,判断是否能输出满足的棋盘
int queen_fill_x(int n)
{
    int i;
    if(n >= QUEEN_N)
    {
        queen_print(queen);
        return 1;
    }
    else
    {
        for(i = 0; i < QUEEN_N; i++)
        {
            if(queen[n][i] == 0)
            {
                queen[n][i] = 1;
                if(queen_check(n, i) == 1)
                {
                    if(queen_fill_x(n+1) == 1)
                        return 1;
                }
                queen[n][i] = 0;
            }
            else
            {
                if(queen_check(n, i) == 1)
                {
                    if(queen_fill_x(n+1) == 1)
                        return 1;
                }
            }
        }
    }
    return 0;
}

int main(void)
{
    int iRet;
    printf("init queen:
");
    queen_print(queen);

    printf("queen_fill_x:
");
    iRet = queen_fill_x(0);
    if(iRet != 1)
    {
        printf("xxx err
");
    }

    printf("queen_fill_1:
");
    queen_fill_1(0);

    printf("queen_fill_all:
");
    queen_fill(0);

    return 0;
}

在编写递归枚举程序之前，需要深入分析问题，对模型精雕细琢。一般还应对解答树的结点数有一个粗略的估计，作为对评价模型的重要依据。

递归解决问题的思想：

if 问题足够简单：

　　直接解决问题

　　返回解

else：

　　将问题分解为与原问题同构的一个或多个更小的问题

　　逐个解决这些更小的问题

　　将结果组合为，获得最终的解

　　返回解