八皇后问题

这个问题是耳熟能详了，不再赘述。

先看几种不同的实现。

１．　

#include <sys/time.h>#include <stdio.h>#define MAX_SIZE50static int n = 0;static int tot = 0;static int C[MAX_SIZE];void search(int cur){if(cur == n){tot++;}else{int i;for(i = 0; i < n; i++){int ok = 1;C[cur] = i;int j;for(j = 0; j < cur; j++){if( C[cur] == C[j] || cur - C[cur] == j - C[j] || C[cur] + cur == C[j] + j){ok = 0;break;}}if(ok){search(cur + 1);}}}}int main(int argc, char **argv){n = 16;struct timeval start, end;gettimeofday(&start, NULL);search(0);gettimeofday(&end, NULL);printf("time = %f\n", (end.tv_sec - start.tv_sec + (end.tv_usec - start.tv_usec)/1000000.0));printf("%d\n", tot);return 0;}

这个实现是把“皇后”逐行排在不同的列上，在判断下一个位置的时候，只需要判断列和对角线是否合适了。

使用一个一维数组，把列号保存在里面，用行号来索引。

２．

#include <stdio.h>#include <stdlib.h>#include <time.h>long sum = 0, upperlim = 1;void test(long row, long ld, long rd) {   if (row != upperlim)   {         long pos = upperlim & ~(row | ld | rd);      while (pos)      {         long p = pos & -pos;         pos -= p;         test(row + p, (ld + p) << 1, (rd + p) >> 1);       }   }    else      sum++;}int main(int argc, char *argv[]){   time_t tm;    int n = 16;    if (argc != 1)   n = atoi(argv[1]);   tm = time(0);   if ((n < 1) || (n > 32))   {     　　　　exit(-1);   }      printf("%d-queens\n", n);    upperlim = (upperlim << n) - 1;   test(0, 0, 0);    printf("there are %ld combinations, time spent: %d secnods \n", sum, (int) (time(0) - tm));}

里面变量的含义：

ld， rd：　值的二进制位数为１　表示从右边数对应列不能放置皇后

变量 pos的二进制表达式里面的１表示可以放置皇后的列。

pos & -pos 这个表达式其实是把pos二进制值除了最右边的第一个１之外，所有的１都设置成为０．其实，就是右数第一个可以放置皇后的位置。

比如， 假如 pos = 65520 = 0xfff0 = 1111111111110000

则 -pos = 11111111111111110000000000010000

pos & -pos = 10000

３．

#ifdef WIN32#define MAX_BOARDSIZE 21typedef unsigned __int64 SOLUTIONTYPE;#else#define MAX_BOARDSIZE 18typedef unsigned long SOLUTIONTYPE;#endif#define MIN_BOARDSIZE 2SOLUTIONTYPE g_numsolutions = 0; 

