八皇后问题是十九世纪著名的数学家高斯1850年提出 。以下为python语言的八皇后代码，摘自《Python基础教程》，代码相对于其他语言，来得短小且一次性可以打印出92种结果。同时可以扩展为九皇后，十皇后问题。

问题：在一个8*8棋盘上，每一行放置一个皇后旗子，且它们不冲突。冲突定义：同一列不能有两个皇后，每一个对角线也不能有两个皇后。当然，三个皇后也是不行的，四个也是不行的，凭你的智商应该可以理解吧。

解决方案：回溯与递归。

介绍：

1.回溯法

回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。参见

2.递归法

阶乘 n! = 1 x 2 x 3 x ... x n

用函数fact(n)表示，可以看出：

fact(1) = 1fact(n) = n!           = 1 x 2 x 3 x ... x (n-1) x n           = (n-1)! x n           = fact(n-1) x n

于是，fact(n)用递归的方式写出来就是：

def fact(n):  if n==1:    return 1  return n * fact(n - 1)

如果计算fact(5)，结果如下：

===> fact(5)===> 5 * fact(4)===> 5 * (4 * fact(3))===> 5 * (4 * (3 * fact(2)))===> 5 * (4 * (3 * (2 * fact(1))))===> 5 * (4 * (3 * (2 * 1)))===> 5 * (4 * (3 * 2))===> 5 * (4 * 6)===> 5 * 24===> 120

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试fact(1000)：

>>> fact(1000)Traceback (most recent call last):  File "
    
     ", line 1, in 
     
        File "
      
       ", line 4, in fact  ...  File "
       
        ", line 4, in factRuntimeError: maximum recursion depth exceeded
       
      
     
    

解决递归调用栈溢出的方法是通过尾递归优化。

尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。如：

def factorial(n, acc=1):  if n == 0:    return acc  return factorial(n-1, n*acc)

函数返回时只调用了它本身factorial(n-1, n*acc)

问题是Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。

python源码：

# -*- coding: utf-8 -*-#python默认为ascii编码，中文编码可以用utf-8import random#随机模块def conflict(state,col):    #冲突函数，row为行，col为列    row=len(state)    for i in range(row):        if abs(state[i]-col) in (0,row-i):#重要语句            return True    return False    def queens(num=8,state=()):    #生成器函数    for pos in range(num):        if not conflict(state, pos):            if len(state)==num-1:                yield(pos,)            else:                for result in queens(num, state+(pos,)):                    yield (pos,)+resultdef queenprint(solution):    #打印函数    def line(pos,length=len(solution)):        return '. '*(pos)+'X '+'. '*(length-pos-1)    for pos in solution:        print line(pos)        for solution in list(queens(8)):    print solution    print '  total number is '+str(len(list(queens())))print '  one of the range is:\n'queenprint(random.choice(list(queens())))

结果：

