我刚刚解决了python中的nqueen问题。该解决方案输出了将n个皇后放置在nXn棋盘上的解决方案总数,但尝试使用n = 15需要一个多小时才能得到答案。任何人都可以看看代码并给我提示加速这个程序......一个新手python程序员。
#!/usr/bin/env python2.7
##############################################################################
# a script to solve the n queen problem in which n queens are to be placed on
# an nxn chess board in a way that none of the n queens is in check by any other
#queen using backtracking'''
##############################################################################
import sys
import time
import array
solution_count = 0
def queen(current_row, num_row, solution_list):
if current_row == num_row:
global solution_count
solution_count = solution_count + 1
else:
current_row += 1
next_moves = gen_nextpos(current_row, solution_list, num_row + 1)
if next_moves:
for move in next_moves:
'''make a move on first legal move of next moves'''
solution_list[current_row] = move
queen(current_row, num_row, solution_list)
'''undo move made'''
solution_list[current_row] = 0
else:
return None
def gen_nextpos(a_row, solution_list, arr_size):
'''function that takes a chess row number, a list of partially completed
placements and the number of rows of the chessboard. It returns a list of
columns in the row which are not under attack from any previously placed
queen.
'''
cand_moves = []
'''check for each column of a_row which is not in check from a previously
placed queen'''
for column in range(1, arr_size):
under_attack = False
for row in range(1, a_row):
'''
solution_list holds the column index for each row of which a
queen has been placed and using the fact that the slope of
diagonals to which a previously placed queen can get to is 1 and
that the vertical positions to which a queen can get to have same
column index, a position is checked for any threating queen
'''
if (abs(a_row - row) == abs(column - solution_list[row])
or solution_list[row] == column):
under_attack = True
break
if not under_attack:
cand_moves.append(column)
return cand_moves
def main():
'''
main is the application which sets up the program for running. It takes an
integer input,N, from the user representing the size of the chessboard and
passes as input,0, N representing the chess board size and a solution list to
hold solutions as they are created.It outputs the number of ways N queens
can be placed on a board of size NxN.
'''
#board_size = [int(x) for x in sys.stdin.readline().split()]
board_size = [15]
board_size = board_size[0]
solution_list = array.array('i', [0]* (board_size + 1))
#solution_list = [0]* (board_size + 1)
queen(0, board_size, solution_list)
print(solution_count)
if __name__ == '__main__':
start_time = time.time()
main()
print(time.time()
答案 0 :(得分:5)
对于N-Queens问题的回溯算法是最坏情况下的因子算法。因此对于N = 8,8!在最坏的情况下检查解决方案的数量,N = 9使其成为9!等等。可以看出,可能的解决方案的数量变得非常大,非常快。如果您不相信我,只需转到计算器并开始乘以连续数字,从1开始。让我知道计算器内存耗尽的速度。
幸运的是,并非所有可能的解决方案都必须经过检查。不幸的是,正确解决方案的数量仍然遵循大致因子增长模式。因此,算法的运行时间以阶乘的速度增长。
由于您需要找到所有正确的解决方案,因此加快程序的速度并不多。你已经在从搜索树中修剪不可能的分支方面做得很好。我不认为还有其他任何会产生重大影响的事情。这只是一个缓慢的算法。
答案 1 :(得分:2)
可以使用Donald Knuth的随机估计方法估算解的数量。
从没有放置皇后开始,下一行的允许位置数为n。 随机选择其中一个位置并计算下一行的允许位置数(p),并将其乘以n,并将其存储为解的总数(total = n * p),然后随机选择一个允许的位置
对于此行,计算下一行的允许位置数(p),并计算多个解的总数(总计* = p)。重复此操作,直到无法解决电路板,在这种情况下,解决方案的数量等于零,或直到电路板解决。
重复多次并计算平均解数(包括任意零)。这可以为您提供快速且非常准确的解决方案数量近似值,近似值可以提高您的运行次数。
我希望这是有道理的;)
答案 2 :(得分:2)
我建议您查看Python源代码中的test_generators.py
,以了解N-Queens问题的替代实现。
Python 2.6.5 (release26-maint, Sep 12 2010, 21:32:47)
[GCC 4.4.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from test import test_generators as tg
>>> n= tg.Queens(15)
>>> s= n.solve()
>>> next(s)
[0, 2, 4, 1, 9, 11, 13, 3, 12, 8, 5, 14, 6, 10, 7]
>>> next(s)
[0, 2, 4, 6, 8, 13, 11, 1, 14, 7, 5, 3, 9, 12, 10]
答案 3 :(得分:2)
刚看到这个问题。我想提供2个解决方案。
答案 4 :(得分:0)
以下是我的PYTHON实施。您可能希望使用PYPY来提高速度。
通过使用O(1)时间方法来检查下一个女王是否被已经放置在棋盘上的女王攻击,有助于提高速度。
假设程序是" nqueen.py",运行它的一个例子是" python nqueen.py 6",其中6是6x6板的大小。
#!/bin/python
#
# TH @stackoverflow, 2016-01-20, "N Queens" with an O(1) time method to check whether the next queen is attacked
#
import sys
board_size = int(sys.argv[1])
Attacked_H = { i:0 for i in range(0, board_size) }
Attacked_DU = { i:0 for i in range(0, board_size*2) }
Attacked_DD = { i:0 for i in range(-board_size, board_size) }
def nqueen(B, N, row, col):
if(row >= N):
return 1
if(col >= N):
print "board:\n" + str.join("\n", ["_|"*q + "Q|" + "_|"*(board_size - q - 1) for q in B])
return 0
B[col] = row
if(0==(Attacked_H[row] + Attacked_DU[row+col] + Attacked_DD[row-col])):
[Attacked_H[row], Attacked_DU[row+col], Attacked_DD[row-col]] = [ 1,1,1 ]
nqueen(B, N, 0, col + 1)
[Attacked_H[row], Attacked_DU[row+col], Attacked_DD[row-col]] = [ 0,0,0 ]
nqueen(B, N, row + 1, col)
nqueen(list(range(0, board_size)), board_size, 0, 0)
答案 5 :(得分:0)
我们也可以用遗传算法解决n-queens问题。这里描述https://youtu.be/l6qll5OldHQ,在edX课程ColumbiaX:CSMM.101x人工智能(AI)的一个讲座中。
目标函数尝试优化非攻击对的数量。 下面的动画显示了R中的示例解,n = 20。有关如何使用遗传算法求解n-queens的更多详细信息,请参见:https://sandipanweb.wordpress.com/2017/03/09/solving-the-n-queen-puzzle-with-genetic-algorithm-in-r/?frame-nonce=76cf9b156a。