算法导论总结索引 | 第四部分第十六章：贪心算法

Asher Gu

于 2024-06-26 22:44:50 发布

阅读量764

点赞数 22

分类专栏：算法导论文章标签：算法贪心算法

本文链接：https://blog.csdn.net/AsherGu/article/details/139988554

版权

算法导论专栏收录该内容

16 篇文章 1 订阅

订阅专栏

1、求解最优化问题的算法通常需要经过一系列的步骤，在每个步骤都面临多种选择。对于许多最优化问题，使用动态规划算法求最优解有些杀鸡用牛刀了，可以使用更简单、更高效的算法
贪心算法（greedy algorithm）就是这样的算法，它在每一步都做出当时看起来最优的选择。也就是说，它总是做出局部最优的选择，寄希望通过这些选择导致全局最优解

2、贪心算法并不保证得到最优解，但对很多问题确实可以求得最优解

1、活动选择问题

一个调度竞争共享资源的多个活动的问题，目标是选出一个最大的互相兼容的活动集合。假定有一个 n 个活动的集合 S = {a1, a2, …, an}，这些活动使用同一资源（例如一个阶梯教室），每个活动 a_i 都有一个开始时间 s_i 和一个结束时间 f_i，其中 0 ≤ s_i < f_i < ∞。如果被选中， a_i 发生在 [si, fi) 期间。如果 a_i 和 a_j 满足 [s_i, f_i) 和 [s_j, f_j) 不重叠，则称它们是兼容的
当 s_i ≥ f_j 或 s_j ≥ f_i 时，a_i 和 a_j 是兼容的。希望选出一个最大兼容活动的子集

假定活动已按结束时间的单调递增顺序排列：
在这里插入图片描述
可以通过动态规划方法将这个问题分为两个子问题，然后将两个子问题的最优解结合成原问题的一个最优解。在确定该将哪些子问题用于最优解时，要考虑几种选择
贪心算法只需考虑一种选择（即贪心的选择），在做贪心选择时，子问题之一必定是空的，因此，只留下一个非空子问题。找到一种递归贪心算法来解决活动调动问题，并将递归算法转化为迭代算法，以完成贪心方法的过程

1.1 最优子结构

A_ij = A_ij U { a_k } U A_kj，而且 S_ij 中最大兼容任务子集 A_ij 包含 I A_ij I = | A_ik | + | A_kj l + 1 个活动
用剪切一粘贴办法证明最优解
A_ij 必然包含两个子问题 S_ik 和 S_kj 的最优解

用 c[i, j] 表示集合 S_ij 的最优解的大小
在这里插入图片描述

1.2 贪心选择

假如发现所有子问题都可以选择出一个活动加入到最优解，对于活动选择问题，只需要考虑一个选择，贪心选择

应该选择这样一个活动，选出它后剩下的资源应能被尽量多的其他任务所用。现在考虑可选的活动，其中必然有一个最先结束。应该选择S中最早结束的活动，因为它剩下的资源可供它之后尽量多的活动使用

选择最早结束的活动并不是本问题唯一的贪心选择方法：也可以选择最晚开始活动（开始要把活动开始时间从晚到早排序（贪心之前的排序很重要），然后把满足条件的顺次加入进去就行）

定理16.1 考虑任意非空子问题s，且 a_j 是 A_k 中结束时间最早的活动，则 a_m 在 S_k 的某个最大兼容子集中
在这里插入图片描述
虽然可以用动态规划方法求解活动选择问题，但并不需要这样做（此外，并未检查活动选择问题是否具有重叠子问题性质）。相反，可以反复选择最早结束的活动，保留与此活动兼容的活动，重复这一过程，直至无剩余活动可选
而且，因为总是选择最早结束的活动，所以选择的活动在结束时间上总是严格递增的，只需要按结束时间的单调递增顺序去处理所有活动，每个活动只考虑一次

贪心算法通常都是这种自顶向下的设计：做出一个选择，然后求解剩下的那个子问题

1.3 递归贪心算法

输入为两个数组 s 和 f，表示活动的开始和结束时间，下标 k 指出要求解的子问题 S_k, 以及问题规模 n

