• 最小生成树 | 市政道路拓宽预算的优化 (Minimum Spanning Tree)

    任务描述：

    市政投资拓宽市区道路，本着执政为民，节省纳税人钱的目的，论证是否有必要对每一条路都施工拓宽？

    这是一个连问带答的好问题。项目制学习可以上下半场，上半场头脑风暴节省投资的所有可行的思路；

    下半场总结可行的思路，归为算法问题解决。

    思路

    MST = Minimum Spanning Tree 最小生成树

    1、选择每一个节点的最短边，加入树Tree，涂成颜色标记如下：

    2、同时避免形成环路,

    3、遍历所有的节点，循环执行以上步骤直至所有节点都在MST中；

    使用Kruskal算法求解最小生成树(Minimum Spanning Tree)的Python代码实现

    #上述代码利用Kruskal算法的贪心思想, 每次选择权值最小的边加入MST, 同时避免形成环路,

    #直到遍历完所有节点, 得到最小生成树的所有边。

    Kruskal算法和Prim算法都是解决最小生成树（Minimum Spanning Tree，MST）问题的常用算法，但它们的工作原理和实现方式略有不同。以下是它们之间的主要区别：

    1. 工作原理：

      • Kruskal算法：Kruskal算法基于贪心策略。它首先将所有的边按权重升序排列，然后从最小权重的边开始，逐渐构建最小生成树。在构建的过程中，Kruskal算法不断选择下一条最小权重的边，但要确保选择的边不会形成环路。它使用了一个并查集（Disjoint Set）数据结构来判断边是否会形成环路。

      • Prim算法：Prim算法也是一种贪心算法，但它从一个初始顶点开始，逐步添加顶点到最小生成树中。它每次选择一个与当前最小生成树相邻的顶点，并选择连接它们的边中权重最小的那条边。这个过程一直进行，直到所有顶点都包含在最小生成树中为止。

    2. 起始点：

      • Kruskal算法：Kruskal算法不需要指定一个起始点，它从边集合出发，根据权重来构建最小生成树。

      • Prim算法：Prim算法需要指定一个起始点，它从指定的起始点开始构建最小生成树。

    3. 数据结构：

      • Kruskal算法：Kruskal算法主要依赖于边的排序和并查集数据结构，用于检测环路。

      • Prim算法：Prim算法通常使用优先队列（Priority Queue）来管理候选边和顶点，以及一个数组来维护顶点的键（键表示连接到最小生成树的最小边的权重）。

    4. 适用情况：

      • Kruskal算法：Kruskal算法适用于稀疏图，即边相对较少的情况。它不受起始点选择的限制，因此在不同起始点下可能会得到相同的最小生成树。

      • Prim算法：Prim算法适用于稠密图，即边相对较多的情况。它的最终结果可能受起始点选择的影响，因为不同的起始点可能会导致不同的最小生成树。

    总的来说，Kruskal算法和Prim算法都是有效的最小生成树算法，选择哪个算法取决于具体的问题和图的性质。在实际应用中，可以根据图的密度和其他要求来选择适当的算法。

    1. import sys
    2. class Graph:
    3.     def __init__(self):
    4.         self.graph = {}
    5.  
    6.     def add_edge(self, u, v, w):
    7.         if u not in self.graph:
    8.             self.graph[u] = {}
    9.         if v not in self.graph:
    10.             self.graph[v] = {}
    11.         self.graph[u][v] = w
    12.         self.graph[v][u] = w
    13.  
    14.     def prim(self):
    15.         key = {}
    16.         parent = {}
    17.         mst_set = set()
    18.  
    19.         # 初始化key值为无穷大
    20.         for vertex in self.graph:
    21.             key[vertex] = sys.maxsize
    22.         # 从起始顶点开始
    23.         start_vertex = list(self.graph.keys())[0]
    24.         key[start_vertex] = 0
    25.         parent[start_vertex] = None
    26.  
    27.         while mst_set != set(self.graph.keys()):
    28.             # 找到key值最小的未加入MST的顶点
    29.             min_vertex = None
    30.             for vertex in self.graph:
    31.                 if vertex not in mst_set and (min_vertex is None or key[vertex] < key[min_vertex]):
    32.                     min_vertex = vertex
    33.  
    34.             mst_set.add(min_vertex)
    35.  
    36.             # 更新与min_vertex相邻的顶点的key值和parent
    37.             for neighbor, weight in self.graph[min_vertex].items():
    38.                 if neighbor not in mst_set and weight < key[neighbor]:
    39.                     key[neighbor] = weight
    40.                     parent[neighbor] = min_vertex
    41.  
    42.         # 构建最小生成树的边列表
    43.         mst_edges = []
    44.         for vertex, p in parent.items():
    45.             if p is not None:
    46.                 mst_edges.append((p, vertex, key[vertex]))
    47.  
    48.         return mst_edges
    创建图并添加边
    1. g = Graph()
    2. g.add_edge("A", "B", 10)
    3. g.add_edge("A", "H", 11)
    4. g.add_edge("A", "G", 14)
    5. g.add_edge("B", "H", 12)
    6. g.add_edge("B", "C", 16)
    7. g.add_edge("C", "D", 15)
    8. g.add_edge("D", "K", 13)
    9. g.add_edge("D", "E", 14)
    10. g.add_edge("E", "K", 13)
    11. g.add_edge("E", "F", 17)
    12. g.add_edge("F", "H", 17)
    13. g.add_edge("F", "G", 16)
    14. g.add_edge("G", "H", 13)
    15. g.add_edge("H", "K", 15)
    计算最小生成树
    1. mst = g.prim()
    2.  
    3. # 打印最小生成树的边和权重
    4. s = 0
    5. for u, v, w in mst:
    6.     s += w
    7.     print(f"{u} - {v}: {w}")
    8. print('total = ',s)
    9.  
    10. A - B: 10
    11. A - H: 11
    12. H - G: 13
    13. D - C: 15
    14. G - F: 16
    15. H - K: 15
    16. K - D: 13
    17. K - E: 13
    18.  
    19. total =  106

    根据图的疏密程度选择合适的最小生成树算法是一个重要的考虑因素。下面是对于不同的图疏密程度如何选择算法的一些建议：

    1. 稀疏图（Sparse Graph）：

      • Kruskal算法：对于稀疏图，通常边的数量相对较少，这使得Kruskal算法的效率较高。因为Kruskal算法不依赖于起始点，适合用于连接各个部分的边比较少的情况。如果图是非连通的，Kruskal算法也可以应对。

      • Prim算法：虽然Prim算法也可以用于稀疏图，但在这种情况下，通常Kruskal算法更具优势，因为它的时间复杂度相对较低。

    2. 稠密图（Dense Graph）：

      • Prim算法：稠密图通常包含大量的边，此时Prim算法更适合，因为它在连接到当前最小生成树的顶点之间选择边的效率更高。Prim算法的时间复杂度在稠密图中通常比Kruskal算法更低。

    3. 图的连通性：

      • Kruskal算法：如果图是非连通的，Kruskal算法可以构建最小生成森林，而不需要将图变为连通的。这在一些应用中可能很有用。

    4. 起始点选择：

      • Kruskal算法：Kruskal算法不受起始点选择的限制，因此在不同的起始点下可能会得到相同的最小生成树。这对于某些问题可能是一个优点。

      • Prim算法：Prim算法需要指定一个起始点，因此选择起始点可能会影响最终的最小生成树结果。在某些情况下，选择不同的起始点可能导致不同的最小生成树。

    总的来说，根据图的疏密程度、连通性和起始点选择的灵活性来选择最小生成树算法。通常，如果图较稀疏，可以优先考虑Kruskal算法，如果图较稠密，可以优先考虑Prim算法。然而，具体的应用可能需要根据问题的特点进行权衡和选择。

    同学对算法缺乏兴趣或没有时间研究的，最好的选择，也是Python的优势所在，直接导入第三方库。

    额外的福利是收获直观可见的无向图，顺便学习一点可视化。

    1. import networkx as nx
    2. import matplotlib.pyplot as plt
    3.  
    4. #1 创建一个空的无向图
    5. G = nx.Graph()
    6.  
    7. #2 添加节点
    8. G.add_node("A")
    9. G.add_node("B")
    10. G.add_node("C")
    11. G.add_node("D")
    12. G.add_node("E")    
    13. G.add_node("F")
    14. G.add_node("G")
    15. G.add_node("H")
    16. G.add_node("K")
    17.  
    18. #根据需求添加边两端连接节点
    19.  
    20. #3 添加边（连接节点）
    21. G.add_edge("A", "B", weight=10)
    22. G.add_edge("A", "H", weight=11)
    23. G.add_edge("A", "G", weight=14)
    24. G.add_edge("B", "H", weight=12)
    25. G.add_edge("B", "C", weight=16)
    26. G.add_edge("C", "D", weight=15)
    27. G.add_edge("D", "K", weight=13)
    28. G.add_edge("D", "E", weight=14)
    29. G.add_edge("E", "K", weight=13)
    30. G.add_edge("E", "F", weight=17)
    31. G.add_edge("F", "H", weight=17)
    32. G.add_edge("F", "G", weight=16)
    33. G.add_edge("G", "H", weight=13)
    34. G.add_edge("H", "K", weight=15)
    35.  
    36. # 绘制图形
    37. pos = nx.spring_layout(G)
    38. nx.draw(G, pos, with_labels=True, node_size=700, node_color='skyblue', font_size=10, font_color='black')
    39. labels = nx.get_edge_attributes(G, 'weight')
    40. nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)
    41.  
    42. # 查找最小生成树
    43. minimum_spanning_tree = nx.minimum_spanning_tree(G)
    44. print("Minimum Spanning Tree Edges:")
    45. s = 0
    46. for edge in minimum_spanning_tree.edges(data=True):
    47.     s += edge[2]['weight']
    48.     print(edge)
    49.  
    50.  
    51. # 查找节点之间的最短路径
    52. shortest_path = nx.shortest_path(G, source="A", target="D", weight="weight")
    53. print("Shortest Path from A to D:", shortest_path)
    54.  
    55. # 计算最短路径长度
    56. shortest_path_length = nx.shortest_path_length(G, source="A", target="D", weight="weight")
    57. print("Shortest Path Length from A to D:", shortest_path_length)
    58.  
    59.  
    60. # 查找节点之间的最短路径
    61. shortest_path = nx.shortest_path(G, source="H", target="K", weight="weight")
    62. print("Shortest Path from H to K:", shortest_path)
    63.  
    64. # 计算最短路径长度
    65. shortest_path_length = nx.shortest_path_length(G, source="H", target="K", weight="weight")
    66. print("Shortest Path Length from H to K:", shortest_path_length)
    67.  
    68. # Total length of Minimum Spanning Tree Edges
    69.  
    70. print(''' totals ''')
    71. print(minimum_spanning_tree) #Graph with 9 nodes and 8 edges
    72. print([edge for edge in minimum_spanning_tree])
    73. print('total length = ',s)
    74.  
    75.  
    76. # 显示图形
    77. plt.show()

    输出结果：

    1. Minimum Spanning Tree Edges:
    2. ('A', 'B', {'weight': 10})
    3. ('A', 'H', {'weight': 11})
    4. ('C', 'D', {'weight': 15})
    5. ('D', 'K', {'weight': 13})
    6. ('E', 'K', {'weight': 13})
    7. ('F', 'G', {'weight': 16})
    8. ('G', 'H', {'weight': 13})
    9. ('H', 'K', {'weight': 15})
    10.  
    11.  
    12. Shortest Path from A to D: ['A', 'H', 'K', 'D']
    13. Shortest Path Length from A to D: 39
    14. Shortest Path from H to K: ['H', 'K']
    15. Shortest Path Length from H to K: 15
    16.  totals 
    17. Graph with 9 nodes and 8 edges
    18. ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'K']
    19. total length =  106

    与原题的图等价。

    最小生成树为：

    ('A', 'B', {'weight': 10})

    ('A', 'H', {'weight': 11})

    ('C', 'D', {'weight': 15})

    ('D', 'K', {'weight': 13})

    ('E', 'K', {'weight': 13})

    ('F', 'G', {'weight': 16})

    ('G', 'H', {'weight': 13})

    ('H', 'K', {'weight': 15})

  • 相关阅读:
    Go语言：基础练习–查找 substring 的函数
    elementUI el-collapse 自定义折叠面板icon 和 样式 或文字展开收起
    Tomcat原理剖析-Tomcat整体架构设计
    自己写了一个简易的android transformation.map
    python+django+vue某小区物业管理系统
    Notexpress 从另一个文档粘贴过来引文出错的问题
    【解题思路】二叉搜索树类问题
    8.（Python数模）（预测模型一）马尔科夫链预测
    vue项目不用重新打包即可以修改项目ip
    C语言进阶:结构体，枚举，联合(结尾有彩蛋)
  • 原文地址：https://blog.csdn.net/qq_40523298/article/details/133420772