作者自我介绍：大爽歌, b站小UP主 ，
python1对1辅导老师，
时常直播编程，直播时免费回答简单问题。
前置知识： 递归算法(recursion algorithm)。
我的递归教程: 【教程】python递归三部曲（基于turtle实现可视化）
回溯与递归的关系：
回溯是一种算法思想，递归是实现方式。
回溯法经典问题：
八皇后问题、数独问题。
（其实两个很像）
八皇后问题
八皇后问题是一个以国际象棋为背景的问题：
如何在8×8的国际象棋棋盘上放置八个皇后，使其不互相攻击。
即任两个皇后都不能处于同一条横行、纵行或斜线上。
n皇后问题
八皇后问题可以推广为更一般的n皇后摆放问题：这时棋盘的大小变为n×n，而皇后个数也变成n。
(当且仅当n = 1 或 n ≥ 4时问题有解)
4皇后问题!
八皇后讨论起来比较麻烦，先讨论四皇后情况(n=4)
首先展示下错误的情况:
如上图所示，三个图的错误分别是
- 第一行有重复了
- 对角线有重复了。(注意有两个对角线)
- 第一列有重复
想要正确，则每一行每一列，每个对角线(对角线有两个方向)都不能有重复项。
正确的情况示例如下：
回溯法
回溯法(backtracking)是暴力搜索法中的一种。
其核心思想就是不断尝试，不行就后退再试其他的。
关于这一思想，我之前有个视频，感觉能比较形象地展示，感兴趣可以看看：
接下来我们用回溯法探究下刚才的4皇后问题。
回溯法过程展示
个人感觉用行列坐标表示不够直观，所以给每个格子从前往后依次编号。
后面用编号来称呼位置（无特殊说明的话）
如下图
同时四个皇后从前往后按次序编为
\(Q_1\)、\(Q_2\)、\(Q_3\)、\(Q_4\)
原始的回溯法
每次会从前往后依次尝试每个编号的位置。
为了简化谈论，以下先进行了一定的优化。
由于每行不能重复，n个皇后必须分别放在n行上。
当有一行放不下了时。也就失败了。
所以
\(Q_1\)必须放在第一行(行索引为0)
\(Q_2\)必须放在第二行(行索引为1)
\(Q_3\)必须放在第三行(行索引为2)
\(Q_4\)必须放在第四行(行索引为3)
1 \(Q_1\)放位置0
使用回溯法，\(Q_2\)仍然会从0开始尝试，发现放不了，就往后走。
由于\(Q_1\)放位置0。所以
0、1、2、3、
4、8、12、
5、10、15都放不了
\(Q_2\)从第二行开头试。
即从4、5开始试，一直试到6才能够放下，那么就先放在这里。
\(Q_2\)放位置6
那么接下来继续尝试\(Q_3\)，
会发现第三行(行索引为2)已经放不了了。
如下图
这说明
\(Q_2\)放位置6失败
回来重新放\(Q_2\)，放位置7
\(Q_2\)放位置7
此时\(Q_3\)唯一能放的位置只有9。
之后，\(Q_4\)已经无处可放。
如下图
这说明
\(Q_2\)放位置7失败
\(Q_2\)无位置可放
\(Q_2\)无位置可放，
说明\(Q_1\)放在位置0失败。
\(Q_1\)需要尝试其他位置，即尝试先放在位置1。
到这里回溯法的特点其实就已经展现的比较够了：
即不断向下尝试，如果所有尝试都失败，那就后退一步，重新尝试。
2 \(Q_1\)放位置1
此时\(Q_2\)只能放在位置7，
之后\(Q_3\)只能放在位置8，
最后\(Q_3\)只能放在位置14，
即如下图所示
到这里，如果只要求找到一个解法，问题就已经结束了，如果要找到所有解法，那就是继续往后不断尝试。
代码实现
原始回溯法代码
class NQueens:
def __init__(self, n):
self.n = n
# 保存每个皇后的坐标, (ci, ri)
# 第一行第一列的皇后坐标为(0, 0)
self.one_solution = []
def check_can_place(self, ri, ci):
for pos in self.one_solution:
pc, pr = pos
if pc == ci: # 行检测
return False
if pr == ri: # 列检测
return False
if pr - pc == ri - ci: # 对角线检测 1
return False
if pr + pc == ri + ci: # 对角线检测 2
return False
return True
def solve(self):
for ri in range(self.n):
for ci in range(self.n):
if self.check_can_place(ri, ci):
pos = (ci, ri)
self.one_solution.append(pos)
if len(self.one_solution) == self.n:
return True
res = self.solve()
if res:
return True
else:
self.one_solution.pop()
return False
def show_in_board(self):
board = [
["-" for i in range(self.n)] for j in range(self.n)
]
for pos in self.one_solution:
pc, pr = pos
board[pr][pc] = "Q"
for row in board:
print(" ".join(row))
nq = NQueens(8)
res = nq.solve()
if res:
print("Queens positions:")
print(nq.one_solution)
print("Queens in board:")
nq.show_in_board()
输出结果
Queens positions:
[(0, 0), (4, 1), (7, 2), (5, 3), (2, 4), (6, 5), (1, 6), (3, 7)]
Queens in board:
Q - - - - - - -
- - - - Q - - -
- - - - - - - Q
- - - - - Q - -
- - Q - - - - -
- - - - - - Q -
- Q - - - - - -
- - - Q - - - -
check_can_place方法
该方法，用于检查指定的横纵坐标，是否还能防止皇后（不与已经放置的皇后冲突）
检查是否能放置
行和列好分析，对角线情况则比较麻烦。
两种对角线图示如下
第一种对角线（红色对角线）
每一条对角线上格子，\(r-c\)都是相同的值。
可以通过这个值来判断是否在同一条对角线上。
第二种对角线（绿色对角线）
每一条对角线上格子，\(r+c\)都是相同的值。
可以通过这个值来判断是否在同一条对角线上。
solve方法解析
def solve(self):
for ri in range(self.n):
for ci in range(self.n):
# 从前往后尝试所有的位置，看是否能放皇后
if self.check_can_place(ri, ci):
# 成功则添加
pos = (ci, ri)
self.one_solution.append(pos)
if len(self.one_solution) == self.n:
# 皇后数量已到达n，问题解决，返回解决成功
return True
# 走到这里，说明还没解决
# 递归调用自身，看当前情况往后是否能够解决成功
res = self.solve()
if res:
# 成功，就继续返回解决成功
return True
else:
# 失败，之前添加的pos方法，是不成功的，将其弹出，之后继续尝试
self.one_solution.pop()
return False
代码优化与拓展
优化：一行一试
上面的原始回溯法的代码。
每一次放皇后都是从前往后一个一个试，效率很低。
这里按照上文讨论中的思路进行优化，
即每一行放一个皇后。
那么代码里面就是每一行，从第一列开始一直尝试到最后一列。
一行放好后，就往下一行进行尝试。
这里只需要给NQueens类添加一个新方法solve_advanced即可
def solve_advanced(self, ri=0):
for ci in range(self.n):
if self.check_can_place(ri, ci):
pos = (ci, ri)
self.one_solution.append(pos)
if ri == self.n - 1:
return True
res = self.solve_advanced(ri+1)
if res:
return True
else:
self.one_solution.pop()
return False
调用时的res = nq.solve()改成res = nq.solve_advanced()即可。
输出和原始回溯法时的输出是一样的。
不过代码运行的速度会得到很大提升。
不仅如此，优化后的代码在去求所有解时，不会求出重复情况。
拓展：获得所有解（不重复）
求所有解的代码在优化后的方法上，简单调整以下就好
- 不再返回（即不会试到一个成功的就退出）
- 成功后将结果记录，记录时要使用切片进行拷贝。
首先，先在NQueens的__init__方法中添加新的属性，用于记录解决方法。
self.solutions = []
然后给NQueens类添加新方法solve_all
def solve_all(self, ri=0):
for ci in range(self.n):
if self.check_can_place(ri, ci):
pos = (ci, ri)
self.one_solution.append(pos)
if ri == self.n - 1:
self.solutions.append(self.one_solution[:])
else:
self.solve_all(ri+1)
self.one_solution.pop()
然后修改下show_in_board方法。
因为原来的方法只能展示self.one_solution。
这里希望也能够展示别的solution
修改后的show_in_board如下
def show_in_board(self, sol=None):
board = [
["-" for i in range(self.n)] for j in range(self.n)
]
if sol is None:
sol = self.one_solution
for pos in sol:
pc, pr = pos
board[pr][pc] = "Q"
for row in board:
print(" ".join(row))
总代码
一个NQueens的实例，只能调用三个方法中的一个(一次)
solvesolve_advancedsolve_all
重复调用可能会出问题（需要再调用，建议新建NQueens实例）
以下总代码中只展示solve_all的调用结果。
且由于八皇后问题的解太多(有92个)，
以下只展示下六皇后问题的调用求解
class NQueens:
def __init__(self, n):
self.n = n
# 保存每个皇后的坐标, (ci, ri)
# 第一行第一列的皇后坐标为(0, 0)
self.one_solution = []
self.solutions = [
]
def check_can_place(self, ri, ci):
for pos in self.one_solution:
pc, pr = pos
if pc == ci: # 行检测
return False
if pr == ri: # 列检测
return False
if pr - pc == ri - ci: # 对角线检测 1
return False
if pr + pc == ri + ci: # 对角线检测 2
return False
return True
def solve(self):
for ri in range(self.n):
for ci in range(self.n):
if self.check_can_place(ri, ci):
pos = (ci, ri)
self.one_solution.append(pos)
if len(self.one_solution) == self.n:
return True
res = self.solve()
if res:
return True
else:
self.one_solution.pop()
return False
def solve_advanced(self, ri=0):
for ci in range(self.n):
if self.check_can_place(ri, ci):
pos = (ci, ri)
self.one_solution.append(pos)
if ri == self.n - 1:
return True
res = self.solve_advanced(ri+1)
if res:
return True
else:
self.one_solution.pop()
return False
def solve_all(self, ri=0):
for ci in range(self.n):
if self.check_can_place(ri, ci):
pos = (ci, ri)
self.one_solution.append(pos)
if ri == self.n - 1:
self.solutions.append(self.one_solution[:])
else:
self.solve_all(ri+1)
self.one_solution.pop()
def show_in_board(self, sol=None):
board = [
["-" for i in range(self.n)] for j in range(self.n)
]
if sol is None:
sol = self.one_solution
for pos in sol:
pc, pr = pos
board[pr][pc] = "Q"
for row in board:
print(" ".join(row))
nq = NQueens(6)
nq.solve_all()
for si in range(len(nq.solutions)):
sol = nq.solutions[si]
print("=== Solution %s ===" % si)
print("Queens positions:")
print(sol)
print("Queens in board:")
nq.show_in_board(sol)
输出
总代码的输出如下
=== Solution 0 ===
Queens positions:
[(1, 0), (3, 1), (5, 2), (0, 3), (2, 4), (4, 5)]
Queens in board:
- Q - - - -
- - - Q - -
- - - - - Q
Q - - - - -
- - Q - - -
- - - - Q -
=== Solution 1 ===
Queens positions:
[(2, 0), (5, 1), (1, 2), (4, 3), (0, 4), (3, 5)]
Queens in board:
- - Q - - -
- - - - - Q
- Q - - - -
- - - - Q -
Q - - - - -
- - - Q - -
=== Solution 2 ===
Queens positions:
[(3, 0), (0, 1), (4, 2), (1, 3), (5, 4), (2, 5)]
Queens in board:
- - - Q - -
Q - - - - -
- - - - Q -
- Q - - - -
- - - - - Q
- - Q - - -
=== Solution 3 ===
Queens positions:
[(4, 0), (2, 1), (0, 2), (5, 3), (3, 4), (1, 5)]
Queens in board:
- - - - Q -
- - Q - - -
Q - - - - -
- - - - - Q
- - - Q - -
- Q - - - -