假期你从徐州出发去旅行，目的地城市有n个，（1）请设计并实现确定到各目的地最短路径的算法，（2）请设计并实现一个算法，算法能计算一条走遍n个目的地的最短路径。

(1) 要设计一个确定从徐州市出发到各个目的地最短路径的算法，我们可以考虑使用经典的图论算法——Dijkstra算法或A*搜索算法。这里我选择Dijkstra算法，因为它适用于所有非负权重的边，并且能够保证找到两点之间的最短路径。

import heapq

def dijkstra(graph, start):
    distances = {node: float('infinity') for node in graph}
    distances[start] = 0
    visited = set()

    pq = [(0, start)]
    while pq:
        current_distance, current_node = heapq.heappop(pq)
        
        if current_node not in visited:
            visited.add(current_node)

            for neighbor, weight in graph[current_node].items():
                distance = current_distance + weight
                if distance < distances[neighbor]:
                    distances[neighbor] = distance
                    heapq.heappush(pq, (distance, neighbor))

    return distances

# 假设graph是一个字典，键是节点，值是邻接字典，表示到每个邻居的距离
# 示例：graph = {
#     'Xuzhou': {'Destination1': 50, 'Destination2': 70},
#     'Destination1': {},
#     'Destination2': {}
# }

(2) 计算一条走遍n个目的地的最短路径，这通常涉及到寻找哈密尔顿路径问题，这是一个NP完全问题，对于大规模的图不容易找到最优解。一个可行的启发式算法是近似算法，比如贪心策略结合回溯法。但是请注意，这种方法并不能保证找到全局最优解，只能得到一种相对接近的答案。

def nearest_neighbor(graph, start, destinations):
    path = [start]
    remaining_destinations = set(destinations)

    while remaining_destinations:
        closest_destination = None
        min_distance = float('inf')

        for dest in remaining_destinations:
            if graph[start][dest] < min_distance:
                closest_destination = dest
                min_distance = graph[start][dest]

        path.append(closest_destination)
        remaining_destinations.remove(closest_destination)
        start = closest_destination

    return path if start == destinations[-1] else None

# 使用示例：假设我们已经得到了dijkstra的结果，可以用它来构造一个简单的邻接矩阵
# graph = {...} # 同上
destinations = ['Destination1', 'Destination2']  # 所有目标城市
shortest_path = nearest_neighbor(graph, 'Xuzhou', destinations)