CCF-CSP 201609-4-交通规划 (Python) 最小堆优先队列 Dijstr 最短路径变形满分实现-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_63894862/article/details/141203676

201609-4-交通规划

问题

思路

求组成最短路径的边的长度总和，

⚠️：使用了最小堆做优先队列的，==Dijstra(迪杰斯特拉)==求解最短路径问题，组成最短路径的边的长度总和即为要改造的铁路长度

利用一个最小堆来维护所有从当前路径的距离，当前路径的终点城市，当前路径的最后一条边的长度，每次从堆中取出一条最小当前路径的距离并更新访问节点集合，直到所有节点都被访问或者堆为空为止。

⚠️：和传统的Dijstra有点不一样点

传统Dijstra是求出其它点到起点最小的距离即可
这里还需要判断到统一节点两种相等路径的取舍，使得总的最小，实际上是用变型的Dijstra来求满足到起点最短路径情况下的“最小生成树”

实现

1、传统Dijstra：到起点最小的距离放入优先队列

`ln + min_list[dst] < min_list[dn]`

from collections import defaultdict
from heapq import heapify, heappush, heappop

n, m = map(int, input().split()) # 城市数量n，城市间铁路数量m    [1,n]

road_dict = defaultdict(list) # 城市间铁路字典 {出发城市:[(距离,终点城市),]}
for _ in range(m):
  a, b, c = map(int, input().split()) # 城市a，城市b，长度c
  road_dict[a].append((c, b))
  road_dict[b].append((c, a))

in_set = set() # 已确定最短路径的城市
pre_list = [0, 1] + [-1 for _ in range(n-1)] # 城市最近前城市 [1,n]
min_list = [0, 0] + [1001 for _ in range(n-1)] # 最短距离   [1,n]
s_length = 0 # 最少改造铁路的长度
heap = [(0,1,0)] # [(当前路径长度，当前路径终点, 当前路径最后一条边的长度)]
heapify(heap)

while len(heap)!=0 and len(in_set) < n:
  dis, dst, leg = heappop(heap) # 最小的  当前路径长度，当前路径终点
  if dst not in in_set:
    in_set.add(dst)
    # print('加入'+str(dst))
    s_length += leg
    for ln, dn in road_dict[dst]: # 下一路径的距离，终点
      # print(road_dict[dst])
      if dn not in in_set and ln + min_list[dst] < min_list[dn] :
        pre_list[dn] = dst
        min_list[dn] = ln + min_list[dst]
        heappush(heap, (min_list[dn], dn, ln))
# print(pre_list, min_list)
print(s_length)

2、传统Dijstra：到起点最小的距离放入优先队列

就实现1上，把=号改为了<=，ln + min_list[dst] <= min_list[dn]

from collections import defaultdict
from heapq import heapify, heappush, heappop

n, m = map(int, input().split()) # 城市数量n，城市间铁路数量m    [1,n]

road_dict = defaultdict(list) # 城市间铁路字典 {出发城市:[(距离,终点城市),]}
for _ in range(m):
  a, b, c = map(int, input().split()) # 城市a，城市b，长度c
  road_dict[a].append((c, b))
  road_dict[b].append((c, a))

in_set = set() # 已确定最短路径的城市
pre_list = [0, 1] + [-1 for _ in range(n-1)] # 城市最近前城市 [1,n]
min_list = [0, 0] + [1001 for _ in range(n-1)] # 最短距离   [1,n]
s_length = 0 # 最少改造铁路的长度
heap = [(0,1,0)] # [(当前路径长度，当前路径终点, 当前路径最后一条边的长度)]
heapify(heap)

while len(heap)!=0 and len(in_set) < n:
  dis, dst, leg = heappop(heap) # 最小的  当前路径长度，当前路径终点
  if dst not in in_set:
    in_set.add(dst)
    # print('加入'+str(dst))
    s_length += leg
    for ln, dn in road_dict[dst]: # 下一路径的距离，终点
      # print(road_dict[dst])
      if dn not in in_set and ln + min_list[dst] <= min_list[dn] :
        pre_list[dn] = dst
        min_list[dn] = ln + min_list[dst]
        heappush(heap, (min_list[dn], dn, ln))
# print(pre_list, min_list)
print(s_length)

下一步的优化思路为，两个一样，选择当前路径最后一条边值小的

3、把（当前路径长度+下一路径的距离）放入优先队列

不在被传统Dijstra限制（到起点距离的最小），而是把（当前路径长度+下一路径的距离）加入优先队列

from heapq import heapify, heappop, heappush
from collections import defaultdict


with open('case.txt','r') as file: 
    n, m = map(int, file.readline().split()) # 城市数量n [0,n-1]，城市间铁路数量m    
    road_set = defaultdict(list) # 城市间铁路字典 {出发城市:[(距离,终点城市),]}
    all_length = 0 # 最少改造铁路的长度
    for i in range(m):
        src, dst, length = map(int, file.readline().split())  # 城市a，城市b，长度c
        road_set[src - 1].append((length, dst - 1))
        road_set[dst - 1].append((length, src - 1))

in_set = {0} # 已确定最短路径的城市
heap = [(item + (item[0],)) for item in road_set[0]] # [(到起点，dst城市，距离),]
heapify(heap)

while len(in_set) < n and len(heap) != 0:
    dis, dst, length = heappop(heap)
    if dst not in in_set: 
        in_set.add(dst)
        all_length += length
        for ln, dt in road_set[dst]:
            if dt not in in_set:
                heappush(heap, (dis + ln, dt, ln))

print(all_length)