1.实验目的：加深图的汉密尔顿路及最短路径的理解与应用 2.实验内容：搜索某旅游城市地图（至少包含6个景点），随机选取出发地点，基于图论理论建立模型，给出合理的旅行路线。要求考虑时间、成本等因素。 3.实验原理和方法： （1）不多于3名同学一组，选择某一旅游城市为研究对象，考察该城市至少6个景点在地图中的位置，根据景点间的路径绘制路线图。 （2）考虑两个景点间的距离、交通工具等因素，设置路线权重。 （3）随机从任意一点出发，基于图论理论建立模型，给出合理的旅行路线。 我有六个景点和其距离的矩阵,用最短路径怎么求解,给出代码

这个问题涉及到图论算法中的最短路径问题，可以使用 Dijkstra 算法或者 Floyd 算法来解决。下面给出两种算法的实现代码。

使用 Dijkstra 算法实现：

import heapq

def dijkstra(graph, start):
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    pq = [(0, start)]
    while pq:
        current_distance, current_node = heapq.heappop(pq)
        if current_distance > distances[current_node]:
            continue
        for neighbor, neighbor_distance in graph[current_node].items():
            distance = current_distance + neighbor_distance
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(pq, (distance, neighbor))
    return distances

# 例如，有6个城市节点，距离矩阵为：
#       A  B  C  D  E  F
#   A   0  2  4  1  0  0
#   B   2  0  0  5  0  0
#   C   4  0  0  8  0  0
#   D   1  5  8  0  3  2
#   E   0  0  0  3  0  4
#   F   0  0  0  2  4  0
# 表示城市 A 到城市 B 的距离为 2，城市 C 到城市 D 的距离为 8，以此类推

graph = {
    'A': {'B': 2, 'C': 4, 'D': 1},
    'B': {'A': 2, 'D': 5},
    'C': {'A': 4, 'D': 8},
    'D': {'A': 1, 'B': 5, 'C': 8, 'E': 3, 'F': 2},
    'E': {'D': 3, 'F': 4},
    'F': {'D': 2, 'E': 4}
}

start = 'A'
distances = dijkstra(graph, start)
print(distances)

使用 Floyd 算法实现：

def floyd(graph):
    n = len(graph)
    distances = [[float('inf')]*n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            if i == j:
                distances[i][j] = 0
            elif graph[i][j] != 0:
                distances[i][j] = graph[i][j]
    for k in range(n):
        for i in range(n):
            for j in range(n):
                distances[i][j] = min(distances[i][j], distances[i][k] + distances[k][j])
    return distances

# 例如，有6个城市节点，距离矩阵为：
#       A  B  C  D  E  F
#   A   0  2  4  1  0  0
#   B   2  0  0  5  0  0
#   C   4  0  0  8  0  0
#   D   1  5  8  0  3  2
#   E   0  0  0  3  0  4
#   F   0  0  0  2  4  0
# 表示城市 A 到城市 B 的距离为 2，城市 C 到城市 D 的距离为 8，以此类推

graph = [
    [0, 2, 4, 1, 0, 0],
    [2, 0, 0, 5, 0, 0],
    [4, 0, 0, 8, 0, 0],
    [1, 5, 8, 0, 3, 2],
    [0, 0, 0, 3, 0, 4],
    [0, 0, 0, 2, 4, 0]
]

distances = floyd(graph)
print(distances)

以上两种算法都能够求出任意两点之间的最短路径长度。如果需要输出具体的路径，可以在算法中加入一些额外的代码来保存路径信息。