蓝桥杯备战资料从0开始！！！（python B组）（最全面！最贴心！适合小白！蓝桥云课）图论

注：你的关注，点赞，评论让我不停更新

一、蓝桥杯图论常见题型

1. 最短路径问题

   • 单源最短路径（Dijkstra 算法）

   • 多源最短路径（Floyd-Warshall 算法）

   • 带有负权边的最短路径（Bellman-Ford 算法）

2. 最小生成树（MST）

   • Kruskal 算法（并查集 + 贪心）

   • Prim 算法（优先队列优化）

3. 遍历与连通性

   • DFS/BFS 求连通块

   • 强连通分量（Tarjan 算法）

4. 网络流与匹配

   • 二分图匹配（匈牙利算法）

   • 最大流问题（Dinic 算法）

5. 动态规划与图的结合

   • 状态压缩 DP 在网格图中的应用

二、核心算法与实现技巧

1. 最短路径算法

• Dijkstra 算法 适用场景：无负权边的单源最短路径。 实现步骤：

  import heapq
  ​
  def dijkstra(n, adj, start):
      dist = [float('inf')] * (n+1)
      dist[start] = 0
      heap = [(0, start)]
      visited = [False] * (n+1)
      
      while heap:
          d, u = heapq.heappop(heap)
          if visited[u]:
              continue
          visited[u] = True
          for v, w in adj[u]:
              if dist[v] > d + w:
                  dist[v] = d + w
                  heapq.heappush(heap, (dist[v], v))
      return dist

  优化点：使用优先队列（堆）优化时间复杂度至 O (M log N)。

• Floyd-Warshall 算法 适用场景：多源最短路径，O (N³) 时间复杂度。 代码示例：

  def floyd(n, graph):
      dist = [[float('inf')]*(n+1) for _ in range(n+1)]
      for i in range(n+1):
          dist[i][i] = 0
      for i in range(1, n+1):
          for j in range(1, n+1):
              if graph[i][j] != 0:
                  dist[i][j] = graph[i][j]
      for k in range(1, n+1):
          for i in range(1, n+1):
              for j in range(1, n+1):
                  if dist[i][k] + dist[k][j] < dist[i][j]:
                      dist[i][j] = dist[i][k] + dist[k][j]
      return dist

2. 最小生成树

• Kruskal 算法

  核心思想：按边权排序，用并查集合并节点。

  def kruskal(n, edges):
      edges.sort(key=lambda x: x[2])
      parent = list(range(n+1))
      
      def find(u):
          while parent[u] != u:
              parent[u] = parent[parent[u]]
              u = parent[u]
          return u
      
      mst = []
      total = 0
      for u, v, w in edges:
          root_u = find(u)
          root_v = find(v)
          if root_u != root_v:
              mst.append((u, v, w))
              total += w
              parent[root_v] = root_u
      return total

3. DFS/BFS 遍历

• DFS：适合递归或栈实现，常用于路径记录。

• BFS

  ：适合队列实现，常用于最短路径问题。

  迷宫问题示例

  from collections import deque
  ​
  def bfs(maze, start, end):
      rows, cols = len(maze), len(maze[0])
      dirs = [(-1,0), (1,0), (0,-1), (0,1)]
      visited = [[False]*cols for _ in range(rows)]
      q = deque([(start[0], start[1], 0)])
      visited[start[0]][start[1]] = True
      
      while q:
          x, y, step = q.popleft()
          if (x, y) == end:
              return step
          for dx, dy in dirs:
              nx, ny = x+dx, y+dy
              if 0<=nx 

三、典型例题与思路

1. 例题 1：迷宫的最短路径 题目描述：给定一个 N×M 的迷宫，求起点到终点的最短路径长度。 思路：将迷宫建模为图，每个格子是节点，相邻格子有边。使用 BFS 求解。

2. 例题 2：城市交通建设 题目描述：给定城市间道路的修建成本，求连接所有城市的最小总费用。 思路：最小生成树问题，用 Kruskal 或 Prim 算法。

3. 例题 3：通讯网络 题目描述：给定通信基站的连接关系，判断是否存在两个基站间的多条路径（强连通分量）。 思路：Tarjan 算法求强连通分量。

四、注意事项

1. 图的存储方式：

   • 邻接表（适合稀疏图）：用字典或列表存储。

   • 邻接矩阵（适合稠密图）：用二维数组。

2. 时间复杂度优化：

   • 对于大规模数据，优先选择 O (M log N) 的算法（如 Dijkstra 堆优化）。

3. 边界条件处理：

   • 节点编号是否从 0 或 1 开始？图是否连通？是否存在负权边？

4. Python 性能问题：

   • 递归深度限制（改用非递归 DFS）。

   • 优先队列（heapq）在 Python 中的效率可能较低，可尝试优化。

通过以上方法，结合蓝桥杯的具体题目，图论问题可以迎刃而解。建议多练习历年真题，熟悉常见模型！