笔记-数据结构与算法-递归

递归Recursion

• 视频链接：https://www.bilibili.com/video/BV1VC4y1x7uv
• 章节：P30-P44

递归是一种解决问题的方法，其精髓在于将：

1. 问题分解为规模更小的相同问题；

2. 持续分解，直到问题规模小到可以用非常简单直接的方式来解决。

3. 递归的问题分解方式非常独特，其算法方面的明显特征就是：在算法流程中调用自身。

数列求和

将问题规模较大的列表求和，分解为规模较小而且固定的2个数求和。

基本算术：数列的和=“首个数”+“余下数列”的和。

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

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

• 代码示例

  def list_sum(alist):
      if len(alist) == 1:
          return alist[0]
      else:
          return alist[0] + list_sum(alist[1:])
  list_sum([1,3,4,7,9])
  

• 程序执行过程

递归函数调用和返回过程

递归3定律

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

• 数列求和问题解析

  基本结束条件：数列长度为1，返回唯一值；

  向基本结束条件演进： 每次数列长度减1；

  调用自身：计算长度减1后的数列之和。

  将问题分解为规模更小的相同问题。

整数进制转换

基本结束条件：当前整数值小于进制基（十进制：数值在0-9之间）；

改变状态向基本条件演进：整数值//进制基数值变小，获取余数；

调用自身：对整数值//进制基的商再进一步求商求余。

• 图表示例
  

• 代码实现

