递归算法应用（Python版)

递归

递归定义

递归是一种解决问题的方法，其精髓在于将问题分解为规模更小的相同问题，持续分解,直到问题规模小到可以用非常简单直接的方式来解决。

递归的问题分解方式非常独特，其算法方面的明显特征就是：在算法流程中调用自身。递归为我们提供了一种对复杂问题的优雅解决方案,精妙的递归算法常会出奇简单

递归三定律

1. 递归算法必须有一个基本结束条件（最小规模问题的直接解决）
2. 递归算法必须能改变状态向基本结束条件演进（减小问题规模）
3. 递归算法必须调用自身(解决减小了规模的相同问题）

递归调用的实现

当一个函数被调用的时候，系统会把调用时的现场数据压入到系统调用栈

• 每次调用，压入栈的现场数据称为栈帧当函数返回时，要从调用栈的栈顶取得返回地址，恢复现场，弹出栈帧，按地址返回。

递归深度限制

在调试递归算法程序的时候经常会碰到这样的错误: RecursionError

• 递归的层数太多,系统调用栈容量有限

这时候要检查程序中是否忘记设置基本结束条件，导致无限递归

• 或者向基本结束条件演进太慢，导致递归层数太多，调用栈溢出

在Python内置的sys模块可以获取和调整最大递归深度

import sys
# 默认递归深度
print(sys.getrecursionlimit())  # 1000
# 修改递归深度为3000
sys.setrecursionlimit(3000)
print(sys.getrecursionlimit())  # 3000

递归应用

数列求和

问题：给定一个列表，返回所有数的和

• 列表中数的个数不定，需要一个循环和一个累加变量来迭代求和
• 假如没有循环语句？既不能用for，也不能用while对不确定长度的列表求和？

换个方式来表达数列求和：全括号表达式(1+(3+(5+(7+9))))

• 上面这个式子,最内层的括号(7+9) ,这是无需循环即可计算的，实际上整个求和的过程是这样：
• 

跟据上述过程中所包含的重复模式,可以把求和问题归纳成这样：

• 数列的和= “首个数” +“余下数列”的和

如果数列包含的数少到只有1个的话,它的和就是这个数了

• 这是规模小到可以做最简单的处理

def list_sum(num_list):
    if len(num_list) == 1:  # 最小规模
        return num_list[0]
    else: # 减小规模
        return num_list[0] + list_sum(num_list[1:]) # 调用自身

print(list_sum([1, 3, 5, 7, 9]))
# 25

1. 问题分解为更小规模的相同问题，并表现为“调用自身”
2. 对“最小规模”问题的解决:简单直接

递归函数执行过程

递归函数调用和返回过程的链条

• 先调用最小规模，然后一层一层往回

数列求和问题首先具备了基本结束条件：当列表长度为1的时候,直接输出所包含的唯一数

数列求和处理的数据对象是一个列表,而基本结束条件是长度为1的列表,那递归算法就要改变列表并向长度为1的状态演进

• 我们看到其具体做法是将列表长度减少1。

调用自身是递归算法中最难理解的部分，实际上我们理解为"问题分解成了规模更小的相同问题"就可以了

• 在数列求和算法中就是“更短数列的求和问题”

任意进制转换

整数转换任意进制

• 十进制有十个不同符号:convString"0123456789"

• 比十小的整数，转换成十进制，直接查表就可以了： convString[n]

• 把比十大的整数，拆成一系列比十小的整数，逐个查表

• 比如七百六十九，拆成七、六、九，查表得到769就可以了

在递归三定律里,我们找到了"基本结束条件",就是小于十的整数

• 拆解整数的过程就是向“基本结束条件”演进的过程

我们用整数除,和求余数两个计算来将整数一步步拆开

• 除以“进制基base" (// base)对“进制基”求余数（% base）

问题分解

• 余数总小于“进制基base”,是“基本结束条件”，可直接进行查表转换

• 整数商成为“更小规模”问题,通过递归调用自身解决

def to_str(n, base):
    convert_string = "0123456789ABCDEF"
    if n < base:
        return convert_string[n]  # 最小规模
    else:
        # 将商作为新的被除数
        return to_str(n//base, base) + convert_string[n%base]  # 减小规模，调用自身
    
print(to_str(1453, 16))  # 5AD

汉诺塔

复杂递归问题

传说在一个印度教寺庙里,有3根柱子,其中一根套着64个由小到大的黄金盘片，僧侣们的任务就是要把这一叠黄金盘从一根柱子搬到另一根，但有两个规则：

• 一次只能搬1个盘子

• 大盘子不能叠在小盘子上

虽然这些黄金盘片跟世界末日有着神秘的联系,但我们却不必太担心,据计算,要搬完这64个盘片：

• 需要的移动次数为264-1 =18,446,744,073,709,551,615次

• 如果每秒钟搬动一次，则需要584,942,417,355（五千亿）年！

我们还是从递归三定律来分析河内塔问题

• 基本结束条件（最小规模问题），如何减小规模，调用自身

分解为递归形式

假设我们有5个盘子,穿在1#柱,需要拥到3#柱

• 如果能有办法把最上面的一摞4个盘子统统挪到2#柱，

• 把剩下的最大号盘子直接从1#柱挪到3#柱

• 再用同样的办法把2#柱上的那一摞4个盘子挪到3#柱，就完成了整个移动

递归思路

将盘片塔从开始柱,经由中间柱,移动到目标柱：

• 首先将上层N-1个盘片的盘片塔，从开始柱，经由目标柱，移动到中间柱；
• 然后将第N个(最大的)盘片,从开始柱,移动到目标柱；
• 最后将放置在中间柱的N-1个盘片的盘片塔,经由开始柱，移动到目标柱。

基本结束条件，也就是最小规模问题是：

• 1个盘片的移动问题

def move_tower(height, from_pole, with_pole, to_pole):
    if height >= 1:
        move_tower(height - 1, from_pole, to_pole, with_pole)
        move_disk(height, from_pole, to_pole)
        move_tower(height - 1, with_pole, from_pole, to_pole)

def move_disk(disk, from_pole, to_pole):
    print(f"Moving disk[{disk}] from {from_pole} to  {to_pole}")

move_tower(3, "#1", "#2", "#3")
# Moving disk[1] from #1 to  #3
# Moving disk[2] from #1 to  #2
# Moving disk[1] from #3 to  #2
# Moving disk[3] from #1 to  #3
# Moving disk[1] from #2 to  #1
# Moving disk[2] from #2 to  #3
# Moving disk[1] from #1 to  #3

探索迷宫

将海龟放在迷宫中间,如何能找到出口

首先,我们将整个迷宫的空间(矩形)分为行列整齐的方格，区分出墙壁和通道。

• 给每个方格具有行列位置，并赋予“墙壁”、通道”的属性

迷宫数据结构

考虑用矩阵方式来实现迷宫数据结构

• 采用“数据项为字符列表的列表”这种两级列表的方式来保存方格内容
• 采用不同字符来分别代表“墙壁+”、“通道”、“海龟投放点S"
• 从一个文本文件maze2.txt逐行读入迷宫数据

maze2.txt

++++++++++++++++++++++
+   +   ++ ++        +
      +     ++++++++++
+ +    ++  ++++ +++ ++
+ +   + + ++    +++  +
+          ++  ++  + +
+++++ + +      ++  + +
+++++ +++  + +  ++   +
+          + + S+ +  +
+++++ +  + + +     + +
++++++++++++++++++++++

读入数据文件成功后

• mazelist如下图示意
• mazelist[row] [col]==‘+’

算法思路

确定了迷宫数据结构之后,我们知道,对于海龟来说，其身处某个方格之中

• 它所能移动的方向,必须是向着通道的方向

• 如果某个方向是墙壁方格，就要换一个方向移动

这样,探索迷宫的递归算法思路如下:

• 将海龟从原位置向北移动一步，以新位置递归调用探索迷宫寻找出口；
• 如果上面的步骤找不到出口，那么将海龟从原位置向南移动一步,以新位置递归调用探索迷宫;
• 如果向南还找不到出口，那么将海龟从原位置向西移动一步，以新位置递归调用探索迷宫；
• 如果向西还找不到出口，那么将海龟从原位置向东移动一步，以新位置递归调用探索迷宫；如果上面四个方向都找不到出口，那么这个迷宫没有出口！

特殊细节：

• 如果我们向某个方向(如北)移动了海龟,那么如果新位置的北正好是一堵墙壁,那么在新位置上的递归调用就会让海龟向南尝试
• 可是新位置的南边一格，正好就是递归调用之前的原位置，这样就陷入了无限递归的死循环之中

所以需要有个机制记录海龟所走过的路径（不走重复的路）

• 沿途洒“面包屑”，一旦前进方向发现“面包屑”，就不能再踩上去，而必须换下一个方向尝试对于递归调用来说，就是某方向的方格上发现“面包屑”,就立即从递归调用返回上一级。

递归调用的“基本结束条件”归纳如下：

• 海龟碰到“墙壁”方格，递归调用结束，返回失败；
• 海龟碰到“面包屑”方格，表示此方格已访问过，递归调用结束，返回失败；
• 海龟碰到“出口”方格，即“位于边缘的通道”方格，递归调用结束，返回成功！
• 海龟在四个方向上探索都失败，递归调用结束，返回失败

辅助动画过程

为了让海龟在迷宫图里跑起来,我们给迷宫数据结构Maze Class添加一些成员和方法

• t：一个作图的海龟，设置其shape为海龟的样子（缺省是一个箭头）
• drawMaze()：绘制出迷宫的图形，墙壁用实心方格绘制
• updatePosition(row, col, val)：更新海龟的位置，并做标注
• isExit(row, col)：判断是否“出口”

import turtle

PART_OF_PATH = 'O'
TRIED = '.'
OBSTACLE = '+'
DEAD_END = '-'

 def drawMaze(self):
        self.t.speed(10)
        for y in range(self.rowsInMaze):
            for x in range(self.columnsInMaze):
                if self.mazelist[y][x] == OBSTACLE:
                    self.drawCenteredBox(x+self.xTranslate,-y+self.yTranslate,'orange')
        self.t.color('black')
        self.t.fillcolor('blue')

    def drawCenteredBox(self,x,y,color):
        self.t.up()
        self.t.goto(x-.5,y-.5)
        self.t.color(color)
        self.t.fillcolor(color)
        self.t.setheading(90)
        self.t.down()
        self.t.begin_fill()
        for i in range(4):
            self.t.forward(1)
            self.t.right(90)
        self.t.end_fill()

    def moveTurtle(self,x,y):
        self.t.up()
        self.t.setheading(self.t.towards(x+self.xTranslate,-y+self.yTranslate))
        self.t.goto(x+self.xTranslate,-y+self.yTranslate)

    def dropBreadcrumb(self,color):
        self.t.dot(10,color)

    def updatePosition(self,row,col,val=None):
        if val:
            self.mazelist[row][col] = val
        self.moveTurtle(col,row)

        if val == PART_OF_PATH:
            color = 'green'
        elif val == OBSTACLE:
            color = 'red'
        elif val == TRIED:
            color = 'black'
        elif val == DEAD_END:
            color = 'red'
        else:
            color = None

        if color:
            self.dropBreadcrumb(color)

    def isExit(self,row,col):
        return (row == 0 or
                row == self.rowsInMaze-1 or
                col == 0 or
                col == self.columnsInMaze-1 )

    def __getitem__(self,idx):
        return self.mazelist[idx]

主函数

def searchFrom(maze, startRow, startColumn):
    # try each of four directions from this point until we find a way out.
    # base Case return values:
    #  1.碰到墙壁，返回失败
    maze.updatePosition(startRow, startColumn)
    if maze[startRow][startColumn] == OBSTACLE :
        return False
    #  2. 碰到面包屑，或死胡同，返回失败
    if maze[startRow][startColumn] == TRIED or maze[startRow][startColumn] == DEAD_END:
        return False
    # 3. 碰到出口，返回成功
    if maze.isExit(startRow,startColumn):
        maze.updatePosition(startRow, startColumn, PART_OF_PATH)
        return True
    # 4. 撒一下面包屑，继续探索
    maze.updatePosition(startRow, startColumn, TRIED)
    # 向北南西东4个方向依次探索，or操作符具有短路效应(减小规模)
    found = searchFrom(maze, startRow-1, startColumn) or \
            searchFrom(maze, startRow+1, startColumn) or \
            searchFrom(maze, startRow, startColumn-1) or \
            searchFrom(maze, startRow, startColumn+1)
    # 如果探索成功,标记当前点,失败则标记为死胡同
    if found:
        maze.updatePosition(startRow, startColumn, PART_OF_PATH)
    else:
        maze.updatePosition(startRow, startColumn, DEAD_END)
    return found

测试运行

myMaze = Maze('maze2.txt')
myMaze.drawMaze()
myMaze.updatePosition(myMaze.startRow,myMaze.startCol)

searchFrom(myMaze, myMaze.startRow, myMaze.startCol)

找零兑换-递归

我们来找一种肯定能找到最优解的方法

• 贪心策略是否有效依赖于具体的硬币体系

首先是确定基本结束条件，兑换硬币这个问题最简单直接的情况就是,需要兑换的找零，其面值正好等于某种硬币

• 如找零25分，答案就是1个硬币！

其次是减小问题的规模，我们要对每种硬币尝试1次，例如美元硬币体系：

• 找零减去1分(penny)后,求兑换硬币最少数量(递归调用自身）；
• 找零减去5分(nikel)后，求兑换硬币最少数量
• 找零减去10分(dime)后，求兑换硬币最少数量
• 找零减去25分(quarter)后，求兑换硬币最少数量上述4项中选择最小的一个。

def rec_mc(coin_value_list, change):
    min_coins = change
    if change in coin_value_list:
        return 1  # 最小规模，直接返回
    else:
        for i in [c for c in coin_value_list if c <= change]:
            num_coins = 1 + rec_mc(coin_value_list, change - i)  # 调用自身，减小规模，每次减去一种硬币面值，挑选最小数量
            if num_coins < min_coins:
                min_coins = num_coins
    return min_coins

print(rec_mc([1, 5, 10, 25], 45))  # 3

• 虽然能解决问题，但极其低效，如果将45改成更大的数需要运行很长时间
• 原因：重复计算太多

递归算法改进

对这个递归解法进行改进的关键就在于消除重复计算

• 我们可以用一个表将计算过的中间结果保存起来，在计算之前查表看看是否已经计算过

这个算法的中间结果就是部分找零的最优解，在递归调用过程中已经得到的最优解被记录下来

• 在递归调用之前，先查找表中是否已有部分找零的最优解
• 如果有，直接返回最优解而不进行递归调用如果没有，才进行递归调用

优化后的代码

def rec_mc(coin_value_list, change, known_results):  # 硬币面值列表，找零，最优解
    min_coins = change
    if change in coin_value_list:  # 递归结束基本结束条件
        known_results[change] = 1  # 记录最优解
        return 1  # 最小规模，直接返回
    elif known_results[change] > 0:
        return known_results[change]  # 查表成功，直接用最优解
    else:
        for i in [c for c in coin_value_list if c <= change]:
            num_coins = 1 + rec_mc(coin_value_list, change - i, known_results)  # 调用自身，减小规模，每次减去一种硬币面值，挑选最小数量
            if num_coins < min_coins:
                min_coins = num_coins
                known_results[change] = min_coins
    return min_coins

print(rec_mc([1, 5, 10, 25], 63, [0] * 64))  # 6

• 改进后的算法，极大减少了递归调用的次数

找零兑换-动态规划

动态规划解法

中间结果记录可以很好解决找零兑换问题

实际上，这种方法还不能称为动态规划，而是叫做"memoization (记忆化/函数值缓存）"的技术提高了递归解法的性能

动态规划算法采用了一种更有条理的方式来得到问题的解

找零兑换的动态规划算法从最简单的“1分钱找零”的最优解开始，逐步递加上去，直到我们需要的找零钱数

在找零递加的过程中,设法保持每一分钱的递加都是最优解，一直加到求解找零钱数，自然得到最优解

递加的过程能保持最优解的关键是,其依赖于更少钱数最优解的简单计算,而更少钱数的最优解已经得到了。、

问题的最优解包含了更小规模子问题的最优解，这是一个最优化问题能够用动态规划策略解决的必要条件。

递归可视化

递归可视化：图示

python turtle库

turtle — 海龟绘图 — Python 3.8.17 文档

Python的海龟作图系统turtle module

• Python内置，随时可用，以LOGO语言的创意为基础

• 其意象为模拟海龟在沙滩上爬行而留下的足迹

• 爬行： forward(n); backward(n)

• 转向: left(a); right(a)

• 抬笔放笔： penup(); pendown()

• 笔属性： pensize(s); pencolor©

简单螺旋图

import turtle
t = turtle.Turtle()
def draw_spiral(t, line_len):
    if line_len > 0:  # 最小规模0直接退出
        t.forward(line_len)
        t.right(90)
        draw_spiral(t, line_len - 5)  # 减小规模边长减5，调用自身

分形树：自相似递归图像

分形Fractal ,是1975年由Mandelbrot开创的新学科

• “一个粗糙或零碎的几何形状,可以分成数个部分,且每一部分都(至少近似地)是整体缩小后的形状”，即具有自相似的性质。

我们可以把树分解为三个部分：树干、左边的小树右边的小树

• 分解后，正好符合递归的定义：对自身的调用

import turtle

def tree(branch_len):  # 树干长度
    if branch_len > 5:  # 树干最短限制，递归结束条件
        t.forward(branch_len)  # 画树干
        t.right(20)  # 右倾斜20度
        tree(branch_len - 15) # 递归调用，画右边小树，树干减15
        t.left(40)  # 向左40度，即左倾斜20度
        tree(branch_len - 15)  # 递归调用，画左边小树，树干减15
        t.right(20)  # 向右回20度，即回正
        t.backward(branch_len)  # 海龟回到原位置
# 由于递归特性，每次退回原位置先退最短的然后逐渐增加，类似栈后进先出，branch_len是最后的值往前
t = turtle.Turtle()
t.left(90)
t.penup()
t.backward(100)
t.pendown()
t.pencolor("green")
t.pensize(2)
tree(75)  # 画树干长度75的二叉树
t.hideturtle()  # 隐藏光标
turtle.exitonclick()

谢尔宾斯基三角

分形构造，平面称谢尔宾斯基三角形，立体称谢尔宾斯基金字塔

• 在一个等边三角形中，不断地被挖去最大的倒等边三角形

• 实际上,真正的谢尔宾斯基三角形是完全不可见的,其面积为0,但周长无穷,是介于一维和二维之间的分数维（约1.585维）构造。

作图思路

根据自相似特性，谢尔宾斯基三角形是由3个尺寸减半的谢尔宾斯基三角形按照品字形拼叠而成

• 由于我们无法真正做出谢尔宾斯基三角形（degree->0），只能做degree有限的近似图形。

在degree有限的情况下，degree=n的三角形，是由3个degree=n-1的三角形按照品字形拼叠而成

• 同时，这3个degree=n-1的三角形边长均为degree=n的三角形的一半（规模减小）。当degree=0，则就是一个等边三角形，这是递归基本结束条件

绘制等边三角形

import turtle
# 绘制等边三角形
def draw_triangle(points, color):
    t.fillcolor(color)
    t.penup()
    t.goto(points["top"])
    t.pendown()
    t.begin_fill()
    t.goto(points["left"])
    t.goto(points["right"])
    t.goto(points["top"])
    t.end_fill()

三角形顶点坐标

def get_mid(p1, p2): # 取两个点中点
    return ((p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2)

谢尔宾斯基三角

def sierpinski(degree, points):
    color_map = ["blue", "red", "green", "white", "yellow", "orange"]
    draw_triangle(points, color_map[degree])# 画等边三角形
    if degree > 0:  # 最小规模，0直接退出
        # 减小规模，getMid边长减半
        # 调用自身安装从左到上到右的顺序
        sierpinski(degree - 1,# 调用自身，左方顶点
                   {"left":points["left"],
                    "top":get_mid(points["left"], points["top"]),
                    "right":get_mid(points["left"], points["right"])})
        sierpinski(degree - 1,# 调用自身，上方顶点
                   {"left":get_mid(points["left"], points["top"]),
                    "top":points["top"],
                    "right":get_mid(points["top"], points["right"])})
        sierpinski(degree - 1,# 调用自身，右方顶点
                   {"left":get_mid(points["left"], points["right"]),
                    "top":get_mid(points["top"], points["right"]),
                    "right":points["right"]})

测试degree = 5 的三角形

# 最开始外轮廓三个顶点
points = {"left":(-200, -100),
          "top":(0, 200),
          "right":(200, -100)}
t = turtle.Turtle()
sierpinski(5, points)  # 画阶数为5的三角形
turtle.exitonclick()

图示degree = 3绘制过程

分治策略

解决问题典型策略：分而治之

• 将问题分为若干更小规模的部分
• 通过解决每一个小规模部分问题，并将结果汇总得到原问题的解

递归算法与分治策略

递归三定律：

• 基本结束条件，解决最小规模问题缩小规模,向基本结束条件演进调用自身来解决已缩小规模的相同问题

体现了分治策略问题

• 解决依赖于若干缩小了规模的问题汇总得到原问题的解

应用：

• 排序、查找、遍历、求值等等

优化问题和贪心策略

计算机科学中许多算法都是为了找到某些问题的最优解

• 例如，两个点之间的最短路径；能最好匹配一系列点的直线；或者满足一定条件的最小集合

找零兑换问题

一个经典案例是兑换最少个数的硬币问题

• 假设你为一家自动售货机厂家编程序，自动售货机要每次找给顾客最少数量硬币;

• 假设某次顾客投进$1纸币，买了£37的东西，要找g63，那么最少数量就是: 2个quarter (g25)、1个dime (g10)和3个p

• 来解决这些问题,例如最直观的“贪心策略”一般我们这么做：从最大面值的硬币开始，用尽量多的数量有余额的,再到下一最大面值的硬币,还用尽量多的数量,一直到penny (g1)为止

贪心策略

• 因为我们每次都试图解决问题的尽量大的一部对应到兑换硬币问题,就是每次以最多数量的大面值硬币来迅速减少找零面值