八皇后问题

百度百科关于八皇后问题的说明：

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

废话不多说，直接贴代码：

#include "stdio.h"
#include "string.h"

// ----------------------------------------------------------------------------
//                 definition
// ----------------------------------------------------------------------------
#define QN_NUM              8
#define AREA_X_MAX          8
#define AREA_Y_MAX          8

// ---------------------------------------------------------------------------
//                 local type
// ----------------------------------------------------------------------------

// basic type
typedef unsigned char   BYTE;
typedef unsigned short  WORD;
typedef unsigned long   DWORD;

// BOOL
typedef enum
{
    FALSE = 0,
    TRUE
}BOOL;

// pos 
typedef struct
{
    BYTE by_x;
    BYTE by_y;
}T_Pos, *PT_Pos;

// queen
typedef struct 
{
    BYTE  by_sn;          // sn 
    T_Pos t_pos;          // pos
}T_QN, *PT_QN;

// area node
typedef struct 
{
    T_Pos t_pos;
    BOOL  b_active;
}T_AN, *PT_AN;


// ---------------------------------------------------------------------------
//                 func part
// ----------------------------------------------------------------------------

// ------------------------------------
// init queen and area
// ------------------------------------
void Set_Default_Val(PT_QN pt_qn, PT_AN pt_an)
{
    BYTE  by_i      = 0;
    BYTE  by_j      = 0;
    PT_AN pt_an_tmp = NULL;
    PT_QN pt_qn_tmp = NULL;

    // init area
    for(by_i=0 ; by_i<AREA_X_MAX ; by_i++)
    {
        for(by_j=0 ; by_j<AREA_Y_MAX ; by_j++)
        {
            pt_an_tmp = pt_an + by_i * AREA_Y_MAX + by_j;
            pt_an_tmp->b_active   = TRUE;
            pt_an_tmp->t_pos.by_x = by_i;
            pt_an_tmp->t_pos.by_y = by_j;
        }
    }

    // init queen
    for(by_i=0; by_i<QN_NUM ; by_i++)
    {
        pt_qn_tmp             = pt_qn + by_i;
        pt_qn_tmp->by_sn      = by_i;
        pt_qn_tmp->t_pos.by_x = 0;
        pt_qn_tmp->t_pos.by_y = 0;
    }
}

// ------------------------------------
// print qn
// ------------------------------------
void Print_QN(BYTE by_rslt_sn, PT_QN pt_qn)
{
    BYTE by_i, by_j;
    BYTE by_sn;
    BYTE aby_line[100];
    BYTE aby_qn[20];

    printf("\r\n - new rslt found - [%02d]\r\n", by_rslt_sn);

    printf("-------------------------\r\n");
    for(by_i=0 ; by_i<AREA_X_MAX ; by_i++)
    {
        for(by_sn=0 ; by_sn<QN_NUM ; by_sn++)
        {
            if(by_i == pt_qn[by_sn].t_pos.by_x)
            {
                memset(aby_line, 0x00, 100);
                memcpy(aby_line, "|  |  |  |  |  |  |  |  |", strlen("|  |  |  |  |  |  |  |  |"));    
                
                memset(aby_qn, 0x00, 20);
                sprintf(aby_qn, "Q%d", by_sn);
                by_j = 1 + strlen("  |") * (pt_qn[by_sn].t_pos.by_y);
                memcpy(&aby_line[by_j], aby_qn, strlen(aby_qn));
                
                printf("%s", aby_line);
            }
        }
        printf("\r\n-------------------------\r\n");
    }

}

// ------------------------------------
// disable area node
// ------------------------------------

/*
 * 斜线的斜率固定(1:1).
 * 区域建模在第一象限
 * y = x + b1 or y = -x + b2
 */
void Disable_Area_Node(const PT_QN pt_qn,
                             PT_AN pt_an)
{
    BYTE  by_i      = 0;
    BYTE  by_j      = 0;

    int   i_b1      = 0;
    int   i_b2      = 0;

    PT_AN pt_an_tmp = NULL;

    // calc b1 & b2
    i_b1 = pt_qn->t_pos.by_y - pt_qn->t_pos.by_x;    // (y - x)
    i_b2 = pt_qn->t_pos.by_y + pt_qn->t_pos.by_x;    // (y + x)

    for(by_i=0 ; by_i<AREA_X_MAX ; by_i++)
    {
        for(by_j=0 ; by_j<AREA_Y_MAX ; by_j++)
        {
            pt_an_tmp = pt_an + by_i * AREA_Y_MAX + by_j;
            // 排除横纵坐标
            if(  !(  (pt_qn->t_pos.by_x != by_i)
                   &&(pt_qn->t_pos.by_y != by_j)))
            {
                pt_an_tmp->b_active = FALSE;   
            }
            
            // 排除y= x + b
            if(pt_an_tmp->t_pos.by_y == (pt_an_tmp->t_pos.by_x + i_b1)) 
            {
                pt_an_tmp->b_active = FALSE;
            }
            
            // 排除y=-x + b
            if(pt_an_tmp->t_pos.by_y == (i_b2 - pt_an_tmp->t_pos.by_x)) 
            {
                pt_an_tmp->b_active = FALSE;
            }
        }
    }
}

