作者自我介绍：大爽歌, b站小UP主 ，

python1对1辅导老师，

时常直播编程，直播时免费回答简单问题。

前置知识： 递归算法(recursion algorithm)。

我的递归教程: 【教程】python递归三部曲（基于turtle实现可视化）

回溯与递归的关系：

回溯是一种算法思想，递归是实现方式。

回溯法经典问题：

八皇后问题、数独问题。

（其实两个很像）

八皇后问题

八皇后问题是一个以国际象棋为背景的问题：

如何在8×8的国际象棋棋盘上放置八个皇后，使其不互相攻击。

即任两个皇后都不能处于同一条横行、纵行或斜线上。

n皇后问题

八皇后问题可以推广为更一般的n皇后摆放问题：这时棋盘的大小变为n×n，而皇后个数也变成n。

(当且仅当n = 1 或 n ≥ 4时问题有解)

4皇后问题!

八皇后讨论起来比较麻烦，先讨论四皇后情况(n=4)

首先展示下错误的情况:

如上图所示，三个图的错误分别是

  1. 第一行有重复了
  2. 对角线有重复了。(注意有两个对角线)
  3. 第一列有重复

想要正确，则每一行每一列，每个对角线(对角线有两个方向)都不能有重复项。

正确的情况示例如下：

回溯法

回溯法(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的实例，只能调用三个方法中的一个(一次)

  • solve
  • solve_advanced
  • solve_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)

solutions = 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 - - - -

参考文档

【大爽python算法】递归算法进化之回溯算法(backtracking)的更多相关文章

  1. 大爽Python入门教程 2-3 字符串，列表，字典

    大爽Python入门公开课教案 点击查看教程总目录 除了通用的序列方法, 列表和字符串还有些自己的专属方法. 后面介绍有些是英中文对照介绍(英文来自官方文档), 便于大家更深入的去理解其意思. 灵活的 ...

  2. 大爽Python入门教程 3-3 循环：`for`、`while`

    大爽Python入门公开课教案 点击查看教程总目录 for循环 可迭代对象iterable 不同于其他语言. python的for循环只能用于遍历 可迭代对象iterable 的项. 即只支持以下语法 ...

  3. 大爽Python入门教程 3-4 实践例题

    大爽Python入门公开课教案 点击查看教程总目录 1. 求和 使用循环,计算列表所有项的和,并输出这个和. 列表示例 lst = [8, 5, 7, 12, 19, 21, 10, 3, 2, 11 ...

  4. 大爽Python入门教程 3-5 习题

    大爽Python入门公开课教案 点击查看教程总目录 1 求平方和 使用循环,计算列表所有项的平方和,并输出这个和. 列表示例 lst = [8, 5, 7, 12, 19, 21, 10, 3, 2, ...

  5. 大爽Python入门教程 3-6 答案

    大爽Python入门公开课教案 点击查看教程总目录 1 求平方和 使用循环,计算列表所有项的平方和,并输出这个和. 列表示例 lst = [8, 5, 7, 12, 19, 21, 10, 3, 2, ...

  6. 大爽Python入门教程 2-5 *拓展实践，对比与思考

    大爽Python入门公开课教案 点击查看教程总目录 本文偏难. 推荐等第一二三四章上完后,回过来拓展阅读. 基础情景思考 假设有这样一张成绩表 最左边的一列是名字,起名麻烦. 这里直接用ABC...来 ...

  7. 大爽Python入门教程 3-1 布尔值: True, False

    大爽Python入门公开课教案 点击查看教程总目录 1 布尔值介绍 从判断说起 回顾第一章介绍的简单的判断 >>> x = 10 >>> if x > 5: ...

  8. 大爽Python入门教程 3-2 条件判断: if...elif..else

    大爽Python入门公开课教案 点击查看教程总目录 简单回顾if 回顾下第一章的代码 >>> x = 5 >>> if x > 0: ... print(&q ...

  9. 大爽Python入门教程 总目录

    作者自我介绍:b站小UP主,时常直播编程+红警三,python1对1辅导老师. 大爽Python入门公开课教案 本篇博客为公开课教案目录,正文内容在目录章节链接的博客里 除目录本身外,没有链接的章节, ...

随机推荐

  1. 10.3 Nginx

    Nginx介绍 engine X,2002年开发,分为社区版和商业版(nginx plus) 2019年 f5 Networks 6.7亿美元收购nginx Nginx 免费 开源 高性能 http ...

  2. WCF服务调用超时错误：套接字连接已中止。这可能是由于处理消息时出错或远程主机超过接收超时或者潜在的网络资源问题导致的。本地套接字超时是“00:05:30”（已解决）

    问题: 线上正式环境调用WCF服务正常,但是每次使用本地测试环境调用WCF服务时长就是出现:套接字连接已中止.这可能是由于处理消息时出错或远程主机超过接收超时或者潜在的网络资源问题导致的.本地套接字超 ...

  3. 8.JVM内存分配机制超详细解析

    一.对象的加载过程 之前研究过类的加载过程.具体详情可查看文章:https://www.cnblogs.com/ITPower/p/15356099.html 那么,当一个对象被new的时候,是如何加 ...

  4. 解析csv数据绘制曲线图

    一个解析csv数据的小工具,所做项目中要查看脉冲图谱,经理就让我这个刚入职的小萌新写了个小程序.同事将csv格式的脉冲数据发给我,我的想法就是,将这些csv里的数据作为纵轴,x++为横轴,绘制出折线图 ...

  5. 题解 CF241E Flights

    题目传送门 题目大意 给出一个 \(n\) 个点 \(m\) 条边的 \(\texttt{DAG}\) ,给每条边设定边权为 \(1\) 或者 \(2\) ,使得 \(1\to n\) 的每条路径长度 ...

  6. MySQL中如何选择合适的备份策略和备份工具

    ​数据库备份的重要性毋庸置疑,可以说,它是数据安全的最后一道防线.鉴于此,对于备份,我们通常会做以下要求: 多地部署 对于核心数据库,我们通常有两地三中心的部署要求.对于备份来说,也是如此. 一个备份 ...

  7. ArrayList-源码分析-自动扩容机制

    ArrayList类: public class ArrayList....{ ...... private static final int DEFAULT_CAPACITY = 10; //默认容 ...

  8. 初探webpack之从零搭建Vue开发环境

    初探webpack之搭建Vue开发环境 平时我们可以用vue-cli很方便地搭建Vue的开发环境,vue-cli确实是个好东西,让我们不需要关心webpack等一些繁杂的配置,然后直接开始写业务代码, ...

  9. Golang通脉之数组

    数组是同一种数据类型元素的集合.数组在内存中都是连续存放的. 在Go语言中,数组从声明时就确定,使用时可以修改数组成员,但是数组大小不可变化. 基本语法: // 定义一个长度为3元素类型为int的数组 ...

  10. javascript-jquery的基本方法

    1.去除字符串中两端的空格$.trim(str) var str1=" 123 " $.trim(str1);//123 2.遍历对象的数据并进行操作$.each(obj,func ...