【算法】【《计算机算法设计与分析（第5版）》笔记】第二章：递归与分治策略

个人主页：丷从心·

系列专栏：算法

---

2.1|递归的概念

Fibonacci数列非递归定义

$$F(n)=\frac{1}{\sqrt{5}}\left[{\left(\frac{1+\sqrt{5}}{2}\right)}^{n+1}-{\left(\frac{1-\sqrt{5}}{2}\right)}^{n+1}\right]$$

Ackerman函数

• 并非一切递归函数都能用非递归方式定义
• $Ackerman$函数是一个双递归函数，当一个函数及它的一个变量由函数自身定义时，称这个函数是双递归函数

递归方程

$$A(n,m)=\{\begin{array}{ll}2& n=1,m=0\\ 1& n=0,m\ge 0\\ n+2& n\ge 2,m=0\\ A(A(n-1,m),m-1)& n,m\ge 1\end{array}$$

• $A(n,m)$的自变量$m$的每个值都定义了一个单变量函数
  • 当$m=0$时，定义了函数“加$2$”
  • 当$m=1$时，由于$A(1,1)=A(A(0,1),0)=A(1,0)=2$，以及$A(n,1)=A(A(n-1,1),0)=A(n-1,1)+2(n>1)$，因此$A(n,1)=2n(n\ge 1)$，即$A(n,1)$是函数“乘$2$”
  • 当$m=2$时，$A(n,2)=A(A(n-1,2),1)=2A(n-1,2)$，$A(1,2)=A(A(0,2),1)=A(1,1)=2$，故$A(n,2)=2^n$
  • 类似地可以推出$A(n,3)=2^{2^{{╱}^2}}$，其中$2$的层数为$n$
  • $A(n,4)$的增长速度非常快，以至于没有适当的数学式子来表示这一函数
• 单变量的$Ackerman$函数$A(n)$定义为$A(n)=A(n,n)$，其拟逆函数 α ( n ) = min ⁡ {   k ∣ A ( k ) ≥ n   } \alpha(n) = \min\set{k \mid A(k) \geq n} α(n)=min{k∣A(k)≥n}
  • $A(4)=2^{2^{{╱}^2}}$（其中$2$的层数为$65536$）的值非常大，如果要写出这个数将需要$\log (A(4))$位，即$2^{2^{{╱}^2}}$（$65535$层$2$的方幂）位，所以对于通常见到的正整数$n$，有$\alpha (n)\le 4$
  • 在理论上$\alpha (n)$没有上界

Python实现

def ackerman(n, m):
    if n == 1 and m == 0:
        return 2
    elif n == 0 and m >= 0:
        return 1
    elif n >= 2 and m == 0:
        return n + 2
    elif n >= 1 and m >= 1:
        return ackerman(ackerman(n - 1, m), m - 1)


res = ackerman(3, 3)

print(res)

16

排列问题

问题描述

• 设 R = {   r 1 , r 2 , ⋯   , r n   } R = \set{r_{1} , r_{2} , \cdots , r_{n}} R={r1​,r2​,⋯,rn​}是要进行全排列的$n$个元素

分治算法

• R i = R − {   r i   } R_{i} = R - \set{r_{i}} Ri​=R−{ri​}

• 集合$X$中的元素的全排列记为$Perm(X)$，$(r_i)Perm(X)$表示在全排列$Perm(X)$的每个排列前加上前缀$r_i$得到的排列

• $R$的全排列可递归定义为

  • 当$n=1$时，$Perm(R)=(r)$，其中$r$是集合$R$中唯一的元素

  • 当$n>1$时，$Perm(R)$由$(r_1)Perm(R_1)$，$(r_2)Perm(R_2)$，$\cdots$，$(r_n)Perm(R_n)$构成

Python实现

def permute(nums):
    if len(nums) <= 1:
        return [nums]

    res = []

    for i in range(len(nums)):
        m = nums[i]
        remaining_nums = nums[:i] + nums[i + 1:]

        sub_permutations = permute(remaining_nums)

        for p in sub_permutations:
            res.append([m] + p)

    return res


nums = [1, 2, 3]

permutations = permute(nums)

for p in permutations:
    print(p)

[1, 2, 3]
[1, 3, 2]
[2, 1, 3]
[2, 3, 1]
[3, 1, 2]
[3, 2, 1]

整数划分问题

问题描述

• 将正整数$n$表示成一系列正整数之和，$n=n_1+n_2+\cdots +n_k(n_1\ge n_2\ge \cdots \ge n_k\ge 1,k\ge 1)$
• 正整数$n$的这种表示称为正整数$n$的划分，正整数$n$的不同的划分个数称为正整数$n$的划分数，记为$p(n)$

分治算法

• 在正整数$n$的所有划分中，将最大加数$n_1$不大于$m$的划分个数记作$q(n,m)$，可以建立$q(n,m)$的递归关系

$$q(n,m)=\{\begin{array}{ll}1,& n=1,m=1\\ q(n,n),& n<m\\ q(n,n-1)+1,& n=m\\ q(n,m-1)+q(n-m,m),& n>m>1\end{array}$$

Python实现

def integer_partition(n, m):
    if n < 1 or m < 1:
        return 0

    if n == 1 or m == 1:
        return 1

    if n < m:
        return integer_partition(n, n)

    if n == m:
        return integer_partition(n, n - 1) + 1

    return integer_partition(n, m - 1) + integer_partition(n - m, m)


n = 6

res = integer_partition(n, n)

print(f'The number of partitions for {n} is: {res}')

The number of partitions for 6 is: 11

Hanoi塔问题

问题描述

• 设$a$、$b$、$c$是三个塔座，开始时，在塔座$a$上有一叠共$n$个圆盘，这些圆盘自下而上，由大到小地叠放在一起，各圆盘从小到大编号为$1$，$2$，$\cdots$，$n$，要求将塔座$a$上的这一叠圆盘移到塔座$b$上，并仍按照同样顺序叠置
• 在移动圆盘时应遵守以下移动规则
  • 每次只能移动一个圆盘
  • 任何时刻都不允许将较大的圆盘压在较小的圆盘之上

非递归解法

• 假设塔座$a$、$b$、$c$按顺时针排成一个三角形
• 在移动圆盘的过程中，若是奇数次移动，则将最小的圆盘移动到顺时针方向的下一塔座上，若是偶数次移动，则保持最小的圆盘不动，而在其他两个塔座之间，将较小的圆盘移到另一塔座上去

Python实现

def hanoi(n):
    a = list(range(1, n + 1))
    a.append(n + 1)
    b = [n + 1]
    c = [n + 1]

    pos = 1
    i = 1
    while len(a) > 1 or len(b) < n + 1:
        if i % 2:
            if a[0] == 1:
                b.insert(0, a.pop(0))
                pos = 2
                print('将盘子 1 从 A 移动到 B')
            elif b[0] == 1:
                c.insert(0, b.pop(0))
                pos = 3
                print('将盘子 1 从 B 移动到 C')
            else:
                a.insert(0, c.pop(0))
                pos = 1
                print('将盘子 1 从 C 移动到 A')
        else:
            if pos == 1 and b[0] < c[0]:
                c.insert(0, b.pop(0))
                print(f'将盘子 {c[0]} 从 B 移动到 C')
            elif pos == 1 and c[0] < b[0]:
                b.insert(0, c.pop(0))
                print(f'将盘子 {b[0]} 从 C 移动到 B')
            elif pos == 2 and a[0] < c[0]:
                c.insert(0, a.pop(0))
                print(f'将盘子 {c[0]} 从 A 移动到 C')
            elif pos == 2 and c[0] < a[0]:
                a.insert(0, c.pop(0))
                print(f'将盘子 {a[0]} 从 C 移动到 A')
            elif pos == 3 and a[0] < b[0]:
                b.insert(0, a.pop(0))
                print(f'将盘子 {b[0]} 从 A 移动到 B')
            elif pos == 3 and b[0] < a[0]:
                a.insert(0, b.pop(0))
                print(f'将盘子 {a[0]} 从 B 移动到 A')

        i += 1


n = 3

hanoi(n)

将盘子 1 从 A 移动到 B
将盘子 2 从 A 移动到 C
将盘子 1 从 B 移动到 C
将盘子 3 从 A 移动到 B
将盘子 1 从 C 移动到 A
将盘子 2 从 C 移动到 B
将盘子 1 从 A 移动到 B

递归解法

Python实现

def hanoi(n, source, target, auxiliary):
    if n > 0:
        # 将 n - 1 个盘子从源柱移动到辅助柱
        hanoi(n - 1, source, auxiliary, target)
        # 将第 n 个盘子从源柱移动到目标柱
        print(f'将盘子 {n} 从 {source} 移动到 {target}')
        # 将 n - 1 个盘子从辅助柱移动到目标柱
        hanoi(n - 1, auxiliary, target, source)


n = 3

hanoi(n, 'A', 'B', 'C')

将盘子 1 从 A 移动到 B
将盘子 2 从 A 移动到 C
将盘子 1 从 B 移动到 C
将盘子 3 从 A 移动到 B
将盘子 1 从 C 移动到 A
将盘子 2 从 C 移动到 B
将盘子 1 从 A 移动到 B

---