GREEDY HIGH-FREQUENCY PROBLEMS: MASTERING GREEDY ALGORITHM TECHNIQUES

后端

2022-11-02 23:42:46

贪心算法：优化问题的利器

在竞争激烈的编程领域，快速有效地解决算法问题至关重要。贪心算法作为一种多才多艺的工具脱颖而出，为优化问题提供了一种直接而有力的方法。在这篇博文中，我们将探索贪心算法的奥秘，并为你提供必要的技能，让你能够自信地解决一系列高频问题。

破解贪心算法的本质

贪心算法的核心原理是，在每一步都做出局部最优选择，相信这些渐进决策最终将导致全局最优解。这种方法虽然不能保证在所有情况下都能得到最优解，但对于各种问题却往往能产生令人满意的结果。

征服经典贪心问题：分步指南

为了加深你对贪心算法的理解，让我们深入研究一系列在竞赛编程挑战中经常出现的经典问题：

1. 活动选择问题： 给你一组具有开始时间和结束时间的活动，确定可以安排的最大非重叠活动数。

代码示例：

def activity_selection(activities):
  activities.sort(key=lambda x: x[1])
  selected_activities = [activities[0]]
  last_activity_end_time = activities[0][1]

  for activity in activities[1:]:
    if activity[0] >= last_activity_end_time:
      selected_activities.append(activity)
      last_activity_end_time = activity[1]

  return selected_activities

2. 分数背包问题： 给你一个容量有限的背包和一堆不同重量和价值的物品。目标是用最宝贵的物品填满背包，而不超过其容量。

代码示例：

def fractional_knapsack(items, capacity):
  items.sort(key=lambda x: x[1] / x[0], reverse=True)
  total_value = 0
  current_weight = 0

  for item in items:
    if current_weight + item[0] <= capacity:
      total_value += item[1]
      current_weight += item[0]
    else:
      remaining_capacity = capacity - current_weight
      total_value += remaining_capacity * (item[1] / item[0])
      break

  return total_value

3. Dijkstra 算法： 给定一个加权图，找到从一个起始顶点到图中所有其他顶点的最短路径。

代码示例：

def dijkstra(graph, source):
  distance = {vertex: float('inf') for vertex in graph}
  distance[source] = 0
  pq = [(0, source)]

  while pq:
    current_distance, current_vertex = heapq.heappop(pq)

    for neighbor, weight in graph[current_vertex].items():
      distance_to_neighbor = current_distance + weight

      if distance_to_neighbor < distance[neighbor]:
        distance[neighbor] = distance_to_neighbor
        heapq.heappush(pq, (distance_to_neighbor, neighbor))

  return distance

4. Prim 算法： 与 Dijkstra 算法类似，Prim 算法为给定的加权图构造一棵最小生成树，确保所有顶点都以最小的总边权相连。

代码示例：

def prim(graph):
  mst = {}
  visited = {vertex: False for vertex in graph}
  visited[next(iter(graph))] = True

  while not all(visited.values()):
    min_weight = float('inf')
    min_edge = None

    for vertex in visited:
      for neighbor, weight in graph[vertex].items():
        if not visited[neighbor] and weight < min_weight:
          min_weight = weight
          min_edge = (vertex, neighbor)

    mst[min_edge[0]].append(min_edge[1])
    mst[min_edge[1]].append(min_edge[0])
    visited[min_edge[1]] = True

  return mst

5. 哈夫曼编码： 该算法通过为更频繁出现的字符分配更短的代码来压缩数据，从而产生数据的紧凑表示。

代码示例：

def huffman_coding(data):
  frequency = {}

  for char in data:
    if char in frequency:
      frequency[char] += 1
    else:
      frequency[char] = 1

  heap = [(frequency[char], char) for char in frequency]
  heapq.heapify(heap)

  while len(heap) > 1:
    char1, frequency1 = heapq.heappop(heap)
    char2, frequency2 = heapq.heappop(heap)

    new_char = (char1, char2)
    new_frequency = frequency1 + frequency2
    heapq.heappush(heap, (new_frequency, new_char))

  huffman_code = {}

  def generate_code(node, code):
    if type(node) == str:
      huffman_code[node] = code
    else:
      generate_code(node[0], code + '0')
      generate_code(node[1], code + '1')

  generate_code(heap[0][1], '')

  return huffman_code