AI大模型从0到1记录学习 数据结构和算法 day20

4.3 分治算法

4.3.1 概述

分治算法的基本思想为：将原问题递归的分解为若干个（通常是两个以上）规模较小、相互独立且性质相同的子问题，直到子问题足够简单，简单到可以直接求解。然后再返回结果，逐个解决上层问题。

实际上，前文提到的归并排序算法和快速排序算法都是分治思想的典型应用。

能使用分治算法解决的问题通常需要具备以下特点：

 可分解：问题可以被划分为多个规模较小的子问题。这些子问题通常具有相同的性质，并且可以独立地解决。

 存在基本情况：问题分解的小到一定程度后，就变得非常简单，简单到可以直接求解。

 可合并：可以通过合并多个子问题的解，得到原问题的解。

4.3.2 案例一：汉诺塔

力扣面试题08.06https://leetcode.cn/problems/hanota-lcci/description/

现有三根柱子A、B 和 C 。起始状态下，柱子A上套着圆盘，它们从上到下按照从小到大的顺序排列。要将所有圆盘移到柱子C上，并保持它们的原有顺序不变。在移动圆盘的过程中，需要遵守以下规则：

 圆盘只能从一根柱子顶部拿出，从另一根柱子顶部放入。

 每次只能移动一个圆盘。

 小圆盘必须时刻位于大圆盘之上。

1）思路分析

将规模为n的汉诺塔问题记作f(n)。例如f(3)代表将3个圆盘从A移动至C。

（1）只有1个圆盘

f(1)，将圆盘从A移动至C。

（2）有2个圆盘

f(2)，借助B将两圆盘从A移动至C，分为3步：

使用f(1)的方法将一个圆盘从A移动至B。

使用f(1)的方法将一个圆盘从A移动至C。

使用f(1)的方法将一个圆盘从B移动至C。

（3）有3个圆盘。

分为3步：

使用f(2)的方法借助C将2个圆盘从A移动至B。

使用f(1)的方法将1个圆盘从A移动至C。

使用f(2)的方法借助A将2个圆盘从B移动至C。

（4）有n个圆盘

分为3步：

使用f(n-1)的方法借助C将n-1个圆盘从A移动至B。

使用f(1)的方法将1个圆盘从A移动至C。

使用f(n-1)的方法借助A将n-1个圆盘从B移动至C。

def print_abc():

"""打印3个柱子"""

print("a:", a)

print("b:", b)

print("c:", c)

print()

def hanota(n, source, target, buffer):

只有一个盘子时，直接从源柱子移动到目标柱子

if n == 1:

target.append(source.pop())

return

# 1. 将 n-1 个盘子从源柱子移动到缓冲柱子
hanota(n - 1, source, buffer, target)
print_abc()

# 2. 将第 n 个盘子从源柱子移动到目标柱子
hanota(1, source, target, buffer)
print_abc()

# 3. 将 n-1 个盘子从缓冲柱子移动到目标柱子
hanota(n - 1, buffer, target, source)
print_abc()

if name == "main ":

n = 3

a = list(range(n, 0, -1))

b = []

c = []

hanota(n, a, c, b)

4.3.3 案例二：Karatsuba大整数乘法算法

Karatsuba（卡拉楚巴）算法是一种高效的大整数乘法算法，关键思想是通过分治法减少了传统乘法的计算量，从而降低了乘法的时间复杂度。

现有两个大整数A和B，它们的乘积C=A×B。在传统的朴素乘法算法中，两个n位数的乘积需要进行O(n2)次基本操作。因为每一位数字都需要与另一个数字的每一位相乘，然后再加上进位。

我们将A、B的高位部分和低位部分拆开，取数字长度的一半为m，分别表示为：

A=10m×A1+A0

B=10m×B1+B0

此时可以得到：C=A×B=(10m×A1+A0)×(10m×B1+B0)

=102m×A1×B1 + 10m×(A1×B0+A0×B1) + A0×B0

这个表达式由三项组成：

A1×B1：高位部分的乘积。

A0×B0：低位部分的乘积。

A1×B0+A0×B1：混合部分，涉及到高位与低位的交叉乘积。