def to_str(n, base):
    covert_string = "0123456789abcdef"
    if n < base:
        return covert_string[n]	# 最小规模
    else:
        return to_str(n // base, base) + covert_string[n % base] # 调用自身

递归调用的实现

当一个函数被凋用的时候，系統会把凋用时的现场数据压入到系统调用栈
每次调用，压入栈的现场数据称为栈帧，当函数返回时，要从调用栈的栈顶取得返回地址 ,恢复现场，弹出栈帧，按地址返回。

现场数据包括返回函数名称，函数的参数，局部变量等

• 递归深度限制
  在调试递归算法程序的时候经常会碰到这样的错误：RecursionError

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

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

    import sys
    
    print(sys.getrecursionlimit())
    sys.setrecursionlimit(3000)
    print(sys.getrecursionlimit())
    

递归可视化

• 自相似

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

自然界这个的分形性质的物体，海岸线、山脉、闪电、云朵、雪花、树

• 分形树

  一棵树的每个分叉和每条树枝,实际上都具有整棵树的外形特征(也是逐步分叉的)。

可以把树分解为三个部分：树干、左边的小树、右边的小树。分解后，正好符合递归的定义:对自身的调用。

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

作图思路
在degree有限的情况下，degree=n的三角形，是由3个degree=n-1的三角形 按照品字形拼叠而成
同时，这3个degree=n-1的三角形边长均为 degree=n的三角形的一半（规模减小）。
当degree=0，则就是一个等边三角形，这是递归基本结束条件。

汉诺塔

• 问题分析
  假设有5个盘子，穿在1#柱,需要挪到3#柱，
  1. 如果能有办法把最上面的一摞4个盘子统统挪到2#柱，那问题就好解决了，
  2. 把剩下的最大号盘子直接从1#柱挪到3#柱，
  3. 再用同样的办法把2#柱上的那一摞4个盘子挪到3#柱，

这样就只需3步就完成了整个移动。问题是如何将4个盘子如何能从1# 挪到2#？(此时问题规模减小了)
同样是想办法把上面的3个盘子到3#柱, 把剩下最大号盘子从1#到2#柱，再用同样的方法把3个盘子从3#到2#柱子
照此，3个盘子，2个盘子都能移动。再分解就是1个盘子的移动了。

• 递归思路

  • 将盘片塔从开始柱，经由中间柱，移动到目标柱:
    1. 首先将上层N-1个盘片的盘片塔，从开始柱，经由目标柱，移动到中间柱;
    2. 然后将第N个（最大的）盘片，从开始柱移动到目标柱；
    3. 最后将放置在中间柱的N-1个盘片的盘片塔，经由开始柱，移动到目标柱。
  • 基本结束条件就是最小规模问题，即一个盘片的移动问题。

• 代码实现

  def move_tower(height, from_tower, with_tower, to_tower):
      """
      :param height: 盘片高度，自上而下的序号
      :param from_tower: 开始柱
      :param with_tower: 中间柱
      :param to_tower: 目标柱
      :return: 
      """
      if height > 0:
          move_tower(height - 1, from_tower, to_tower, with_tower)
          # 打印盘片移动记录
          print(f"移动{height}，从{from_tower}到{to_tower}")
          move_tower(height - 1, with_tower, from_tower, to_tower)
  move_tower(3, "一", "二", "三")
  

探索迷宫

• 目的

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

• 迷宫结构

  整个迷宫的空间(矩形)分为行列整齐的方格，区分出“墙壁“和”通道“。 给每个方格具有行列位置，并赋予“墙壁”、“ 通道”的属性。

• 迷宫的数据结构

  采用“数据项为字符列表的列表”这种两列表的方式来保存方格内容；

  采用不同字符来分别代表“墻壁+”、“通道 ”、“海色投放点S”

  从一个文本文件逐行读入迷宫数据

• 迷宫探索

  对于海龟来说，其身处某个方格之中它所能移动的方向，必须是向着通道的方向，如果某个方向是墙壁方格，就要换一个方向移动。
  

  • 基本探索步骤

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

  • 记录已探索位置

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

    

    • 面包屑

      需要有个机制海龟所走的路径，沿途洒“面包屑”，一旦前方向发现“面包屑 ”，就不能再上去,而必須换下一个方向尝试，对于递归调用来说，就是某方向的方格上发现“ 面包屑”，就立即从递归调用返回上一級。

      

  • 递归基本结束条件

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

  • 代码实现

  OBSTACLE = '墙壁'
  TRIED = '面包屑'
  DEAD_END = '死胡同'
  PART_OF_PATH = '探索成功'
  
  def is_exit(row, col):
  	# 出口
      pass
  
  def search_from(maze, start_row, start_column):
      # 墙壁
      if maze[start_row, start_column] == OBSTACLE:
          return False
      # 面包屑
      if maze[start_row, start_column] == TRIED:
          return False
      # 死胡同
      if maze[start_row, start_column] == DEAD_END:
          return False
      # 出口
      if is_exit(start_row, start_column):
          return True
      # 北南西东4个方向依次探索
      found = search_from(maze, start_row - 1, start_column) or \
              search_from(maze, start_row + 1, start_column) or \
              search_from(maze, start_row, start_column - 1) or \
              search_from(maze, start_row, start_column + 1)
      # 探索完成，标记当前点，失败标记死胡同
      if found:
          maze[start_row, start_column] = PART_OF_PATH
      else:
          maze[start_row, start_column] = DEAD_END
      return found
  

  分治策略

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

• 递归算法与分治策略

  • 递归3定律，
    • 基本结束条件，解决最小规模问题
    • 缩小规模，向基本结束条件演进
    • 调用自身来解决已缩小规模的相同问题
  • 体现了分治策略，问题解决依赖于若干缩小了规模的问题，汇总得到原问题的解。

  递归算法与分治策略有天然的联系，应用广泛：排序、查找、遍历、求值等等

优化问题

计算机科学中许多算法都是为了找到某些问题的最优解例如，两个点之间的最短路径；能最好匹配一系列点的直线；或者满足一定条件的最小集合。

找零问题

兑换最少个数的硬币问题。
假设你为一家自动售货机厂家编程序，自动售货机要每次找给顾客最少数量硬币；假设某次顾客投进$1纸币,买了37分的东西，要找63分，那么最少数量就是：2个quarter（25）、1个dime（10）和3个penny（1），一共6个硬币。

贪心策略

从最大面值的硬币开始，用尽量多的数量，有余额，再到下一最大面值的硬币，还用尽量多的数量，一直到penny（1）为止。每次都试图解决问题的尽量大的一部分，对应到兑换硬币问题，就是每次以最多数量的最 大面值硬币来迅速减少找零面值。

• 贪心策略失效

  假设存在面值21分的硬币，按照“贪心策略”，63分还是原来的6个硬币63= 25 * 2 +10 * 1+1 * 3，
  但实际上最优解是3个面值21的硬币! 63=21*3。“贪心策略”失效了。

递归算法

• 基本结束条件
  兑换硬币这个问题最简单直接的情况就是，需要兑换的找零，其面值正好等于某种硬币，如找零25分，答案就是1个。

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

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

• 代码实现

  def rec_mc(coin_value_list, change):
      """
      :param coin_value_list: 硬币体系
      :param change: 找零数额
      :return:
      """
      # 最小硬币数初始化
      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]:
              # 硬币数量+1，递归调用，传入金额减去一个硬币后的值（减少规模）
              num_coins = 1 + rec_mc(coin_value_list, change - i)
              # 获取最小数量
              if num_coins < min_coins:
                  min_coins = num_coins
      return min_coins
  