为了方便算法初始化，添加一个虚拟活动 a_0，其结束时间 f_0 = 0（因为上来的活动就是 k + 1），求解原问题即可调用RECURSIVE-ACTIVITY-SELECTOR(s, f, 0, n)

RECURSIVE-ACTIVITY-SELECTOR(s, f, k, n)
1  m = k + 1
2  while m <= n and s[m] < f[k]
3     m = m + 1
4  if m <= n
5     return {a_m} ∪ RECURSIVE-ACTIVITY-SELECTOR(s, f, m, n) // 下一代从 k = m 开始
6  else return ∅

可能因为 m>n 而终止，这意味着我们已经检查了 S_k 中所有活动，未找到与 a_k 兼容者

假定活动已经按结束时间排好序，则递归调用 RECURSIVE-ACTIVITY-SELECTOR(s, f, 0, n) 的运行时间为 Θ(n)，在整个递归调用过程中，每个活动只被 while 循环检查一次

1.4 迭代贪心算法

1、将算法转换为迭代形式。过程 RECURSIVE-ACTIVITY-SELECTOR 几乎就是“尾递归”。它以一个对自身的递归调用再接一次并集操作结尾。将一个尾递归过程改为迭代形式通常是很直接的，实际上，某些特定语言的编译器可以自动完成这一工作

GREEDY-ACTIVITY-SELECTOR(s, f)
1.  n = s.length
2.  A = {a_1}
3.  k = 1
4.  for m = 2 to n
5.      if s[m] >= f[k]
6.          A = A ∪ {a_m}
7.          k = m
8.  return A

与递归版本类似，在输入活动已按结束时间排序的前提下，GREEDY-ACTIVITY-SELECTOR 的运行时间为 Θ(n)

2、并不是所有贪心方法都能得到最大兼容活动子集。在剩余兼容活动中选择持续时间最短者不能得到最大集。在剩余兼容活动选择与其他剩余活动重叠最少者也是同理

3、假定有一组活动，需要将它们安排到一些教室，任意活动都可以在任意教室进行。希望使用最少的教室完成所有活动。设计一个高效的贪心算法来安排哪些活动在哪个教室进行

(这个问题称为区间图着色问题(interval-graph coloring problem))。可以构建一个区间图，其中表示活动的节点，边连接不兼容的活动。要求用最少的颜色对图的顶点进行着色，使用所有邻项顶点之间的不同颜色

在这里插入图片描述
这个算法的关键在于贪心策略：
总是优先使用已经空闲的讲堂来安排新的活动
只有当没有空闲讲堂时，才添加新的讲堂

在这里插入图片描述
不能用贪心了，O(n³) 是 i 从0到 n，j 从 i + 1 到 n，k 从 i 到 j
因为 c[i, k] + c[k, j] + V_k
希望最大化兼容活动的总价值，可以使用动态规划（Dynamic Programming, DP）来实现

def find_latest_non_conflicting(activities, n):
    for j in range(n-1, -1, -1):
        if activities[j][1] <= activities[n][0]:
            return j
    return -1

def activity_selection_with_values(activities):
    # 按结束时间排序
    activities.sort(key=lambda x: x[1])
    
    # 动态规划数组
    n = len(activities)
    dp = [0] * (n + 1)
    
    for i in range(1, n + 1):
        # 当前活动的值
        value = activities[i-1][2]
        
        # 查找最新的与当前活动兼容的活动
        j = find_latest_non_conflicting(activities, i-1)
        
        # 递推公式
        if j != -1:
            dp[i] = max(dp[i-1], value + dp[j+1])
        else:
            dp[i] = max(dp[i-1], value)
    
    return dp[n]

# 示例活动 (开始时间, 结束时间, 价值)
activities = [(1, 3, 5), (2, 5, 6), (4, 6, 5), (6, 7, 4), (5, 8, 11), (7, 9, 2)]
print("最大价值：", activity_selection_with_values(activities))

2、贪心算法原理

1、通过做出一系列选择来求出问题的最优解。在每个决策点，它做出在当时看来最佳的选择。这种启发式策略并不保证总能找到全局最优解

2、设计贪心算法步骤

将最优化问题转换为这样的形式：对其做出一次选择后，只剩下一个子问题需要求解
证明做出贪心选择后，原问题总是存在最优解，即贪心选择是安全的
证明做出贪心选择后，剩余的子问题满足性质：其最优解与贪心选择组合即可得到原问题的最优解，这样就得到了最优子结构

