为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 朴素贪心算法入门教程

朴素贪心算法入门教程

标签：
算法与数据结构
概述

朴素贪心算法是一种在每一步选择中都采取当前最优选择的贪心算法，虽然其简单直接，但在许多情况下能有效解决问题。它通过局部最优解的选择来试图达到全局最优解，但并不总是能确保全局最优解。本文将详细介绍朴素贪心算法的特点、应用场景和局限性。

定义与基本概念

贪心算法是一种在每一步选择中都采取当前看来最优的选择，从而希望导致全局最优解的算法。它在求解问题时，总是做出当前看来最好的选择，而不考虑长远的影响。贪心算法的每一步都是局部最优解的选取，但最终结果并不一定是最优解。

朴素贪心算法是贪心算法的一种简单应用形式，它在每一步决策中只考虑当前的最佳选择，不考虑未来可能的选择影响，这种“一招鲜，吃遍天”的理念虽然简单直接，但是却在很多情况下能有效地解决问题。

贪心算法的基本概念

贪心算法的基本思想是：

  1. 局部最优解：在每一个决策点，选择当前看来最优的选择。
  2. 全局最优解：期望通过一系列局部最优解的选择，最终达到全局最优解。

贪心算法的特点在于其贪婪的特性，在每一步决策时，总是选择当前最优解，而不考虑未来的决策。这种算法适用于一些特定的问题，但并不总能得到全局最优解。

朴素贪心算法的定义

朴素贪心算法是一种简单的贪心算法实现。它在解决问题时，遵循一个基本的原则：在每一步选择中，都选择当前最优的选择，而不考虑未来的影响。这种算法适用于一些特定的问题，但其局限性在于可能无法保证全局最优解。

实例代码

以下是一个简单的贪心算法示例，用于解决一个简单的背包问题。在这个问题中，我们有一个背包和一组物品，每个物品都有一个重量和价值。我们需要选择一些物品放入背包，使得背包的总价值最大，但不能超过背包的最大容量。

def greedy_knapsack(weights, values, capacity):
    # 计算每个物品的单位价值
    unit_values = [v / w for w, v in zip(weights, values)]

    # 按单位价值从高到低排序
    sorted_items = sorted(zip(unit_values, weights, values), reverse=True)

    total_value = 0
    remaining_capacity = capacity

    for unit_value, weight, value in sorted_items:
        if weight <= remaining_capacity:
            total_value += value
            remaining_capacity -= weight
        else:
            fraction = remaining_capacity / weight
            total_value += value * fraction
            break

    return total_value

# 示例数据
weights = [10, 20, 30]
values = [60, 100, 120]
capacity = 50

# 调用函数并打印结果
print(greedy_knapsack(weights, values, capacity))  # 输出应为 240.0

在这个示例中，我们首先计算每个物品的单位价值，然后按照单位价值从高到低排序。接着，我们从排序后的列表中选择物品，直到背包容量不足，选择部分物品以充分利用剩余容量。这种方法简单直接，但可能不是全局最优解。

贪心算法与局部最优解的关系

局部最优解是在当前决策点选择最优解，而全局最优解是在所有决策点选择最优解后的整体最优解。朴素贪心算法在每一步选择时只考虑当前最优解，因此可能会错过全局最优解。然而，在某些特定问题中，每一步选择局部最优解最终也会得到全局最优解。

实例代码

以下是一个简单的例子，展示了局部最优解与全局最优解之间的关系。假设我们有一个问题，需要从一堆物品中选择一些物品放入背包，且背包有容量限制。我们使用贪心算法选择单位价值最高的物品。

def greedy_selection(values, weights, capacity):
    # 计算每个物品的单位价值
    unit_values = [value / weight for value, weight in zip(values, weights)]

    # 按单位价值从高到低排序
    sorted_items = sorted(zip(unit_values, values, weights), reverse=True)

    total_value = 0
    remaining_capacity = capacity

    for unit_value, value, weight in sorted_items:
        if weight <= remaining_capacity:
            total_value += value
            remaining_capacity -= weight
        else:
            break

    return total_value, remaining_capacity