注意到，A1×B0+A0×B1可以转换为(A1+A0)×(B1+B0)- A0×B0-A1×B1，即(A1+A0)×(B1+B0)-低位部分的乘积-高位部分的乘积，低位部分乘积和高位部分乘积可以复用，我们只需计算(A1+A0)×(B1+B0)，相较于计算A1×B0+A0×B1，减少了1次乘法计算。

令z0=A0×B0

令z1=(A1+A0)×(B1+B0)

令z2= A1×B1

此时结果C=102m× z2 + 10m×(z1−z2−z0) + z0

这样，Karatsuba通过减少了1个乘法操作，将原本的4次乘法运算变成了3次乘法运算，时间复杂度：T(n)=3T(n2)+O(n)，O(nlog3)≈O(n1.585)。

def karatsuba(x, y):

"""卡拉楚巴算法"""

将 x 和 y 转换为字符串

x_str, y_str = str(x), str(y)

n = max(len(x_str), len(y_str))

# 如果存在负数，将其转换为正数再调用 karatsuba
if x_str[0] == "-":
    return -karatsuba(-x, y)
if y_str[0] == "-":
    return -karatsuba(x, -y)

# 如果只剩1位则返回乘积
if n == 1:
    return x * y

# 确保数字长度一致
x_str = x_str.zfill(n)
y_str = y_str.zfill(n)

# 计算分割点
m = n // 2

# 将数字划分为高位部分和低位部分
high1, low1 = int(x_str[:-m]), int(x_str[-m:])
high2, low2 = int(y_str[:-m]), int(y_str[-m:])

# 递归调用 karatsuba
z0 = karatsuba(low1, low2)
z1 = karatsuba(low1 + high1, low2 + high2)
z2 = karatsuba(high1, high2)

return pow(10, 2 * m) * z2 + pow(10, m) * (z1 - z2 - z0) + z0

4.4 动态规划算法

4.4.1 概述

动态规划算法与分治法类似，也是通过将原问题拆分为若干子问题，然后递归求解子问题，最后再组合子问题的解进而得到原问题的解。不同的是，分治算法解决的问题，子问题通常相互独立。而动态规划解决的问题，子问题具有重叠现象，所谓的重叠现象，是指不同的子问题会有相同的子子问题。

对于这些重复的子问题，若不加干预，会进行多次的重复计算，效率低下。动态规划意义就是，能够保证每个重复的子问题只计算一次，其解决问题的思路就是将计算过的子问题保存起来，后续计算相同子问题时，便可直接获取结果。

动态规划算法的实现方式分为自上而下的记忆化递归和自下而上的迭代。自上而下的递归方式只需考虑原问题到子问题的递归公式，而无序考虑子问题的执行顺序；而自下而上的迭代方式，除了需要考虑递推关系，还需要确保子问题从小到大依次执行。

4.4.2 案例一：爬楼梯

力扣70题https://leetcode.cn/problems/climbing-stairs/description/

爬有n个台阶的楼梯，每次可以爬1或2个台阶。有多少种不同的方法可以爬到楼顶？

1）方法一

由于每次只能个或个台阶，所以第n个台阶可能是从第n-1个台阶爬1阶上来的，也可能是从第n-2个台阶爬2阶上来的，所以爬到第n阶的方法数就等于爬到第n-1阶的方法数加上爬到第n-2阶的方法数。故可以得到状态转移方程：f(n) = f(n-1) + f(n-2)。

def climb(n):

if n == 1:

return 1

elif n == 2:

return 2

else:

return climb(n - 1) + climb(n - 2)

2）方法二

既然f(n) = f(n-1) + f(n-2)，那么我们也可以自下而上从1阶台阶开始逐渐增加，并记录当前阶方法数和当前阶-1的方法数。

def climb(n):

pre = 1

cur = 1

for _ in range(1, n):

pre, cur = cur, pre + cur

return cur

4.4.3 案例二：最大的连续子数组之和

力扣53题https://leetcode.cn/problems/maximum-subarray/description/

找出整数数组nums中数组之和最大的连续子数组（子数组最少包含一个元素），返回其最大和。