2.1 贪心选择性质

1、可以通过做出局部最优（贪心）选择来构建全局最优解

2、与动态规划先求解子问题才能进行第一次选择不同，贪心算法在进行第一次选择之前不求解任何子问题，一个动态规划算法是自底向上进行计算的，而一个贪心算法通常是自顶向下的，进行一次又一次选择，将给定问题实例变得更小

3、必须证明每个步骤做出贪心选择能生成全局最优解。这种证明通常首先考查某个子问题的最优解，然后用贪心选择替换某个其他选择来修改此解，从而得到一个相似但更小的子问题

进行贪心选择时不得不考虑众多选择，通常意味着可以改进贪心选择，使其更为高效
例如，在活动选择问题中，假定已经将活动按结束时间单调递增顺序排好序，则对每个活动能够只处理一次。通过对输入进行预处理或者使用适合的数据结构（通常是优先队列），通常可以使得贪心选择更快速，从而得到更有效的算法

2.2 最优子结构

1、如果一个问题的最优解包含其子问题的最优解，则称此问题具有最优子结构性质。此性质是能否应用动态规划和贪心算法的关键要素

活动选择问题为例，如果一个子问题 S_ij 的最优解包含活动a_k，那么必然也包含子问题 S_ik 和 S_kj 的最优解
如果知道 S_ij 的最优解应该包含哪个活动 a_k，就可以组合 a_k 以及 S_ik 和 S_kj 的最优解中所有活动来构造 S_ij 的最优解

2、论证最优子结构：将子问题的最优解与贪心选择组合在一起就能生成原问题的最优解。这种方法隐含对于子问题使用了数学归纳法，证明了每个步骤进行贪心选择都会生成原问题的最优解

2.3 贪心对动态规划

1、0-1背包问题：一个正在抢劫商店的小偷发现了 n 个商品，第 i 个商品价值 v_i 美元，重 w_i 磅，v_i 和 w_i 都是整数。小偷希望拿走价值尽货高的商品，但他的背包最多能容纳 W 磅重的商品， W是一个整数。应该拿哪些商品
（称这个问题是 0-1 背包问题，因为对每个商品，小偷要么把它完整拿走，要么把它留下，不能只拿走一部分）

2、在分数背包问题中，设定与 0-1 背包问题是一样的，不同的是：小偷可以拿走其一部分，而不是只能做出二元 (0-1) 选择

3、两个背包问题都具有最优子结构性质。对0-1背包问题，考虑重量不超过 W 而价值最高的装包方案。如果将商品 j 从此方案中删除，则剩余商品必须是重量不超过 W - w_j 的价值最高的方案

贪心策略可以求解分数背包问题，而不能求解 0-1 背包问题
为了求解分数背包问题，首先计算每个商品的每磅价值 v_i / w_i 。遵循贪心策略，首先尽量多地拿每磅价值最高的商品。通过将背包按每磅价值排序，贪心算法的运行时间可为 O(nlgn)

证明分数背包问题具有贪心选择性质
在这里插入图片描述

拿走商品 1 的策略对 0-1 背包问题无效是因为小偷无法装满背包，空闲空间降低了方案的有效每磅价值。在 0-1 背包问题中，当考虑是否将一个商品装入背包时，必须比较包含此商品的子问题的解与不包含它的子问题的解，然后才能做出选择。这会导致大量的重叠子问题——动态规划的标识

设计动态规划算法求解 0-1 背包问题，要求运行时间为 O(nW)，n 为商品数量，W 是小偷能放进背包中的最大商品总重量
动规不用事先排序
K含义：K[考虑过的物品，剩余空间重量]

0-1-KNAPSACK(n, W)
    Initialize an (n + 1) by (W + 1) table K
    for i = 1 to n
        K[i, 0] = 0
    for j = 1 to W
        K[0, j] = 0
    for i = 1 to n
        for j = 1 to W
            if j < i.weight
                K[i, j] = K[i - 1, j]
            else
                K[i, j] = max(K[i - 1, j], K[i - 1, j - i.weight] + i.value)

在这里插入图片描述

3、赫夫曼编码