# 示例数据
values = [60, 100, 120]
weights = [10, 20, 30]
capacity = 50

# 调用函数并打印结果
print(greedy_selection(values, weights, capacity))  # 输出应为 (220, 0)

在这个例子中，我们选择单位价值最高的物品，并将其放入背包，直到背包容量不足。最终，我们得到了一个局部最优解，但可能不是全局最优解。

算法的时间复杂度分析

朴素贪心算法的时间复杂度主要取决于排序操作的时间复杂度。在大多数情况下，排序操作的时间复杂度为O(n log n)，其中n是物品的数量。排序操作完成后，每一步的选择操作的时间复杂度为O(1)。因此，整体的时间复杂度为O(n log n + n) ≈ O(n log n)。

实例代码

以下是一个简单的例子，展示了朴素贪心算法的时间复杂度分析。假设我们有一个列表，需要对其进行排序并选择最大值。

import timeit

def time_greedy_selection(values, weights, capacity):
    t = timeit.timeit('greedy_selection(values, weights, capacity)', globals=globals(), number=1000)
    return t

# 示例数据
values = [60, 100, 120]
weights = [10, 20, 30]
capacity = 50

# 调用函数并打印结果
print(time_greedy_selection(values, weights, capacity))  # 输出应为一个时间值

在这个例子中，我们使用timeit模块来测量greedy_selection函数的执行时间，以分析其时间复杂度。通过多次运行并取平均值，可以得到一个较为准确的时间复杂度估计。

朴素贪心算法的应用场景

朴素贪心算法适用于一些特定的问题，比如最小生成树问题和单源最短路径问题。在这些问题中，每一步选择局部最优解最终也能得到全局最优解。

最小生成树问题

最小生成树问题是指在一个无向图中，选择一些边，使得这些边组成的子图是一个连通图，并且总权重最小。朴素贪心算法可以通过Kruskal算法或Prim算法来求解最小生成树问题。

实例代码

以下是一个使用Kruskal算法求解最小生成树问题的示例。Kruskal算法通过排序所有边的权重，并依次选择权值最小的边，直到形成一个连通图。

from collections import defaultdict

def find(parent, i):
    if parent[i] == i:
        return i
    return find(parent, parent[i])

def union(parent, rank, x, y):
    root_x = find(parent, x)
    root_y = find(parent, y)
    if rank[root_x] < rank[root_y]:
        parent[root_x] = root_y
    elif rank[root_x] > rank[root_y]:
        parent[root_y] = root_x
    else:
        parent[root_x] = root_y
        rank[root_y] += 1

def kruskal(graph):
    result = []
    graph = sorted(graph, key=lambda item: item[2])
    parent = []
    rank = []
    for node in range(num_nodes):
        parent.append(node)
        rank.append(0)

    for edge in graph:
        u, v, w = edge
        root_u = find(parent, u)
        root_v = find(parent, v)
        if root_u != root_v:
            result.append(edge)
            union(parent, rank, root_u, root_v)

    return result

# 示例数据
graph = [(0, 1, 10), (0, 2, 6), (0, 3, 5), (1, 3, 15), (2, 3, 4)]
num_nodes = 4

# 调用函数并打印结果
print(kruskal(graph))  # 输出应为 [(0, 3, 5), (2, 3, 4), (0, 1, 10)]

在这个例子中，我们首先对所有边进行排序，然后依次选择权值最小的边，直到形成一个连通图。最终，我们得到了最小生成树。

Prim算法实例代码

以下是一个使用Prim算法求解最小生成树问题的示例。Prim算法通过维护一个集合，选择当前距离源节点距离最小的边，直到形成一个连通图。

import heapq

def prim(graph, start):
    visited = set()
    mst = []
    edges = []
    heapq.heappush(edges, (0, start))

    while edges:
        weight, node = heapq.heappop(edges)
        if node not in visited:
            visited.add(node)
            mst.append((node, weight))
            for neighbor, weight in graph[node].items():
                if neighbor not in visited:
                    heapq.heappush(edges, (weight, neighbor))

    return mst