示例：

 输入：nums = [-2,1,-3,4,-1,2,1,-5,4]

 输出：6

解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

1）思路分析

用f(x)表示以x结尾的最大子数组之和，考虑处于位置i时，有两种选择：

 与之前的子数组组成连续子数组，此时子数组之和f(i) = f(i-1) + nums[i]。

 中断连续，从头开始一个新的连续子数组，此时f(i) = nums[i]。

得到状态转移方程：f(i) = max( f(i-1) + nums[i] , nums[i] )。

持续组成连续子数组，除非连续子数组之和已经<0，此时中断连续。

def max_subarray(nums):

result, f = nums[0], 0

for i in nums:

连续子数组之和若小于0，则中断连续

if f < 0:

f = 0

累加连续子数组之和

f += i

更新最大值

if result < f:

result = f

return result

4.4.4 案例三：0-1背包

0-1背包问题是一个经典的动态规划问题。其基本描述是：给定一组物品，每个物品都有一个重量和一个价值，在背包容量有限的情况下，如何选择物品放入背包，使得背包中物品的总价值最大化，且总重量不超过背包的容量。

 物品：有n个物品，每个物品i的重量为weight[i]和价值value[i]。

 背包容量：背包可以承载的最大重量为W。

 目标：选择若干物品放入背包，使得总重量不超过W，且总价值最大。

1）方法一

（1）定义状态

定义一个二维数组 dp[i][j]，表示前i个物品中，总重量不超过j的情况下，能够取得的最大价值。

 i：表示考虑第i个物品。

 j：表示背包当前容量为j。

（2）状态转移

对于每个物品i，有两个选择：

 不选第i个物品：此时最大价值就是前i−1个物品在容量j下的最大价值，即 dp[i−1][j]。

 选第i个物品：此时背包剩余容量为j−weighti，所以最大价值为valuei+dp[i−1][j−weighti]，前提是 j≥wi。

状态转移方程：dp[i][j] =max( dp[i−1][j] , valuei+dp[i−1][j−weighti] )

最大价值会存储在 dp[n][W]中，其中n是物品的数量，W是背包的最大容量。

（3）实现步骤

 初始化二维数组dp，i行、W+1列，因为要存放背包容量为0~W时的状态。

 循环中每次增加一个可选物品。

 每增加一个可选物品后遍历背包容量为0~W。考虑该物品是否放得下背包，如果放得下，将放进去后和不放进去进行比较。

def knapsack(weights, values, W):

n = len(weights)

初始化二维数组dp，dp[i][j]表示前i个物品中，背包容量为j时的最大价值

dp = [[0] * (W + 1) for _ in range(n)]

# 每次增加一个可选物品，增加物品后遍历一次背包重量
for i in range(n):
    for j in range(1, W + 1):
        # 如果当前物品放的进背包，进行比较
        if weights[i] <= j:
            dp[i][j] = max(dp[i - 1][j], values[i] + dp[i - 1][j - weights[i]])
        # 如果当前物品放不进背包，使用上轮相同j的状态
        else:
            dp[i][j] = dp[i - 1][j]

        print(f"前{i + 1}个物品，背包容量为{j}时")
        for row in range(len(dp)):
            print(dp[row])

return dp[n - 1][W]

if name == "main ":

weights = [1, 2, 3] # 物品的重量

values = [3, 2, 6] # 物品的价值

W = 3 # 背包的最大容量

print(knapsack(weights, values, W))

2）方法二

可以看到在方法一中，我们每轮遍历时只用到上1轮的结果，与这一轮的结果无关，因此我们只用一维数组存储上1轮的结果即可。

并且遍历时需要从后往前遍历，防止这轮结果将还需要用到的上轮结果覆盖。

并且不用全部遍历，遍历到背包当前重量刚好大于当前物品重量即可。

def knapsack(weights, values, W):

n = len(weights)

dp = [0] * (W + 1)

for i in range(n):

for j in range(W, weights[i] - 1, -1): # 从后往前遍历

dp[j] = max(dp[j], values[i] + dp[j - weights[i]])

return dp[W]

if name == "main ":

weights = [1, 2, 3] # 物品的重量

values = [3, 2, 6] # 物品的价值