• 算法分析

  此方法极其低效

  对63分的兑换硬币问题，需要进行67,716,925 次递归调用，耗时32s。

  原因：重复计算非常多，对同一个面额，在不同的路线下都会进行相同的计算（比如，63—>53，可以通过2次5，或者10次1达到，2种分支下，53都要进行重复的递归计算）。

• 算法优化

  想办法消除重复计算，可以用一个表将中间过程的部分找零的最优解记录下来。在递归调用之前，先查找表中是否已有部分找零的最优解，如果有直接返回最优解而不是进行递归调用。

  这种方法叫作记忆化/函数值缓存的技术，提高了递归解法的性能。

  比如一种路径中已经得到53分的最优解，那当另一个路线也剩余53分时，可以直接获取结果。而不用重复计算。

• 优化后的代码

  def rec_mc2(coin_value_list, change, known_result):
      """
      增加已知最优解记录表
      :param coin_value_list: 硬币体系
      :param change: 找零数额
      :param known_result: 已知找零的最优解记录表，字典类型
      :return:
      """
      # 最小硬币数初始化
      min_coins = change
      #  最小规模,直接返回
      if change in coin_value_list:
          return 1
      # 当前面额存在最优解直接返回
      if change in known_result:
          return known_result[change]
      else:
          # 筛选小于当前面额的硬币列表，用于遍历
          for i in [c for c in coin_value_list if c <= change]:
              # 硬币数量+1，递归调用，传入金额减去一个硬币后的值（减少规模）
              num_coins = 1 + rec_mc2(coin_value_list, change - i, known_result)
              # 获取最小数量
              if num_coins < min_coins:
                  min_coins = num_coins
          # 录入当前面额最优解
          known_result[change] = min_coins
      return min_coins
  

• 结果对比

  6
  32.35688495635986
  6
  0.0009965896606445312
  

动态规划

• 主要思想

  从最简单情况开始到达所需情况的循环，其每一步都依靠以前的最优解来得到本步骤的最优解，直到得到答案。

动态规划找零兑换

• 步骤
  1. 从最简单的1开始找零的最优解开始，逐步递加上去，直到我们需要的找零钱数；
  2. 在找零递加的过程中，设法保持每一分钱的递加都是最优解，一直加到求解找零钱的数，自然为最优解；
  3. 递加的过程能保持最优解的关键是，其依赖于更少钱数最优解的简单计算，而更少钱的最优解已经得到；
  4. 问题最优解包含了更小规模子问题的最优解，这是一个最优化问题能够用动态规划策略解决的必要条件。
     