(0, 4, 7, 5, 2, 6, 1, 3)(0, 5, 7, 2, 6, 3, 1, 4)(0, 6, 3, 5, 7, 1, 4, 2)(0, 6, 4, 7, 1, 3, 5, 2)(1, 3, 5, 7, 2, 0, 6, 4)(1, 4, 6, 0, 2, 7, 5, 3)(1, 4, 6, 3, 0, 7, 5, 2)(1, 5, 0, 6, 3, 7, 2, 4)(1, 5, 7, 2, 0, 3, 6, 4)(1, 6, 2, 5, 7, 4, 0, 3)(1, 6, 4, 7, 0, 3, 5, 2)(1, 7, 5, 0, 2, 4, 6, 3)(2, 0, 6, 4, 7, 1, 3, 5)(2, 4, 1, 7, 0, 6, 3, 5)(2, 4, 1, 7, 5, 3, 6, 0)(2, 4, 6, 0, 3, 1, 7, 5)(2, 4, 7, 3, 0, 6, 1, 5)(2, 5, 1, 4, 7, 0, 6, 3)(2, 5, 1, 6, 0, 3, 7, 4)(2, 5, 1, 6, 4, 0, 7, 3)(2, 5, 3, 0, 7, 4, 6, 1)(2, 5, 3, 1, 7, 4, 6, 0)(2, 5, 7, 0, 3, 6, 4, 1)(2, 5, 7, 0, 4, 6, 1, 3)(2, 5, 7, 1, 3, 0, 6, 4)(2, 6, 1, 7, 4, 0, 3, 5)(2, 6, 1, 7, 5, 3, 0, 4)(2, 7, 3, 6, 0, 5, 1, 4)(3, 0, 4, 7, 1, 6, 2, 5)(3, 0, 4, 7, 5, 2, 6, 1)(3, 1, 4, 7, 5, 0, 2, 6)(3, 1, 6, 2, 5, 7, 0, 4)(3, 1, 6, 2, 5, 7, 4, 0)(3, 1, 6, 4, 0, 7, 5, 2)(3, 1, 7, 4, 6, 0, 2, 5)(3, 1, 7, 5, 0, 2, 4, 6)(3, 5, 0, 4, 1, 7, 2, 6)(3, 5, 7, 1, 6, 0, 2, 4)(3, 5, 7, 2, 0, 6, 4, 1)(3, 6, 0, 7, 4, 1, 5, 2)(3, 6, 2, 7, 1, 4, 0, 5)(3, 6, 4, 1, 5, 0, 2, 7)(3, 6, 4, 2, 0, 5, 7, 1)(3, 7, 0, 2, 5, 1, 6, 4)(3, 7, 0, 4, 6, 1, 5, 2)(3, 7, 4, 2, 0, 6, 1, 5)(4, 0, 3, 5, 7, 1, 6, 2)(4, 0, 7, 3, 1, 6, 2, 5)(4, 0, 7, 5, 2, 6, 1, 3)(4, 1, 3, 5, 7, 2, 0, 6)(4, 1, 3, 6, 2, 7, 5, 0)(4, 1, 5, 0, 6, 3, 7, 2)(4, 1, 7, 0, 3, 6, 2, 5)(4, 2, 0, 5, 7, 1, 3, 6)(4, 2, 0, 6, 1, 7, 5, 3)(4, 2, 7, 3, 6, 0, 5, 1)(4, 6, 0, 2, 7, 5, 3, 1)(4, 6, 0, 3, 1, 7, 5, 2)(4, 6, 1, 3, 7, 0, 2, 5)(4, 6, 1, 5, 2, 0, 3, 7)(4, 6, 1, 5, 2, 0, 7, 3)(4, 6, 3, 0, 2, 7, 5, 1)(4, 7, 3, 0, 2, 5, 1, 6)(4, 7, 3, 0, 6, 1, 5, 2)(5, 0, 4, 1, 7, 2, 6, 3)(5, 1, 6, 0, 2, 4, 7, 3)(5, 1, 6, 0, 3, 7, 4, 2)(5, 2, 0, 6, 4, 7, 1, 3)(5, 2, 0, 7, 3, 1, 6, 4)(5, 2, 0, 7, 4, 1, 3, 6)(5, 2, 4, 6, 0, 3, 1, 7)(5, 2, 4, 7, 0, 3, 1, 6)(5, 2, 6, 1, 3, 7, 0, 4)(5, 2, 6, 1, 7, 4, 0, 3)(5, 2, 6, 3, 0, 7, 1, 4)(5, 3, 0, 4, 7, 1, 6, 2)(5, 3, 1, 7, 4, 6, 0, 2)(5, 3, 6, 0, 2, 4, 1, 7)(5, 3, 6, 0, 7, 1, 4, 2)(5, 7, 1, 3, 0, 6, 4, 2)(6, 0, 2, 7, 5, 3, 1, 4)(6, 1, 3, 0, 7, 4, 2, 5)(6, 1, 5, 2, 0, 3, 7, 4)(6, 2, 0, 5, 7, 4, 1, 3)(6, 2, 7, 1, 4, 0, 5, 3)(6, 3, 1, 4, 7, 0, 2, 5)(6, 3, 1, 7, 5, 0, 2, 4)(6, 4, 2, 0, 5, 7, 1, 3)(7, 1, 3, 0, 6, 4, 2, 5)(7, 1, 4, 2, 0, 6, 3, 5)(7, 2, 0, 5, 1, 4, 6, 3)(7, 3, 0, 2, 5, 1, 6, 4)  total number is 92  one of the range is:X . . . . . . . . . . . . . X . . . . X . . . . . . . . . X . . . . . . . . . X . X . . . . . . . . . . X . . . . . X . . . . .