W = 3 # 背包的最大容量

print(knapsack(weights, values, W))

4.4.5 案例四：完全背包

完全背包问题是0-1背包问题的一种扩展。与0-1背包不同，完全背包问题允许每个物品可以被选取多次，也就是说，物品的数量没有限制。

1）方法一

（1）定义状态

定义一个二维数组 dp[i][j]，表示前i个物品中，总重量不超过j的情况下，能够取得的最大价值。

 i：表示考虑第i个物品。

 j：表示背包当前容量为j。

（2）状态转移

相较于0-1背包，仅有选择放入第i个物品时发生了变化。

对于每个物品i，有两个选择：

 不选第i个物品：与0-1背包相同，此时最大价值就是前i−1个物品在容量j下的最大价值，即 dp[i−1][j]。

 选第i个物品：此时背包剩余容量为j−weighti，所以最大价值为valuei+dp[i][j−weighti]。

状态转移方程：dp[i][j] =max( dp[i−1][j] , valuei+dp[i][j−weighti] )

状态转移方程相较于0-1背包问题仅有一处 i-1 变为了 i。

（3）实现步骤

 初始化二维数组dp，i行、W+1列，因为要存放背包容量为0~W时的状态。

 循环中每次增加一个可选物品。

 每增加一个可选物品后遍历背包容量为0~W。考虑该物品是否放得下背包，如果放得下，将放进去后和不放进去进行比较。

def knapsack(weights, values, W):

n = len(weights)

初始化二维数组dp，dp[i][j]表示前i个物品中，背包容量为j时的最大价值

dp = [[0] * (W + 1) for _ in range(n)]

# 每次增加一个可选物品，增加物品后遍历一次背包重量
for i in range(n):
    for j in range(1, W + 1):
        # 如果当前物品放的进背包，进行比较
        if weights[i] <= j:
            dp[i][j] = max(dp[i - 1][j], values[i] + dp[i][j - weights[i]])
        # 如果当前物品放不进背包，使用上轮相同j的状态
        else:
            dp[i][j] = dp[i - 1][j]

        print(f"前{i + 1}个物品，背包容量为{j}时")
        for row in range(len(dp)):
            print(dp[row])

return dp[n - 1][W]

if name == "main ":

weights = [1, 2, 3] # 物品的重量

values = [3, 7, 11] # 物品的价值

W = 3 # 背包的最大容量

print(knapsack(weights, values, W))

2）方法二

方法一同样可以优化为一维数组。可以看到在方法一中我们既使用了上1轮结果，也使用了本轮i之前的结果，但是两者上下没有重叠。

这时我们遍历时需要从前向后遍历，因为可能会用到本轮i之前的结果。

def knapsack(weights, values, W):

n = len(weights)

dp = [0] * (W + 1)

for i in range(n):
    for j in range(weights[i], W + 1):
        dp[j] = max(dp[j], dp[j - weights[i]] + values[i])

return dp[W]

if name == "main ":

weights = [1, 2, 3] # 物品的重量

values = [3, 7, 11] # 物品的价值

W = 3 # 背包的最大容量

print(knapsack(weights, values, W))

4.5 回溯算法

4.5.1 概述

回溯算法是一种通过探索所有可能的解来解决问题的算法。回溯法采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现，现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题的答案。回溯法通常用递归方法来实现。

回溯算法的基本步骤可以总结为：

 选择：在每个决策点选择一个候选解。

 探索：递归地继续在下一个决策点上做选择。

 验证：在每次选择之后，检查当前路径是否满足条件。

 回溯：当某条路径不满足条件或无法继续时，回到上一步，尝试其他可能的选择。

4.5.2 案例一：全排列

力扣46题https://leetcode.cn/problems/permutations/description/

现有一个不含重复数字的数组nums ，返回其所有可能的全排列。

示例：

 输入：nums = [1,2,3]

 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

1）思路分析

实现步骤：

 选择：从待排列的元素中选择一个元素作为当前位置的元素。

 递归：将该元素固定在当前位置后，递归排列下一个元素。

 终止条件：所有位置的元素都已确定，添加到结果中并终止递归。

 回溯：回到上一步，撤销当前的选择，尝试下一个可能的元素。