originalamount：找零面额
1+numCoins(originalamount -1)：originalamount-1的最优解+1个硬币

从1、5、10、25 四种硬币为最后1个硬币的4种更小规模子问题的最优解+1结果中获取当前面额的最优解。

• 示例

  动态规划解决11分钱的兑换问题，从1分钱兑换开始，逐步建立一个兑换表。

1分钱1个，2分2个，3分3个，4分4个，5分1个(5分硬币)，6分2个（1个1，1个5）…
计算11分钱的兑换法,我们做如下几步:

• 首先减去1分硬币，剩下10分钱查表最优解是1 （10分硬币）

• 然后减去5分硬币，剩下6分钱查表最优解是2 （1个1，1个5）

• 最后减去10分硬币，剩下1分钱查表最优解是1（1分硬币）

• 所以11分钱兑换的最优解是2个硬币（1+10、10+1）

• 找零兑换代码实现

  def coin_change(n):
      min_list = (num + 1) * [0]  # 用于保持子问题最优解
      base_list = [1, 2, 5, 10, 20, 21, 50] # 硬币种类
      for i in range(n + 1):  # 列表，左闭右开，需要+1
          if i in base_list:  # 零钱数和兑换基值相同是最优解1
              min_list[i] = 1  # 保持值列表中
              continue
          min_count = i		# 初始化数量
          for base in base_list:  # 遍历所有兑换基值
              if i - base > 0:  # 使用小于零钱的基值
                  count1 = min_list[i - base]  # 当前值减一次基值，查询最优解表，获取子问题最优解
                  if count1 < min_count:
                      min_count = count1  # 求最优解中的最优解
          min_list[i] = min_count + 1  # 子问题最优解+1的到当前值的最优解，+1对应 20减一次base
      return min_list[-1]  # 返回最后一个值为目标值
  num = 63
  print(coin_change(num))
  

博物馆大盗问题

大盗潜入博物馆，面前有5件宝物，分别有重量和价值，大盗的背包仅能负重20公斤，请问如何选择宝物，总价值最高?

item	weight	value
1	2	3
2	3	4
3	4	8
4	5	8
5	9	10

• 建模：核心是尽可能的达到最大负重，提供重量/价值比：

  • 相同重量不同物品搭配不同，选择高性价比；
  • 相同物品不同重量搭配不同，选择高价值，2个制约，画2个函数图，取较大值。

• 制约条件

  • 重量，必须计算小重量值时的最优解，大重量的最优解任何依赖小重量推导出
  • 物品数量

• 创建函数关系m(i,W)

  前 i (1<=i<=5)个宝物中，组合不超过 W (1<=W<=20)重量，得到的最大价值 m(i, W)，

1. m(i-1, W)，重量不变，第i个宝贝的性价比低，不添加第i件宝贝，i-1件宝贝在W重量下的最优值。(在Wi大于W时，必定是这种情况)

2. m(i-1, W-Wi)+vi，添加第i件宝贝，i-1件宝贝在W-Wi重量下的最优值再加上第i件宝贝价值vi。

   两者最大值，我们从m(1,1)开始计算到m(5,20)。
   

• 推演过程
  两个方向嵌套循环，递推表格

m(5,5) = m(4,5) = max(m(3,5),m(3,0)+8)
宝贝5个，重量5，第5个宝贝重量为9大于W（5），一定不会添加，所以等价于m(4,5)
m(4,5) 为m(3,5) 和 m(3,5[W]-5(w4)+8) 之间的最大值，都为8，所以m(5,5)等于8。
所以后面的价值依赖于前面的最优解。
表格数值依赖自身位置的上边和左边值，这些值是已经计算出来了。