源码解析：

主要利用冲突函数检测冲突，如果冲突则回溯，递归用到python的yield语句，该语句涉及python的生成器。

冲突函数：

def conflict(state,col):  #冲突函数，row为行，col为列  row=len(state)  for i in range(row):    if abs(state[i]-col) in (0,row-i):#重要语句      return True  return False

state为皇后的状态，类型是一个元组，如(7, 3, 0, 2, 5, 1, 6, 4)，元组是不可变对象，一经创建不能修改，元组是创建生成器的一种方法。

步骤：

假设第一行到第三行的皇后都没冲突，这个时候要检测第四行皇后是否冲突。如第一行皇后在第五列，第二行皇后在第八列，第三行皇后在第四列，检验第四行皇后放在哪一列不会冲突。

. . . . X . . . . . . . . . . X . . . X . . . .

这时state=(4,7,3)，col=?

1.得出目前没冲突行数row

row=len(state)

2.从1~row行依次检测是否与row+1行皇后冲突

for i in range(row):

3.如果row+1行皇后所在的列col与其他行皇后的列相同或处于对角线，则冲突

if abs(state[i]-col) in (0,row-i):#重要语句     return True

以上语句翻译为（其他行所在的列-要求检测所在行的列）相差范围为0~row-i则冲突。

傻瓜式教学：

第一行与第四行冲突，要么在同一列，要么在对角线，当对角线时列数相差3(因为第一行与第二行对角线相差1，第二行与第三行对角线相差1，则第一行与第三行对角线相差2，以此类推，第一行与第四行冲突，则相差3)

当第四行所在列col=4，这时abs ( state[0]-4 ) in (0 , 3-0)为真，因为4-4=0,如：

. . . . X . . . . . . . . . . X . . . X . . . . . . . . X . . .  同列冲突

当第四行所在列col=7，这时abs ( state[0]-7 ) in (0 , 3-0)为真，因为abs (4-7)=3,如：

. . . . X . . . . . . . . . . X . . . X . . . .. . . . . . . X 对角线冲突

你们这么聪明，该重要语句应该懂吧。

生成器函数：

def queens(num=8,state=()):  #生成器函数  for pos in range(num):    if not conflict(state, pos):      if len(state)==num-1:        yield(pos,)      else:        for result in queens(num, state+(pos,)):          yield (pos,)+result

生成器：

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器（Generator）。

参考：

步骤：

1.下面该语句为构建所有皇后摆放情况打下基础。可以尝试所有情况。

for pos in range(num):

2.如果不冲突，则递归构造棋盘。

if not conflict(state, pos):

3.如果棋盘状态state已经等于num-1，即到达倒数第二行，而这时最后一行皇后又没冲突，直接yield，打出其位置(pos, )，Python在显示只有1个元素的元组时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

否则递归，打印(pos , )+ result

if len(state)==num-1:    yield(pos,)  else:    for result in queens(num, state+(pos,)):      yield (pos,)+result

傻瓜式教学：

例如pos=0，第一行放在第一列，这时不会冲突，但是不会进入if，因为还没到达倒数第二行，进入else后，再调用queens(num, state+(pos,),这时进入第二行，再次递归展开则是queens(num,state+(pos, )+(pos, ) ),到达最后一行时返回(pos, )，再返回倒数第二行，再返回倒数第三行，最后到达最开始那层(pos, )+result, pos为第一行皇后所在列，result包含第二行皇后所在列和另一个result，就是这么复杂，希望好好琢磨。

优美格式的打印函数就不讲了。

讲讲打印所有结果

for solution in queens(8):    print solution

queens(8)因为生成器函数的for循环，每一次循环都会yield一个元组出来，所以有很多种情况，可以把它全部打出来。

也可以用list包装成列表再统计一下多少种数目。

print '  total number is '+str(len(list(queens()))

随机优美打印一个棋盘情况：

print '  one of the range is:\n'queenprint(random.choice(list(queens())))