def permute(nums):

result = []

def backtrack(start):
    # 到达末尾，将此时排列结果添加到最终结果中
    if start == len(nums):
        result.append(nums[:])
        return

    for i in range(start, len(nums)):
        # 选取当前位置的元素：将要选取的元素与此位置的元素互换
        if start != i:
            nums[start], nums[i] = nums[i], nums[start]
        # 递归处理下一个位置的元素
        backtrack(start + 1)
        # 回溯，恢复原始数组
        if start != i:
            nums[start], nums[i] = nums[i], nums[start]

backtrack(0)
return result

4.5.3 案例二：N皇后

力扣51题https://leetcode.cn/problems/n-queens/description/

按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。

n皇后问题研究的是如何将n个皇后放置在n×n的棋盘上，并且使皇后彼此之间不能相互攻击。给一个整数n，返回所有的解决方案。每一个方案中 'Q' 和 '.' 分别代表了皇后和空位。

 输入：n = 4

 输出：[[".Q...","...Q","Q...","...Q."],["...Q.","Q...","...Q",".Q..."]]

解释：如上图所示，4皇后问题存在两个不同的解法。

1）思路分析

实现步骤：

 选择：从棋盘每行中选择一个列放置棋子。

 验证合法性：每次放置一个皇后时，检查该位置是否与其他已经放置的皇后在列或对角线上发生冲突。

 递归：棋子放置位置合法则递归放置下一个棋子。

 终止条件：若所有棋子都放置完则终止递归。

 回溯：回到上一步，尝试下一个位置。

def n_queens(n):

result = []

cols = set() # 记录哪些列有皇后

diag1 = set() # 记录哪些主对角线上有皇后

diag2 = set() # 记录哪些副对角线上有皇后

# 初始化棋盘
board = [["." for _ in range(n)] for _ in range(n)]

def backtrack(row):
    # 如果已经放置了n个皇后，说明找到一个解
    if row == n:
        result.append(["".join(row) for row in board])
        return

    for col in range(n):
        # 检查当前列和对角线是否有皇后
        if col in cols or (row - col) in diag1 or (row + col) in diag2:
            continue  # 如果有冲突，跳过当前列

        # 放置皇后
        board[row][col] = "Q"
        # 标记当前列和对角线
        cols.add(col)
        diag1.add(row - col)
        diag2.add(row + col)

        # 递归处理下一行
        backtrack(row + 1)

        # 回溯，删除当前位置的皇后，并清理列和对角线的标记
        board[row][col] = "."
        cols.remove(col)
        diag1.remove(row - col)
        diag2.remove(row + col)

backtrack(0)

return result

4.6 贪心算法

4.6.1 概述

贪心算法在解决问题时，采取的是逐步选择当前状态下最优的选项（即局部最优解），并期望通过这些局部最优解得到全局最优解。在每一步中，贪心算法都会选择当前看起来最优的选择，不考虑未来的选择。并通过一系列局部最优的选择，最终达到全局最优解（虽然并非总是能得到最优解，贪心算法的有效性依赖于问题的特性）。

贪心算法的特点：

 选择性：在每一步选择中，贪心算法根据某种启发式策略选择局部最优解。

 不可回溯：一旦做出了选择，就不能回退或重新考虑。

 局部最优：每一步的选择都依赖于局部最优，但并不保证整个问题能得到全局最优解。

贪心算法能够得到全局最优解的条件是问题需要满足贪心选择性质和最优子结构：

 贪心选择性质：通过局部最优的选择可以导出全局最优解。也就是说，每一步的局部选择都不会影响后续的选择，最终可以得到全局最优。

 最优子结构：问题的最优解包含子问题的最优解，即可以通过解决子问题来构建问题的最终解。

4.6.2 案例一：最大交换

力扣670题https://leetcode.cn/problems/maximum-swap/description/

现有一个非负整数，至多可以交换一次数字中的任意两位。返回能得到的最大值。

示例：

 输入：2736

 输出：7236

解释：交换数字2和数字7。

1）思路分析