/* The function which calculates the N queen solutions.   We calculate one-half the solutions, then flip the results over   the "Y axis" of the board.  Every solution can be reflected that   way to generate another unique solution (assuming the board size   isn't 1 x 1).  That's because a solution cannot be symmetrical   across the Y-axis (because you can't have two queens in the same   horizontal row).  A solution also cannot consist of queens    down the middle column of a board with an odd number of columns,   since you can't have two queens in the same vertical row.   This is a backtracking algorithm.  We place a queen in the top   row, then note the column and diagonals it occupies.  We then    place a queen in the next row down, taking care not to place it   in the same column or diagonal.  We then update the occupied   columns & diagonals & move on to the next row.  If no position   is open in the next row, we back track to the previous row & move   the queen over to the next available spot in its row & the process   starts over again.*/void Nqueen(int board_size){    int aQueenBitRes[MAX_BOARDSIZE]; /* results */    int aQueenBitCol[MAX_BOARDSIZE]; /* marks colummns which already have queens */    int aQueenBitPosDiag[MAX_BOARDSIZE]; /* marks "positive diagonals" which already have queens */    int aQueenBitNegDiag[MAX_BOARDSIZE]; /* marks "negative diagonals" which already have queens */    int aStack[MAX_BOARDSIZE + 2]; /* we use a stack instead of recursion */    register int* pnStack;    register int numrows = 0; /* numrows redundant - could use stack */    register unsigned int lsb; /* least significant bit */    register unsigned int bitfield; /* bits which are set mark possible positions for a queen */    int i;    int odd = board_size & 1; /* 0 if board_size even, 1 if odd */    int board_minus = board_size - 1; /* board size - 1 */    int mask = (1 << board_size) - 1; /* if board size is N, mask consists of N 1's */    /* Initialize stack */    aStack[0] = -1; /* set sentinel -- signifies end of stack */    /* NOTE: (board_size & 1) is true iff board_size is odd */    /* We need to loop through 2x if board_size is odd */    for (i = 0; i < (1 + odd); ++i)    {        /* We don't have to optimize this part; it ain't the            critical loop */        bitfield = 0;        if (0 == i)        {            /* Handle half of the board, except the middle               column. So if the board is 5 x 5, the first               row will be: 00011, since we're not worrying               about placing a queen in the center column (yet).            */            int half = board_size>>1; /* divide by two */            /* fill in rightmost 1's in bitfield for half of board_size               If board_size is 7, half of that is 3 (we're discarding the remainder)               and bitfield will be set to 111 in binary. */            bitfield = (1 << half) - 1;            pnStack = aStack + 1; /* stack pointer */                aQueenBitRes[0] = 0;            aQueenBitCol[0] = aQueenBitPosDiag[0] = aQueenBitNegDiag[0] = 0;        }        else        {            /* Handle the middle column (of a odd-sized board).               Set middle column bit to 1, then set               half of next row.               So we're processing first row (one element) & half of next.               So if the board is 5 x 5, the first row will be: 00100, and               the next row will be 00011.            */            bitfield = 1 << (board_size >> 1);            numrows = 1; /* prob. already 0 */            /* The first row just has one queen (in the middle column).*/            aQueenBitRes[0] = bitfield;            aQueenBitCol[0] = aQueenBitPosDiag[0] = aQueenBitNegDiag[0] = 0;            aQueenBitCol[1] = bitfield;            /* Now do the next row.  Only set bits in half of it, because we'll               flip the results over the "Y-axis".  */            aQueenBitNegDiag[1] = (bitfield >> 1);            aQueenBitPosDiag[1] = (bitfield << 1);            pnStack = aStack + 1; /* stack pointer */            *pnStack++ = 0; /* we're done w/ this row -- only 1 element & we've done it */            bitfield = (bitfield - 1) >> 1; /* bitfield -1 is all 1's to the left of the single 1 */        }        /* this is the critical loop */        for (;;)        {            /* could use                lsb = bitfield ^ (bitfield & (bitfield -1));                to get first (least sig) "1" bit, but that's slower. */            lsb = -((signed)bitfield) & bitfield; /* this assumes a 2's complement architecture */            if (0 == bitfield)             {                bitfield = *--pnStack; /* get prev. bitfield from stack */                if (pnStack == aStack) { /* if sentinel hit.... */                    break ;                }                --numrows;                continue;            }            bitfield &= ~lsb; /* toggle off this bit so we don't try it again */            aQueenBitRes[numrows] = lsb; /* save the result */            if (numrows < board_minus) /* we still have more rows to process? */            {                int n = numrows++;                aQueenBitCol[numrows] = aQueenBitCol[n] | lsb;                aQueenBitNegDiag[numrows] = (aQueenBitNegDiag[n] | lsb) >> 1;                aQueenBitPosDiag[numrows] = (aQueenBitPosDiag[n] | lsb) << 1;                *pnStack++ = bitfield;                /* We can't consider positions for the queen which are in the same                   column, same positive diagonal, or same negative diagonal as another                   queen already on the board. */                bitfield = mask & ~(aQueenBitCol[numrows] | aQueenBitNegDiag[numrows] | aQueenBitPosDiag[numrows]);                continue;            }            else            {                /* We have no more rows to process; we found a solution. */                /* Comment out the call to printtable in order to print the solutions as board position*/                /* printtable(board_size, aQueenBitRes, g_numsolutions + 1);  */                ++g_numsolutions;                bitfield = *--pnStack;                --numrows;                continue;            }        }    }    /* multiply solutions by two, to count mirror images */    g_numsolutions *= 2;}

参考：

１．　http://www.jsomers.com/nqueen_demo/nqueens.html

２．　http://blog.csdn.net/justme0/article/details/7540425