1、根据每个字符的出现频率，赫夫曼算法构造出字符的最优二进制表示
在这里插入图片描述
每个字符用一个唯一的一二进制串表示，称为码字。如果使用定长编码，需要用3位表示6个字符：a=000, b=001, …, f=101。这种方法需要300,000个二进制位来编码文件

2、变长编码可以达到比定长编码好得多的压缩率，其思想是赋予高频字符短码字，赋予低频字符长码字。上图显示了六个字符的一种变长编码：1位的a表示，4位的f表示。因此，这种编码表示此文件
(45⋅1+13⋅3+12⋅3+16⋅3+9⋅4+5⋅4)⋅1000=224,000位
与定长编码相比节约了25%的空间，这是此文件的最优字符编码

3.1 前缀码

1、只考虑所谓前缀码，即没有任何字符是其他字符的前缀。与任何字符编码相比，前缀码都可以保证达到最优数据压缩率。因此只关注前缀码，不会丧失一般性

前缀码的作用是简化解码过程。由于没有码字是其他码字的前缀，编码文件的开始码字是无歧义的。可以简单地识别出开始码字，将其转换回原字符，然后对编码文件剩余部分重复这种解码过程

在上节的例子中，二进制串 001011101 可以唯一地解析为 0·0·101·1101，解码为 aabec

2、解码过程需要前缀码的一种方便的表示形式，以便可以容易地截取开始字符。一种二叉树表示可以满足这种需求，其叶结点为给定的字符。字符的二进制码字用从根结点到该字符叶结点的简单路径表示，其中 0 意味着 “转向左孩子”，1 意味着 “转向右孩子”
注意，编码树并不是二叉搜索树，因为叶节点并未有序排列，而内部结构并不包含字符关键字
在这里插入图片描述
文件的最优编码方案总是对应一棵 满(full) 二叉树，即每个非叶节点都有两个孩子结点。前文给出的定长编码实例不是最优的，因为它的二叉树表示并非满二叉树
若 C 为字母表且所有字符的出现频率均为正数，则最优编码树对应的树结构恰有 |C| 个叶结点，每个叶结点对应字母表中一个字符，且恰有 |C|−1 个内部结点

对字母表C中的每个字符c，令属性 c.freq 表示 c 在文件中出现的频率，令 d_T(c) 表示c的叶结点在树中的深度。注意，d_T(c) 也是字母c的码字的长度。则编码该文件需要
在这里插入图片描述

3.2 构造赫夫曼编码

1、贪心算法来构造最优前缀码，它的正确性证明依赖于贪心选择性质和最优子结构

2、算法自底向上地构建出对应最优编码的二叉树 T
它从 |C| 个叶结点开始，执行 |C|−1 次“合并”操作创建出最终的二叉树。算法使用一个以属性 freq 为关键字的最小优先队列 Q，以识别两个最低频率的对象将其合并。当合并两个对象时，得到的新对象的频率等于原来两个对象频率之和
（根搜索树不一样，没有其他对节点的顺序限制之后，只需要让频率大的靠近根，频率小的远离根）

HUFFMAN(C)
1  n = |C|
2  Q = C
3  for i = 1 to n-1
4     allocate a new node z
5     z.left = x = EXTRACT-MIN(Q) // 把代价最小的删除并返回
6     z.right = y = EXTRACT-MIN(Q)
7     z.freq = x.freq + y.freq
8     INSERT(Q, z)
9  return EXTRACT-MIN(Q) // return the root of the tree

由于字母表包含6个字符，初始队列大小为 n=6
在这里插入图片描述
for循环反复从队列中提取两个频率最低的结点 x 和 y，将它们合并为一个新结点z，替代它们。z的频率为 x 和 y 的频率之和
结点z将 x 作为其左孩子，将 y 作为其右孩子（顺序是不重要的，交换左右孩子会生成一种不同的编码，但代价完全一样）。经过 n−1 次合并后，第9行返回队列中剩下的唯一结点——编码树的根结点

3、为了分析赫夫曼算法的运行时间，假定 Q 是使用最小二叉堆实现的（参见第6章）。在第2行用 BUILD-MIN-HEAP过程（参见6.3节）将 Q 初始化，花费时间为 O(n)。第3～8行的 for 循环执行 n−1 次，且每个堆操作需要 O(lgn) 的时间，所以循环对总时间的贡献为 O(nlgn)。因此，处理一个n个字符的集合，HUFFMAN 的总运行时间为 O(nlgn)