从右向左遍历，同时维护一个最大数的索引。

 如果当前位置的数大于最大数，则更新最大数索引。

 否则将当前位置的数与最大数进行交换，交换后的数更新到result中，再将两个位置的数交换回来将数组恢复原样。

遍历结束后，result中的数就是能得到的最大值。

def maximumSwap(num):

result = num

num_list = list(str(num))

max_index = -1 # 最大值的索引

for i in range(len(num_list) - 1, -1, -1):

当前值大于最大值时，更新最大值的索引

if num_list[i] > num_list[max_index]:

max_index = i

当前值小于最大值时，交换，更新result，再交换回来

else:

num_list[i], num_list[max_index] = num_list[max_index], num_list[i]

result = max(result, int("".join(num_list)))

num_list[i], num_list[max_index] = num_list[max_index], num_list[i]

return result

4.6.3 案例二：分发糖果

力扣135题https://leetcode.cn/problems/candy/description/

n个孩子站成一排。用一个整数数组ratings表示每个孩子的评分。按照以下要求，给这些孩子分发糖果：

 每个孩子至少分配到1个糖果。

 相邻两个孩子评分更高的孩子会获得更多的糖果。

给每个孩子分发糖果，计算并返回需要准备的最少糖果数目。

1）方法一

每个孩子先分发1个糖果。

从左向右遍历，如果右边孩子比左边孩子评分高，则右边孩子糖果数量应该>左边孩子糖果数量，这时令右边孩子糖果数量为左边孩子糖果数量+1。

再从右向左遍历，如果左边孩子比右边孩子评分高，则左边孩子糖果数量应该为max(右边孩子糖果数量+1, 自己糖果数量)。

def candy(ratings):

n = len(ratings)

# 每个孩子先分发1个糖果
candy_num = [1] * len(ratings)

# 从左向右遍历，如果右边评分更高，则右边孩子的糖果数改为左边孩子的糖果数+1
for pos in range(n - 1):
    if ratings[pos] < ratings[pos + 1]:
        candy_num[pos + 1] = candy_num[pos] + 1

# 从右向左遍历，如果左边评分更高，则左边孩子的糖果数改为右边孩子的糖果数+1
total_candies = candy_num[-1]
for pos in range(n - 2, -1, -1):
    if ratings[pos] > ratings[pos + 1]:
        if candy_num[pos] <= candy_num[pos + 1]:
            candy_num[pos] = candy_num[pos + 1] + 1
    total_candies += candy_num[pos]
return total_candies

2）方法二

每个孩子先分发1个糖果。

按孩子评分相较于前一个孩子评分的增加、减少、不变分成3个区域，分别是上升区、下降区、平缓区。

在进入不同区域时，执行不同的操作：

 上升区

上升区长度+1，并清空之前的下降区长度。同时在result中累加糖果数。上升区或下降区长度每增加1，result中都需要增加与上升区或下降区长度相同数量的糖果。

 下降区

下降区存在一个特殊的准下降区。当从上升区进入下降区后，第一个进入的为准下降区。

准下降区不计入下降区长度。

当下降区长度等于上升区长度时，准下降区转变为真下降区并计入下降区长度。

下降区内清空之前的上升区长度，同时在result中累加糖果数。

 平缓区

清空所有记录，没有其他操作。

def candy(ratings):

每个孩子分发一个糖果

result = len(ratings)

上升区长度

up_length = 0

上升区长度的记录

up_num = 0

下降区长度

down_length = 0

for i in range(1, len(ratings)):

如果处于上升区

if ratings[i] > ratings[i - 1]:

上升区长度+1，清空下降区长度，并在result中累加糖果数

up_length += 1

up_num = up_length

down_length = 0

result += up_length

如果处于下降区

elif ratings[i] < ratings[i - 1]:

如果上升区长度为0，说明前一个位置已经不在上升区内，下降区长度+1

if up_length == 0:

down_length += 1

如果下降区长度已经等于之前上升区长度,说明峰值的糖果数由下降区决定，下降区长度+1

if down_length == up_num:

down_length += 1

清空上升区长度

up_length = 0

result += down_length

如果处于平缓区

else:

清空所有记录

up_length = 0

down_length = 0

up_num = 0

return result