Python 所有可能的N皇后
经典的N皇后问题找到了一种方法，将N个皇后放置在N×N棋盘上，这样就不会有两个皇后互相攻击。 这是我对N皇后问题的解决方案Python 所有可能的N皇后,python,algorithm,backtracking,recursive-backtracking,Python,Algorithm,Backtracking,Recursive Backtracking,经典的N皇后问题找到了一种方法，将N个皇后放置在N×N棋盘上，这样就不会有两个皇后互相攻击。 这是我对N皇后问题的解决方案 class Solution(object): def solveNQueens(self, n): """ :type n: int :rtype: List[List[str]] """ grid = [['.' for _ in range(n)] for _ in range(n
class Solution(object):
def solveNQueens(self, n):
"""
:type n: int
:rtype: List[List[str]]
"""
grid = [['.' for _ in range(n)] for _ in range(n)]
solved = self.helper(n, 0, grid)
if solved:
return ["".join(item) for item in grid]
else:
return None
def helper(self, n, row, grid):
if n == row:
return True
for col in range(n):
if self.is_safe(row, col, grid):
grid[row][col] = 'Q'
if self.helper(n, row + 1, grid):
return True
else:
grid[row][col] = '.'
return False
def is_safe(self, row, col, board):
for i in range(len(board)):
if board[row][i] == 'Q' or board[i][col] == 'Q':
return False
i = 0
while row - i >= 0 and col - i >= 0:
if board[row - i][col - i] == 'Q':
return False
i += 1
i = 0
while row + i < len(board) and col + i < len(board):
if board[row + i][col - i] == 'Q':
return False
i += 1
i = 1
while row + i < len(board) and col - i >= 0:
if board[row + i][col - i] == 'Q':
return False
i += 1
i = 1
while row - i >= 0 and col + i < len(board):
if board[row - i][col + i] == 'Q':
return False
i += 1
return True
if __name__ == '__main__':
solution = Solution()
print(solution.solveNQueens(8))
是否有人可以帮助扩展此解决方案以找到所有可能的解决方案。好问题！N-queens也是一个很好的递归问题：实际上，您已经非常接近于获得所需的内容，并且不必对代码进行太多修改 思考这个问题的一个好方法是理解你所看到的两个不同的问题。您当前的方法是使用回溯来找到第一个可能的解决方案。你要做的是找到所有的解决方案，一个类似的问题，只需要你以不同的方式思考你的基本情况 在当前设置中，如果基本情况返回True，则父调用将短路并返回True。当我们试图找到任何单一的解决方案时，这是理想的，因为一旦我们找到了一个有效的解决方案，我们知道我们可以停止寻找。然而，结果是，我们没有继续探索其他途径 考虑回溯的一种方式是，您基本上是创建一个由可能的移动产生的可能的板组成的树。要找到第一个解决方案，只要您到达一个叶节点或一个成功的状态，您就可以一路返回。但是，您要做的是继续遍历树的所有其他路径，并继续查找赢得叶子的状态，并记录它们 因此，修改当前方法的一个简单方法是修改基本情况，这样它就不会返回True，而是在跟踪所有解决方案的变量中记录董事会的状态，即获胜状态。另外，在递归的情况下，当您进行递归调用时，您不会检查它是否返回True或False，而是继续在for循环中运行并尝试所有移动 我这样修改了你的解决方案，得到了92个解决方案，互联网证实了这一点：
class Solution(object):
def __init__(self):
self.solutions = []
def solveNQueens(self, n):
"""
:type n: int
:rtype: List[List[str]]
"""
grid = [['.' for _ in range(n)] for _ in range(n)]
solved = self.helper(n, 0, grid)
print len(self.solutions)
if solved:
return ["".join(item) for item in grid]
else:
return None
def helper(self, n, row, grid):
if n == row:
print "wooo"
self.solutions.append(copy.deepcopy(grid))
return
for col in range(n):
if self.is_safe(row, col, grid):
grid[row][col] = 'Q'
self.helper(n, row + 1, grid)
grid[row][col] = '.'
我希望这有帮助 好问题！N-queens也是一个很好的递归问题：实际上，您已经非常接近于获得所需的内容，并且不必对代码进行太多修改 思考这个问题的一个好方法是理解你所看到的两个不同的问题。您当前的方法是使用回溯来找到第一个可能的解决方案。你要做的是找到所有的解决方案，一个类似的问题，只需要你以不同的方式思考你的基本情况 在当前设置中，如果基本情况返回True，则父调用将短路并返回True。当我们试图找到任何单一的解决方案时，这是理想的，因为一旦我们找到了一个有效的解决方案，我们知道我们可以停止寻找。然而，结果是，我们没有继续探索其他途径 考虑回溯的一种方式是，您基本上是创建一个由可能的移动产生的可能的板组成的树。要找到第一个解决方案，只要您到达一个叶节点或一个成功的状态，您就可以一路返回。但是，您要做的是继续遍历树的所有其他路径，并继续查找赢得叶子的状态，并记录它们 因此，修改当前方法的一个简单方法是修改基本情况，这样它就不会返回True，而是在跟踪所有解决方案的变量中记录董事会的状态，即获胜状态。另外，在递归的情况下，当您进行递归调用时，您不会检查它是否返回True或False，而是继续在for循环中运行并尝试所有移动 我这样修改了你的解决方案，得到了92个解决方案，互联网证实了这一点：
class Solution(object):
def __init__(self):
self.solutions = []
def solveNQueens(self, n):
"""
:type n: int
:rtype: List[List[str]]
"""
grid = [['.' for _ in range(n)] for _ in range(n)]
solved = self.helper(n, 0, grid)
print len(self.solutions)
if solved:
return ["".join(item) for item in grid]
else:
return None
def helper(self, n, row, grid):
if n == row:
print "wooo"
self.solutions.append(copy.deepcopy(grid))
return
for col in range(n):
if self.is_safe(row, col, grid):
grid[row][col] = 'Q'
self.helper(n, row + 1, grid)
grid[row][col] = '.'
我希望这有帮助 @DanielleM。我找到了一种方法，需要你的帮助和所有可能的方法：@DanielleM.：forcontext@Makoto哦，我知道，这只是一句我试着记住的很好的引语，希望有一天能在一次采访中使用它。我想是来自Aphyr.com？如果你听到一声叹息，然后在纸上乱涂乱画，不要感到惊讶。我们明白了，但现在来吧…：@丹尼尔。我找到了一种方法，需要你的帮助和所有可能的方法：@DanielleM.：forcontext@Makoto哦，我知道，这只是一句我试着记住的很好的引语，希望有一天能在一次采访中使用它。我想是来自Aphyr.com？如果你听到一声叹息，然后在纸上乱涂乱画，不要感到惊讶。我们明白了，但现在来吧…：