# 示例数据
graph = {
    'A': {'B': 1, 'C': 4},
    'B': {'C': 1, 'D': 2},
    'C': {'D': 3},
    'D': {}
}
start = 'A'

# 调用函数并打印结果
print(prim(graph, start))  # 输出应为 [('A', 0), ('B', 1), ('C', 1), ('D', 2)]

在这个例子中，我们从一个起始节点开始，选择当前距离源节点距离最小的边，直到形成一个连通图。最终，我们得到了最小生成树。

单源最短路径问题

单源最短路径问题是指在一个加权有向图中，从一个指定的源节点到其他所有节点的最短路径。朴素贪心算法可以通过Dijkstra算法来求解单源最短路径问题。

实例代码

以下是一个使用Dijkstra算法求解单源最短路径问题的示例。Dijkstra算法通过维护一个优先队列，选择当前距离源节点距离最短的节点，并更新其邻居节点的距离。

import heapq

def dijkstra(graph, source):
    distances = {node: float('inf') for node in graph}
    distances[source] = 0
    priority_queue = [(0, source)]

    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)
        if current_distance > distances[current_node]:
            continue
        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))

    return distances

# 示例数据
graph = {
    'A': {'B': 1, 'C': 4},
    'B': {'C': 1, 'D': 2},
    'C': {'D': 3},
    'D': {}
}
source = 'A'

# 调用函数并打印结果
print(dijkstra(graph, source))  # 输出应为 {'A': 0, 'B': 1, 'C': 2, 'D': 4}

在这个例子中，我们使用优先队列来维护当前距离最短的节点，并依次选择这些节点，更新其邻居节点的距离。最终，我们得到了从源节点到其他所有节点的最短路径。

Bellman-Ford算法实例代码

以下是一个使用Bellman-Ford算法求解单源最短路径问题的示例。Bellman-Ford算法通过多次迭代，选择当前距离最短的节点，并更新其邻居节点的距离。

def bellman_ford(graph, source):
    distances = {node: float('inf') for node in graph}
    distances[source] = 0

    for _ in range(len(graph) - 1):
        for node in graph:
            for neighbor, weight in graph[node].items():
                if distances[node] + weight < distances[neighbor]:
                    distances[neighbor] = distances[node] + weight

    return distances

# 示例数据
graph = {
    'A': {'B': 1, 'C': 4},
    'B': {'C': 1, 'D': 2},
    'C': {'D': 3},
    'D': {}
}
source = 'A'

# 调用函数并打印结果
print(bellman_ford(graph, source))  # 输出应为 {'A': 0, 'B': 1, 'C': 2, 'D': 4}

在这个例子中，我们通过多次迭代，选择当前距离最短的节点，并更新其邻居节点的距离。最终，我们得到了从源节点到其他所有节点的最短路径。

朴素贪心算法的实现步骤

实现朴素贪心算法的关键在于选择合适的贪心策略，并设计相应的算法框架。

选择合适的贪心策略

选择合适的贪心策略是实现朴素贪心算法的第一步。贪心策略是指在每一步决策中选择当前最优解的原则。不同的问题可能有不同的贪心策略，需要根据具体问题来确定。

实例代码

以下是一个简单的例子，展示了如何选择合适的贪心策略。假设我们有一个问题，需要从一堆物品中选择一些物品放入背包，且背包有容量限制。我们选择单位价值最高的物品作为贪心策略。

def greedy_selection(values, weights, capacity):
    # 计算每个物品的单位价值
    unit_values = [v / w for v, w in zip(values, weights)]

    # 按单位价值从高到低排序
    sorted_items = sorted(zip(unit_values, values, weights), reverse=True)

    total_value = 0
    remaining_capacity = capacity

    for unit_value, value, weight in sorted_items:
        if weight <= remaining_capacity:
            total_value += value
            remaining_capacity -= weight
        else:
            break

    return total_value

