问题描述
我已经开始通过Python回溯解决8个皇后区问题。一切都很好。它甚至打印出第一个答案。但是，它坚持进行第一次回溯尝试。
任务听起来像这样：
实现一个解决8个皇后难题的Python函数。 8个皇后难题包括在棋盘上放置8个皇后，因此，任何一个皇后都无法捕获其他任何皇后。请注意，皇后可以在任何方向上正交或对角移动。
您应该实现一个功能solve（），该函数在被调用时将打印难题的第一个解决方案，然后等待输入。用户按下“ enter”（输入）后，将打印下一个解决方案，依此类推。
-您的程序应该只能找到该拼图的所有解决方案，而每个解决方案只能找到一次。'
-在任何一行中，都有一个皇后。因此，您需要计算的是可以放置8个皇后中的每一个的列。
-您应该实现一个递归函数solve（n），该函数找到第n + 1个皇后的位置，然后递归调用第n + 1个皇后的位置（除非已放置所有皇后）。应该使用回溯系统地探索所有可能性。
-如有必要，允许（鼓励）定义其他函数（resolve（）除外）以提高代码质量。
import numpy as np
grid = np.zeros((8,8),dtype = int)
def possible(y,n):
global solved
global grid
for i in range(0,8):
if grid[y][i] == n:
return False
try:
for item in solved[str(y)]:
if grid[y].all() == item.all():
return False
except KeyError:
return True
return True
max_y = 7
max_x = 7
def print_grid():
global grid
for line in grid:
for square in line:
if square == 0:
print(".",end = " ")
else :
print("Q",end = " ")
print()
solved = {}
def prefilled_solved():
global solved
for i in range(0,len(grid[0])):
solved[f"{str(i)}"] = []
def solve(y=0):
global grid
global solved
while y < 8:
for x in range(0,8):
if grid[y][x] == 0:
if possible(x,1):
grid[y][x] = 1
solved[f"{str(y)}"].append(grid[y])
y += 1
solve(y)
#y -= 1 or y = 0 or y -=2
# backtracking - bad choice
# grid[y][x] = 0
print_grid()
print(grid)
return
input("More?")
if __name__ == '__main__':
prefilled_solved()
solve()
我遵循了@mkam的建议，现在我有了皇后的随机星座，但是我完全摆脱了递归。
```import numpy as np
grid = np.zeros((8,dtype = int)
from random import randint,shuffle,choice
from itertools import permutations
constellations_drawn = []
def print_grid():
global grid
for line in grid:
for square in line:
if square == 0:
print(".",end = " ")
else :
print("Q",end = " ")
print()
solved = []
def prefilled_solved():
global solved
new_board = ['1','2','3','4','5','6','7','8']
new_board_i = ''.join(new_board)
solved = permutations(new_board_i,8)
def solve(y=0):
global grid
global solved
global constellations_drawn
list_solved = list(solved)
len_solved = len(list_solved)
board_drawn = list_solved[randint(0,len_solved-1)]
board_drawn_str = ''.join(board_drawn)
while board_drawn_str in constellations_drawn:
board_drawn = list_solved[randint(0,len_solved - 1)]
new_board_list = [int(item) for item in board_drawn]
for i,x in enumerate(new_board_list):
if grid[i-1][x-1] == 0:
grid[i-1][x-1] = 1
#y += 1
#solve(y)
#y -= 1 or y = 0 or y -=2
# backtracking - bad choice
# grid[y][x] = 0
constellations_drawn.append(board_drawn_str)
print_grid()
print(grid)
return
input("More?")
if __name__ == '__main__':
prefilled_solved()
solve()
I've merged the code of @mkam and mine. And it works. I still use numpy ndarray.
import numpy as np
from numpy.core._multiarray_umath import ndarray
def print_grid(solutions_found,board) -> None:
line: ndarray
len_board = len(board)
grid: ndarray = np.zeros((len_board,len_board),dtype=int)
for i,number in enumerate(board):
grid[i - 1][number - 1] = 1
for line in grid:
for square in line:
if square == 0:
print(".",end=" ")
else:
print("Q",end=" ")
print()
print(f'Solution - {solutions_found}')
def solve(boardsize,board=[],solutions_found=0):
if len(board) == boardsize:
solutions_found += 1
print_grid(solutions_found,board)
else:
for q in [col for col in range(1,boardsize + 1) if col not in board]:
if is_safe(q,board):
solutions_found = solve(boardsize,board + [q],solutions_found)
return solutions_found
def is_safe(q,board,x=1):
if not board:
return True
if board[-1] in [q + x,q - x]:
return False
return is_safe(q,board[:-1],x + 1)
if __name__ == '__main__':
solve(8)
解决方法
这是一个示例，说明如何使用一个简单的列表表示董事会来递归解决8皇后问题。诸如[8、4、1、3、6、2、7、5]之类的列表代表棋盘的8行，从上到下，其中Q在第一行的第8列，Q的第4列第七行，第六行的第一列...和底部行的第五列。
从空板[]开始构建解决方案，方法是将Q放在无法获取的列位置的下一行中。可能的位置是之前尚未采用的列（这是函数solve中的for循环）。对于这些可能的列位置中的每一个，函数issafe都检查该位置是否安全，以免被板上已经存在的Q对角地占据。如果位置安全，则将解决方案板再延长一行，然后重复进行解决方案，直到解决方案板填满（len(board) == boardsize），此时解决方案计数将增加并显示该板。
请注意，函数solve适用于任何大小的方形棋盘-所需的大小作为参数传递给solve，并且该函数返回找到的解的总数。
希望这有助于解释如何在没有numpy的情况下递归解决8皇后问题。
def display(solution_number,board):
row = '| ' * len(board) + '|'
hr = '+---' * len(board) + '+'
for col in board:
print(hr)
print(row[:col*4-3],'Q',row[col*4:])
print(f'{hr}\n{board}\nSolution - {solution_number}\n')
def issafe(q,board,x=1):
if not board: return True
if board[-1] in [q+x,q-x]: return False
return issafe(q,board[:-1],x+1)
def solve(boardsize,board=[],solutions_found=0):
if len(board) == boardsize:
solutions_found += 1
display(solutions_found,board)
else:
for q in [col for col in range(1,boardsize+1) if col not in board]:
if issafe(q,board):
solutions_found = solve(boardsize,board + [q],solutions_found)
return solutions_found
if __name__ == '__main__':
solutions = solve(8)
print(f'{solutions} solutions found')
您提到使用yield-这也是可能的，并且会将solve转换为生成器，一次生成一个解决方案。然后，您的程序可以使用for循环依次接收每个解决方案并根据需要对其进行处理。以下yield解决方案可使用yield from，因此适用于Python v.3.3及更高版本：
def display(solution_number,board=[]):
if len(board) == boardsize:
yield board
else:
for q in [col for col in range(1,board):
yield from solve(boardsize,board + [q])
if __name__ == '__main__':
for solutionnumber,solution in enumerate(solve(8)):
display(solutionnumber+1,solution)
如果递归函数issafe令人困惑，则为非递归版本：
def issafe(q,board):
x = len(board)
for col in board:
if col in [q+x,q-x]: return False
x -= 1
return True