本文介绍了贪心算法的基本概念及其特点，重点阐述了朴素贪心算法的工作原理和适用场景。通过局部最优解构建全局解，朴素贪心算法在简单问题中表现出高效性，但也存在局限性。文中提供了找零问题和区间调度问题的实例来进一步说明朴素贪心算法的应用。
了解贪心算法 贪心算法的基本概念贪心算法（Greedy Algorithm）是一种常用的算法设计策略。它主要通过局部最优解来构建全局最优解，即在每一步决策时都选择当前最优解，而不考虑未来的选择，从而希望最终能构建出全局最优解。贪心算法具有简单、直观的特点，但需要注意的是，并不是所有的贪心算法都能保证得到全局最优解。
贪心算法的代码示例（最短路径问题）
import heapq
def dijkstra(graph, start):
n = len(graph)
visited = [False] * n
distance = [float('inf')] * n
distance[start] = 0
priority_queue = [(0, start)]
while priority_queue:
current_distance, current_node = heapq.heappop(priority_queue)
if visited[current_node]:
continue
visited[current_node] = True
for neighbor, weight in enumerate(graph[current_node]):
if weight > 0 and not visited[neighbor]:
new_distance = current_distance + weight
if new_distance < distance[neighbor]:
distance[neighbor] = new_distance
heapq.heappush(priority_queue, (new_distance, neighbor))
return distance
# 测试代码
graph = [
[0, 1, float('inf'), 3, float('inf')],
[float('inf'), 0, 4, float('inf'), float('inf')],
[float('inf'), float('inf'), 0, 5, float('inf')],
[float('inf'), 2, float('inf'), 0, 1],
[float('inf'), float('inf'), float('inf'), float('inf'), 0]
]
start_node = 0
print(dijkstra(graph, start_node)) # 输出：[0, 1, 5, 3, 4]
``
## 贪心算法的特点和适用场景
### 特点
1. **局部最优解：** 贪心算法每一步都选择当前最优解。这种选择并不依赖于后续的步骤。
2. **简单直观：** 贪心算法的设计通常较为直接，易于理解和实现。
3. **效率高：** 如果贪心算法能保证全局最优解，那么它通常具有较高的效率。
4. **确定性：** 贪心算法的每一步决策都是确定性的，没有随机性。
### 适用场景
1. **最小生成树：** 例如Kruskal算法和Prim算法。
2. **最短路径问题：** 例如Dijkstra算法。
3. **哈夫曼编码：** 构建最优前缀编码。
4. **调度问题：** 例如区间调度问题。
5. **背包问题：** 有条件限制的背包问题。
6. **找零问题：** 例如使用最少的硬币找零。
# 介绍朴素贪心算法
## 什么是朴素贪心算法
朴素贪心算法是贪心算法的一种基本形式，它在每一步决策时都选择当前最优解，而不考虑后续影响。这种算法通常用于解决一些简单的、局部最优解能够保证全局最优解的问题。如果一个问题可以通过朴素贪心算法解决，则该算法通常会比其他复杂算法更加高效。
### 朴素贪心算法的代码示例（哈夫曼编码）
```python
import heapq
def huffman_encoding(frequencies):
priority_queue = [[weight, [char, ""]] for char, weight in frequencies.items()]
heapq.heapify(priority_queue)
while len(priority_queue) > 1:
lo = heapq.heappop(priority_queue)
hi = heapq.heappop(priority_queue)
for pair in lo[1:]:
pair[1] = '0' + pair[1]
for pair in hi[1:]:
pair[1] = '1' + pair[1]
heapq.heappush(priority_queue, [lo[0] + hi[0]] + lo[1:] + hi[1:])
return sorted(heapq.heappop(priority_queue)[1:], key=lambda x: len(x[1]))
# 测试代码
frequencies = {'A': 45, 'B': 13, 'C': 12, 'D': 16, 'E': 9, 'F': 5}
print(huffman_encoding(frequencies)) # 输出编码结果
朴素贪心算法的操作步骤如下：
- 初始化： 设置初始条件，通常包括数据结构的初始化。
- 选择当前最优解： 在每一步决策时，选择当前最优解。
- 更新状态： 根据当前最优解更新状态。
- 检查终止条件： 检查是否已经满足终止条件，通常是一个循环的终止条件。
- 输出结果： 返回最终结果。
找零钱问题是指给定若干种面值的硬币和一个需要找零的总金额，找出能够找零的最小数量的硬币。例如，给定面值为1、5、10、25的硬币，要找零30，可以使用两枚10面值的硬币，或者一枚25面值的硬币和一枚5面值的硬币。
算法步骤
- 初始化： 将找零的总金额设为剩余金额。
- 选择当前最优解： 每次选择当前最大的硬币面值。
- 更新状态： 每次选择一个硬币后，剩余金额减少相应面值。
- 检查终止条件： 当剩余金额为0时终止。
- 输出结果： 输出所用的硬币数量和面值。
代码示例
def coinChange(coins, amount):
# 对硬币面值进行排序，从大到小
coins.sort(reverse=True)
# 初始化结果数组
result = []
for coin in coins:
# 只要剩余金额大于等于当前硬币面值
while amount >= coin:
# 减去当前硬币面值
amount -= coin
# 添加当前硬币面值到结果中
result.append(coin)
# 如果剩余金额不为0，表示无法完成找零
if amount != 0:
return "无法找零"
else:
return result
# 测试代码
coins = [1, 5, 10, 25]
amount = 30
print(coinChange(coins, amount)) # 输出：[10, 10, 10]区间调度问题是指给定一系列区间，每个区间有一个开始时间和结束时间，目标是选择尽可能多的非重叠区间。例如，给定区间[1, 3]、[2, 4]、[3, 6]、[5, 7]，可以选择区间[1, 3]和[5, 7]，因为它们是不重叠的。
算法步骤
- 初始化： 将所有区间按照结束时间进行排序。
- 选择当前最优解： 每次选择结束时间最早的区间。
- 更新状态： 选择一个区间后，更新当前结束时间。
- 检查终止条件： 当所有区间都遍历完成。
- 输出结果： 输出选择的区间。
代码示例
import java.util.Arrays;
import java.util.List;
public class IntervalScheduling {
public static List<int[]> optimalScheduling(List<int[]> intervals) {
// 按照结束时间排序
intervals.sort((a, b) -> Integer.compare(a[1], b[1]));
List<int[]> result = new java.util.ArrayList<>();
int endTime = Integer.MIN_VALUE;
for (int[] interval : intervals) {
// 只要当前区间开始时间大于等于上一个区间的结束时间
if (interval[0] >= endTime) {
// 更新当前结束时间
endTime = interval[1];
// 添加当前区间到结果中
result.add(interval);
}
}
return result;
}
public static void main(String[] args) {
List<int[]> intervals = Arrays.asList(
new int[]{1, 3},
new int[]{2, 4},
new int[]{3, 6},
new int[]{5, 7}
);
List<int[]> result = optimalScheduling(intervals);
System.out.println(result); // 输出：[[1, 3], [5, 7]]
}
}代码实现
def coinChange(coins, amount):
# 对硬币面值进行排序，从大到小
coins.sort(reverse=True)
# 初始化结果数组
result = []
for coin in coins:
# 只要剩余金额大于等于当前硬币面值
while amount >= coin:
# 减去当前硬币面值
amount -= coin
# 添加当前硬币面值到结果中
result.append(coin)
# 如果剩余金额不为0，表示无法完成找零
if amount != 0:
return "无法找零"
else:
return result
# 测试代码
coins = [1, 5, 10, 25]
amount = 30
print(coinChange(coins, amount)) # 输出：[10, 10, 10]代码实现
import java.util.Arrays;
import java.util.List;
public class IntervalScheduling {
public static List<int[]> optimalScheduling(List<int[]> intervals) {
// 按照结束时间排序
intervals.sort((a, b) -> Integer.compare(a[1], b[1]));
List<int[]> result = new java.util.ArrayList<>();
int endTime = Integer.MIN_VALUE;
for (int[] interval : intervals) {
// 只要当前区间开始时间大于等于上一个区间的结束时间
if (interval[0] >= endTime) {
// 更新当前结束时间
endTime = interval[1];
// 添加当前区间到结果中
result.add(interval);
}
}
return result;
}
public static void main(String[] args) {
List<int[]> intervals = Arrays.asList(
new int[]{1, 3},
new int[]{2, 4},
new int[]{3, 6},
new int[]{5, 7}
);
List<int[]> result = optimalScheduling(intervals);
System.out.println(result); // 输出：[[1, 3], [5, 7]]
}
}- 高效性： 贪心算法通常时间复杂度较低，因为每一步决策都是基于局部最优解。
- 简单性： 贪心算法的设计通常较为简单，易于理解和实现。
- 确定性： 贪心算法的每一步决策都是确定性的，没有随机性。
- 局部最优解不保证全局最优解： 贪心算法在某些情况下，局部最优解并不能保证全局最优解。
- 适用范围有限： 贪心算法只能应用于某些特定的问题，对于某些问题可能不适用。
- 难以证明正确性： 对于某些问题，很难证明贪心算法的正确性。
朴素贪心算法是一种常用的算法设计策略，它通过局部最优解来构建全局最优解。尽管它在某些情况下能够高效地解决问题，但也有一定的局限性，局部最优解并不一定能保证全局最优解。因此，在使用贪心算法时，需要仔细分析问题是否适合使用贪心算法。
练习题- 找零问题： 给定面值为1、5、10、25的硬币，输出找零32所需的最少硬币数量。
- 区间调度问题： 给定一系列区间，每个区间有一个开始时间和结束时间，输出尽可能多的非重叠区间。
- 背包问题： 给定容量为10的背包，和一个物品列表，每个物品有重量和价值，输出能够放入背包中的最大价值。
- 最小生成树问题： 给定一个无向图，输出最小生成树的边集。
通过这些练习题，可以巩固你对贪心算法的理解并提高解决问题的能力。
随时随地看视频