# 示例数据
values = [60, 100, 120]
weights = [10, 20, 30]
capacity = 50

# 调用函数并打印结果
print(greedy_selection(values, weights, capacity))  # 输出应为 220

在这个例子中，我们选择单位价值最高的物品作为贪心策略。首先计算每个物品的单位价值，然后按照单位价值从高到低排序。接着，我们从排序后的列表中选择物品，直到背包容量不足。

设计算法框架

设计算法框架是实现朴素贪心算法的第二步。算法框架是指整个算法的结构和流程。一个好的算法框架可以提高算法的可读性和可维护性。

实例代码

以下是一个简单的例子，展示了如何设计算法框架。假设我们有一个问题，需要从一堆物品中选择一些物品放入背包，且背包有容量限制。我们设计一个通用的算法框架来解决这个问题。

def solve_knapsack(values, weights, capacity):
    # 计算每个物品的单位价值
    unit_values = [v / w for v, w in zip(values, weights)]

    # 按单位价值从高到低排序
    sorted_items = sorted(zip(unit_values, values, weights), reverse=True)

    total_value = 0
    remaining_capacity = capacity

    for unit_value, value, weight in sorted_items:
        if weight <= remaining_capacity:
            total_value += value
            remaining_capacity -= weight
        else:
            break

    return total_value

# 示例数据
values = [60, 100, 120]
weights = [10, 20, 30]
capacity = 50

# 调用函数并打印结果
print(solve_knapsack(values, weights, capacity))  # 输出应为 220

在这个例子中，我们设计了一个通用的算法框架来解决背包问题。首先计算每个物品的单位价值，然后按照单位价值从高到低排序。接着，我们从排序后的列表中选择物品，直到背包容量不足。

朴素贪心算法的案例分析

通过对实际问题的建模和算法的具体实现，可以更好地理解和应用朴素贪心算法。

实际问题的建模

实际问题的建模是指将实际问题转化为数学模型。一个好的数学模型可以帮助我们更清晰地理解问题，并设计相应的算法。

实例代码

以下是一个简单的例子，展示了如何对实际问题进行建模。假设我们有一个问题，需要从一堆物品中选择一些物品放入背包，且背包有容量限制。我们将其转化为一个数学模型，并设计相应的算法。

def solve_knapsack(values, weights, capacity):
    # 计算每个物品的单位价值
    unit_values = [v / w for v, w in zip(values, weights)]

    # 按单位价值从高到低排序
    sorted_items = sorted(zip(unit_values, values, weights), reverse=True)

    total_value = 0
    remaining_capacity = capacity

    for unit_value, value, weight in sorted_items:
        if weight <= remaining_capacity:
            total_value += value
            remaining_capacity -= weight
        else:
            break

    return total_value

# 示例数据
values = [60, 100, 120]
weights = [10, 20, 30]
capacity = 50

# 调用函数并打印结果
print(solve_knapsack(values, weights, capacity))  # 输出应为 220

在这个例子中，我们将背包问题转化为一个数学模型，并设计了一个通用的算法框架来解决这个问题。首先计算每个物品的单位价值，然后按照单位价值从高到低排序。接着，我们从排序后的列表中选择物品，直到背包容量不足。

算法的具体实现

算法的具体实现是指将算法框架转化为具体的代码实现。一个好的代码实现可以提高算法的效率和可读性。

实例代码

以下是一个简单的例子，展示了如何实现朴素贪心算法。假设我们有一个问题，需要从一堆物品中选择一些物品放入背包，且背包有容量限制。我们选择单位价值最高的物品作为贪心策略，并设计相应的算法框架。

def greedy_selection(values, weights, capacity):
    # 计算每个物品的单位价值
    unit_values = [v / w for v, w in zip(values, weights)]

    # 按单位价值从高到低排序
    sorted_items = sorted(zip(unit_values, values, weights), reverse=True)

    total_value = 0
    remaining_capacity = capacity

    for unit_value, value, weight in sorted_items:
        if weight <= remaining_capacity:
            total_value += value
            remaining_capacity -= weight
        else:
            break

    return total_value

