贪心算法经典案例：区间调度与霍夫曼编码的问题解决思路

最新推荐文章于 2025-11-25 11:08:34 发布

原创最新推荐文章于 2025-11-25 11:08:34 发布 · 581 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#贪心算法 #ios #算法

贪心算法经典案例：区间调度与霍夫曼编码的问题解决思路

贪心算法是一种在每一步选择局部最优解的策略，旨在通过累积这些选择达到全局最优解。它适用于问题具有“贪心选择性质”和“最优子结构”的场景，即局部最优决策能导向全局最优解。本文将探讨两个经典案例：区间调度问题和霍夫曼编码，分别解决资源分配和数据压缩难题。文章结构清晰，逐步解析问题定义、贪心策略、算法步骤及实现代码，帮助读者深入理解贪心算法的实际应用。

一、区间调度问题

区间调度问题（如活动选择问题）的核心是：给定一组活动，每个活动有开始时间$s_i$和结束时间$f_i$，目标是选择最大数量的互不重叠活动。贪心算法在此问题中表现优越，因为它能避免全局搜索，直接基于局部信息决策。

问题定义：
设有$n$个活动，表示为集合$S = { (s_1, f_1), (s_2, f_2), \dots, (s_n, f_n) }$，其中$s_i < f_i$。需找到子集$A \subseteq S$，使得$A$中任意两个活动$i$和$j$满足$f_i \leq s_j$或$f_j \leq s_i$（即不重叠），且$|A|$最大。

贪心策略：
选择结束时间最早的活动。这利用了贪心选择性质：结束时间最早的活动能留出更多时间给后续活动，从而最大化总活动数。数学上，证明该策略最优的关键在于：如果存在最优解，它一定包含当前结束时间最小的活动。

算法步骤：

将所有活动按结束时间$f_i$升序排序。
初始化选择集合$A$为空，并设置当前结束时间$f_{\text{current}} = 0$。
遍历排序后的活动列表：
- 对于每个活动$i$，如果$s_i \geq f_{\text{current}}$（即不重叠），则将其加入$A$，并更新$f_{\text{current}} = f_i$。
返回$A$作为最大互不重叠活动子集。

复杂度分析：
排序时间复杂度为$O(n \log n)$，遍历为$O(n)$，总体$O(n \log n)$。空间复杂度$O(1)$（忽略排序空间）。

示例代码（Python）：
以下代码实现贪心算法求解活动选择问题。输入为活动列表，每个活动为元组$(s_i, f_i)$；输出为选择的活动索引列表。

def activity_selection(activities):
    # 按结束时间排序
    activities.sort(key=lambda x: x[1])
    selected = []
    last_end = 0
    
    for i, (start, end) in enumerate(activities):
        if start >= last_end:  # 检查是否不重叠
            selected.append(i)
            last_end = end
    
    return selected

# 示例使用
activities = [(1, 4), (3, 5), (0, 6), (5, 7), (8, 9)]
print("选择的活动索引:", activity_selection(activities))  # 输出: [0, 3, 4]

二、霍夫曼编码问题

霍夫曼编码是一种贪心算法，用于数据压缩。它通过构建最优前缀码（无歧义解码）最小化编码长度，其中频率高的字符使用短码，频率低的用长码。贪心策略确保整体压缩率接近理论极限。

问题定义：
给定字符集和每个字符的频率$f_i$，需构建一棵二叉树（霍夫曼树），其中叶子节点代表字符，路径代表编码（如左0右1）。目标是最小化加权路径长度，即最小化$\sum f_i l_i$，其中$l_i$是字符$i$的码长。

贪心策略：
反复合并频率最低的两个节点。这利用了贪心选择性质：合并最低频率节点能优先减少高成本的长码影响，从而全局最小化$\sum f_i l_i$。数学上，霍夫曼树满足前缀码最优性，即熵下界$\sum f_i \log_2 \frac{1}{f_i}$。

算法步骤：

创建叶子节点，每个节点对应一个字符及其频率$f_i$。
将所有节点放入优先队列（最小堆），按频率排序。
当队列中节点数大于1时：
- 提取频率最小的两个节点$A$和$B$。
- 创建新节点$C$，频率$f_C = f_A + f_B$，$A$和$B$作为子节点（$A$为左，$B$为右）。
- 将$C$加入队列。
最后剩余节点为霍夫曼树根节点。
从根节点遍历树，分配编码（左分支0，右分支1）。

复杂度分析：
建堆时间复杂度$O(n)$，每次合并$O(\log n)$，总体$O(n \log n)$。空间复杂度$O(n)$。

示例代码（Python）：
以下代码实现霍夫曼编码构建。输入为字典freq_dict，键为字符，值为频率；输出为编码字典。

import heapq

class Node:
    def __init__(self, char, freq):
        self.char = char
        self.freq = freq
        self.left = None
        self.right = None
    
    def __lt__(self, other):
        return self.freq < other.freq

def build_huffman_tree(freq_dict):
    heap = [Node(char, freq) for char, freq in freq_dict.items()]
    heapq.heapify(heap)
    
    while len(heap) > 1:
        left = heapq.heappop(heap)
        right = heapq.heappop(heap)
        merged = Node(None, left.freq + right.freq)
        merged.left = left
        merged.right = right
        heapq.heappush(heap, merged)
    
    return heap[0]  # 根节点

def generate_codes(root, current_code="", codes={}):
    if root is None:
        return
    if root.char is not None:  # 叶子节点
        codes[root.char] = current_code
    generate_codes(root.left, current_code + "0", codes)
    generate_codes(root.right, current_code + "1", codes)
    return codes

def huffman_coding(freq_dict):
    root = build_huffman_tree(freq_dict)
    return generate_codes(root)

# 示例使用
freq_dict = {'a': 5, 'b': 9, 'c': 12, 'd': 13, 'e': 16}
huffman_codes = huffman_coding(freq_dict)
print("霍夫曼编码:", huffman_codes)  # 输出示例: {'a': '110', 'c': '00', 'b': '111', 'e': '10', 'd': '01'}