用宽度优先搜索算法或深度优先搜索算法编程，求出V1至V5的最短路径，输出路线和距离。

 代码：

import math

import heapq

# 创建一个类

class Graph:

    def __init__(self):

        self.adj = {}

    def add_edge(self, u, v):

        if self.adj[u] is None:

            self.adj[u] = []

        self.adj[u].append(v)

class BFSResult:

    def __init__(self):

        self.level = {}

        self.parent = {}

# 宽度优先搜索

def bfs(g, s):

    r = BFSResult()

    r.parent = {s: None}

    r.level = {s: 0}

    i = 1

    frontier = [s]

    while frontier:

        next = []

        for u in frontier:

            for v in g.adj[u]:

                if v not in r.level:

                    r.level[v] = i

                    r.parent[v] = u

                    next.append(v)

        frontier = next

        i += 1

    return r

# 求最短路径

def find_shortest_path(bfs_result, v):  # bfs_result :BFS的结果，v:需要确定最短路径的结点

    source_vertex = [verterx for verterx, level in bfs_result.level.items() if level == 0]

    v_parent_list = []

    if v != source_vertex[0]:

        v_parent = bfs_result.parent[v]

        v_parent_list.append(v_parent)

        # 求v结点的父结点的父结点，直到源结点。

        while v_parent != source_vertex[0] and v_parent != None:

            # 记录经过的各个结点 V_parent.

            v_parent = bfs_result.parent[v_parent]

            v_parent_list.append(v_parent)

    return v_parent_list

def init_value(graph, s):

    value = {s: 0}

    for vertex in graph:

        if vertex != s:

            value[vertex] = math.inf

    return value

#计算权值

def Bfs(graph, x):

    bfs_list = []

    #(0, x)元素增加到bfs_list定义堆中

    heapq.heappush(bfs_list, (0, x))

    seen = set()

    parent = {x: None}

    value = init_value(graph, x)

    while (len(bfs_list) > 0):

        #删除并返回最小值，因为堆的特征是heap[0]永远是最小的元素，所以一般都是删除第一个元素。

        pair = heapq.heappop(bfs_list)

        dist = pair[0]

        vertex = pair[1]

        seen.add(vertex)

        nodes = graph[vertex].keys()

        for w in nodes:

            if w not in seen:

                if dist + graph[vertex][w] < value[w]:

                    heapq.heappush(bfs_list, (dist + graph[vertex][w], w))

                    parent[w] = vertex

                    value[w] = dist + graph[vertex][w]

    return value

if __name__ == "__main__":

    g = Graph()

    g.adj= {

        "v1": {"v2": 5},

        "v2": {"v1": 5, "v3": 50,"v6": 10 },

        "v3": {"v2": 50, "v4": 20, "v5": 10},

        "v4": {"v3": 20, "v5": 60,"v6": 30 },

        "v5": {"v6": 100, "v4": 60},

        "v6": {"v2": 10, "v4": 30, "v5": 100}

        }

    bfs_result = bfs(g,'v1')

    print("V1至V5的最短路径路线：",find_shortest_path(bfs_result,'v5'))

    p= Bfs(g.adj, "v1")

print("V1至V5最短路径的距离：",p['v5'])

结果