3.3 赫夫曼算法的正确性

1、确定最优前缀码的问题具有贪心选择和最优子结构性质

2、（1）令 C 为一个字符表，其中每个字符 c∈C 都有一个频率 c.freq。令 x 和 y 是 C 中频率最低的两个字符。那么存在 C 的一个最优前缀码，x 和 y 的码字长度相同，且只有最后一个二进制位不同（即是兄弟结点，在最优的基础上每次合并仍是最优，即可合并）

证明证明的思想是令 T 表示任意一棵最优前缀码所对应的编码树，对其进行修改，得到表示另外一个最优前缀码的编码树，使得在新树中，x 和 y 是深度最大的叶结点，且它们为兄弟结点
如果可以构造这样一棵树，那么 x 和 y 的码字将有相同长度，且只有最后一位不同

令 a 和 b 是 T 中深度最大的兄弟叶结点，不失一般性，假定a.freq <= b.freq 且 x.freq＜= y.freq。由于 x.freq 和 y.freq 是叶结点中最低的两个频率，而 a.freq 和 b.freq 是两个任意频率。因此，我们有 x.freq <= a.freq 且 y.freq <= b.freq
交换 x 和 a 生成一棵新树 T’, 井在 T 中交换 b 和 y 生成一棵新树 T"
T和T’的代价差为
在这里插入图片描述
类似地，交换 x 和 b 也不能增加代价，所以 B(T′) − B(T’‘) 也是非负的。因此 B(T′′) < B(T)，由于 T 是最优的，我们有 B(T′’) = B(T)，这意味着 B(T′′) = B(T)。因此，T’’ 也是最优树，且 x 和 y 是其中深度最深的兄弟结点，引理成立
在这里插入图片描述
3、通过合并来构造最优树的过程，可以从合并出现频率最低的两个字符这样一个贪心选择开始。为什么这是一个贪心选择？可以将每一次合并操作的代价看做被合并的两项的频率之和

在每个步骤可选择的所有合并操作中，HUFFMAN 选择是代价最小的那个，下面的引理证明了构造最优前缀码的问题具有最优子结构性质

（2）令 C 为一个含有 n 个字符表，其中每个字符 c∈C 都有一个频率 c.freq。令 C’ 为 C 去棹字符 x 和 y, 加入一个新字符 z 后得到的宇母表，即 C’ = C - {x, y} ∪{z}，z.freq = x.freq + y.freq。令 T’ 为字母表 C’ 的任意一个最优前缀码对应的编码树。于是可以将 T’ 中叶结点 z 替换为一个以 x 和 y 为孩子的内部结点，得到树 T, 而 T 表示字母表C的一个最优前缀码

证明：用树 T’ 的代价 B(T’) 来表示树 T 的代价 B(T)
在这里插入图片描述
用反证法来证明引理。假定 T 对应的前缀码并不是 C 的最优前缀码，存在最优编码树 T’’ 满足 B(T′‘) < B(T)。不失一般性(由引理 16.2)，T’’ 包含兄弟结点 x 和 y，令 T’’ 将 T 中 x,y 及它们的父结点替换为叶结点 z 得到的树，其中 z.freq = x.freq + y.freq（T’‘’ 对应 T’，T’’ 对应 T）
在这里插入图片描述
与 T’ 对应 C’ 的一个最优前缀码的假设矛盾。因此 T 必然表示字符表 C 的一个最优前缀码，即最优 T 一定包含最优 T’'（最优子结构）

4、由（1）（2），过程 HUFFMAN 会生成一个最优前缀码
在这里插入图片描述
5、

Asher Gu

关注

22
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
算法导论总结索引 | 第四部分第十六章：贪心算法

活动选择问题：最优子结构，贪心选择，递归贪心算法，迭代贪心算法；贪心算法原理：贪心选择性质，最优子结构，贪心对动态规划；赫夫曼编码：前缀码，构造赫夫曼编码：前缀码，构造赫夫曼编码，赫夫曼编码的正确性
复制链接

扫一扫