• 代码实现

  # 宝物重量和价值
  tr = [None, {'w': 2, 'v': 3}, {'w': 3, 'v': 4},
        {'w': 4, 'v': 8}, {'w': 5, 'v': 8},
        {'w': 9, 'v': 10}]
  # 最大负重
  max_w = 20
  # 初始化二维表格m[(i,w)]
  # 表示前i个宝贝中，最大重量w的组合，所得到的最大价值
  # 当i 什么都不取，或w上限为0，价值为0
  m = {(i, w): 0 for i in range(len(tr)) for w in range(max_w + 1)}
  print(m)
  # 逐个填写二维表格
  for i in range(1, len(tr)):
      for w in range(1, max_w + 1):
          if tr[i]['w'] > w:	# 装不下第i个宝物
              m[(i, w)] = m[(i - 1, w)]
          else:
              print('=======================')
              print(f"m[({i} - 1, {w})] ,{m[(i - 1, w)]}")
              print(f"m[({i} - 1, {w} - {tr[i]['w']})] + {tr[i]['v']} ,{m[(i - 1, w - tr[i]['w'])] + tr[i]['v']}")
              # 不装第i个宝物和装第i个宝物，两种情况的较大值
              m[(i, w)] = max(m[(i - 1, w)], m[(i - 1, w - tr[i]['w'])] + tr[i]['v'])
  
  print(m[(5, 20)])
  

• 另一种思路步骤

  1. 规模增大，递增遍历，a、宝贝种类 b、重量总数，为什么会选择宝贝种类呢，因为价值和重量同时关联宝贝，所以递增宝贝种类；
  2. 随着宝贝种类增加，在重量不变时，需要添加value/weight高的宝贝，如果新增宝贝比例没有小序号的高时，不用拿新的，那就是选择m(i-1,w)的场景；
  3. 随着重量的增加，可以带走更大重量的产品，如果都选择低重量的产品导致有重量大量剩余的情况，那选择m(i-1,w-wi)+vi。

  tr2 = [{'w': 2, 'v': 3}, {'w': 3, 'v': 4},
         {'w': 4, 'v': 8}, {'w': 5, 'v': 8},
         {'w': 9, 'v': 10}]
  max_v = 0
  for i in range(len(tr2)):
      for j in range(i + 1, len(tr2)):
          v = tr2[i]['v'] + tr2[j]['v']
          if v > max_v:
              max_v = v
  

• 递归实现
  假设已经拿了5个宝物，重量超过20，去除哪些宝物后，重量小于等于20，并且剩余物品的最大值。

  tr2 = [(2, 3), (3, 4,), (4, 8), (5, 8,), (9, 10)]
  max_w = 20
  
  # 初始化记忆化表格m，减少重复计算
  # key是(宝物组合，最大重量)，value是最大价值
  m = {}
  def thief(tr, w):
      if tr == set() or w == 0:
          m[(tuple(tr), w)] = 0  # 键值为不可变类型
          return 0
      elif (tuple(tr), w) in m:
          return m[(tuple(tr), w)]
      else:
          v_max = 0
          for t in tr:
              if t[0] <= w:
                  # 逐个从集合中去掉某个宝物，递归调用
                  # 选出所以价值中的最大值
                  v = thief(set(tr) - {t}, w - t[0]) + t[1]
                  v_max = max(v_max, v)
          m[(tuple(tr), w)] = v_max
          return v_max
  
  print(thief(tr2, max_w))
  

递归算法总结

适用场景：递归是解决某些具有自相似性的复杂问题的有效技术。

递归算法“三定律”：必须具备基本结束条件；必须要减小规模，改变状态向基本结束条件演进；必须要调用自身。

某些情况下，递归可以代替迭代循环。

递归算法通常能够跟问题的表达自然契合，有时候递归算法会引发巨量的重复计算，可以使用“记忆化/函数值缓存”技术，通过附加存储空间记录中间计算结果来有效减少重复计算。

如果一个问题最优解包括规模更小相同问题的最优解，就可以用动态规划来解决。