# 示例数据
values = [60, 100, 120]
weights = [10, 20, 30]
capacity = 50

# 调用函数并打印结果
print(greedy_selection(values, weights, capacity))  # 输出应为 220

在这个例子中，我们实现了一个简单的朴素贪心算法来解决背包问题。首先计算每个物品的单位价值，然后按照单位价值从高到低排序。接着，我们从排序后的列表中选择物品，直到背包容量不足。

朴素贪心算法的优缺点总结

朴素贪心算法虽然简单直接，但也有其局限性。了解其优缺点可以更好地应用这种算法。

优点与应用范围

朴素贪心算法的优点在于其简单性和高效性。由于每一步都只考虑当前最优解，算法实现简单，且在某些特定问题中能够得到全局最优解。

实例代码

以下是一个简单的例子，展示了朴素贪心算法的优点。假设我们有一个问题，需要从一堆物品中选择一些物品放入背包，且背包有容量限制。我们选择单位价值最高的物品作为贪心策略，并设计相应的算法框架。

def solve_knapsack(values, weights, capacity):
    # 计算每个物品的单位价值
    unit_values = [v / w for v, w in zip(values, weights)]

    # 按单位价值从高到低排序
    sorted_items = sorted(zip(unit_values, values, weights), reverse=True)

    total_value = 0
    remaining_capacity = capacity

    for unit_value, value, weight in sorted_items:
        if weight <= remaining_capacity:
            total_value += value
            remaining_capacity -= weight
        else:
            break

    return total_value

# 示例数据
values = [60, 100, 120]
weights = [10, 20, 30]
capacity = 50

# 调用函数并打印结果
print(solve_knapsack(values, weights, capacity))  # 输出应为 220

在这个例子中，我们使用朴素贪心算法解决了背包问题。首先计算每个物品的单位价值，然后按照单位价值从高到低排序。接着，我们从排序后的列表中选择物品，直到背包容量不足。这种算法简单且高效，适用于解决类似问题。

缺点及局限性

朴素贪心算法的缺点在于可能无法得到全局最优解。由于每一步只考虑当前最优解，可能错过全局最优解。因此，在某些问题中，朴素贪心算法可能不是最优选择。

实例代码

以下是一个简单的例子，展示了朴素贪心算法的局限性。假设我们有一个问题，需要从一堆物品中选择一些物品放入背包，且背包有容量限制。我们选择单位价值最高的物品作为贪心策略，并设计相应的算法框架。

def solve_knapsack(values, weights, capacity):
    # 计算每个物品的单位价值
    unit_values = [v / w for v, w in zip(values, weights)]

    # 按单位价值从高到低排序
    sorted_items = sorted(zip(unit_values, values, weights), reverse=True)

    total_value = 0
    remaining_capacity = capacity

    for unit_value, value, weight in sorted_items:
        if weight <= remaining_capacity:
            total_value += value
            remaining_capacity -= weight
        else:
            break

    return total_value

# 示例数据
values = [60, 100, 120]
weights = [10, 20, 30]
capacity = 50

# 调用函数并打印结果
print(solve_knapsack(values, weights, capacity))  # 输出应为 220

在这个例子中，我们使用朴素贪心算法解决了背包问题。虽然算法简单且高效，但可能无法得到全局最优解。因此，在某些问题中，需要考虑其他算法来解决。

点击查看更多内容
发表于 2024.09.24 10:31， 共 81 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

作者其他优质文章

正在加载中

蝴蝶不菲

手记
篇
粉丝
81
获赞与收藏
384

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
微信客服

购课补贴
联系客服咨询优惠详情

 帮助反馈 APP下载

慕课网APP
您的移动学习伙伴

 公众号

扫描二维码
关注慕课网微信公众号

举报

0/150
提交
取消