// ------------------------------------
// search active node
// ------------------------------------
void Search_Active_Node_In_Row(const PT_AN pt_row_start, 
                               BYTE*       pby_num,
                               BYTE*       pby_buf)
{
    BYTE  by_i         = 0;
    BYTE  by_buf_index = 0;
    PT_AN pt_an_tmp    = NULL;

    *pby_num  = 0;
    pt_an_tmp = pt_row_start;
    
    for(by_i=0 ; by_i<AREA_X_MAX ; by_i++)
    {
        if(pt_an_tmp->b_active)
        {
            pby_buf[by_buf_index] = by_i;
            by_buf_index++;
            (*pby_num)++;
        }
        pt_an_tmp++;
    }
}

// ------------------------------------
// copy an
// ------------------------------------
void Copy_AN(PT_AN pt_an1, PT_AN pt_an2)
{
    BYTE  by_i;
    BYTE  by_j;

    PT_AN pt_an_temp1 = NULL;
    PT_AN pt_an_temp2 = NULL;

    for(by_i=0 ; by_i<AREA_X_MAX ; by_i++)
    {
        for(by_j=0 ; by_j<AREA_Y_MAX ; by_j++)
        {
            pt_an_temp1 = pt_an1 + by_i * AREA_Y_MAX + by_j;
            pt_an_temp2 = pt_an2 + by_i * AREA_Y_MAX + by_j;
            
            pt_an_temp1->b_active = pt_an_temp2->b_active;
            pt_an_temp1->t_pos    = pt_an_temp2->t_pos;
        }
    }
}


// ------------------------------------
// match queen in a single line
// ------------------------------------

/*
 * search direction:
 * row 0 ------>
 * row 1 ------>
 *  .
 *  .
 * row 7 ------>
 *
 */

void Match_In_Row(PT_AN pt_an,
                  PT_QN pt_qn,          // buffer for queen
                  BYTE  by_row_num, 
                  BYTE* pby_cur_rslt_num)
{   
    T_AN  at_an_tmp[AREA_X_MAX][AREA_Y_MAX];
    BYTE  aby_active_node_buf[AREA_Y_MAX];
    BYTE  by_active_node_num;
    BYTE  by_i;
    PT_AN pt_row_start = NULL;

    pt_row_start = pt_an + AREA_Y_MAX * by_row_num;
    Search_Active_Node_In_Row(pt_row_start, &by_active_node_num, aby_active_node_buf);

    for(by_i=0 ; by_i<by_active_node_num ; by_i++)
    {
        if(0 == by_row_num)
        {
            Set_Default_Val(pt_qn, pt_an);
        }
    
        pt_qn[by_row_num].t_pos.by_x = by_row_num;
        pt_qn[by_row_num].t_pos.by_y = aby_active_node_buf[by_i];
            
        // find a valid result
        if((AREA_X_MAX-1) == by_row_num)
        {
            Print_QN(*pby_cur_rslt_num, pt_qn);
            (*pby_cur_rslt_num)++;
        }
        else // search in next row
        {
            Copy_AN(&at_an_tmp[0][0], pt_an); 
            Disable_Area_Node(&pt_qn[by_row_num], &at_an_tmp[0][0]);
            Match_In_Row(&at_an_tmp[0][0], pt_qn, by_row_num+1, pby_cur_rslt_num);
        }
    }
}

// ------------------------------------
// main func
// ------------------------------------
void main()
{
   T_AN at_an[AREA_X_MAX][AREA_Y_MAX];
   T_QN at_qn[QN_NUM];
   BYTE by_rslt_num = 0;

   printf("Start...\r\n");

   Set_Default_Val(at_qn, &at_an[0][0]);
   Match_In_Row(&at_an[0][0],
                 at_qn,          
                 0, 
                &by_rslt_num);

   printf("done...\r\n");
   getchar();
}