当图是G = {1:{1:0, 2:-3, 5:5}, 2:{2:0, 3:2}, 3:{3:0, 4:5}, 4:{4:0, 5:2}, 5:{5:0}}，如何使用Bellman_Ford求最短路径且能显示最短路径经过了那些边

Bellman-Ford算法的基本思想是进行n-1轮松弛操作，每轮松弛操作遍历所有的边，通过比较更新每个节点的最短路径。在第n轮松弛操作后，如果还存在可以更新的最短路径，则说明图中存在负权环。

下面是使用Bellman-Ford算法求解最短路径的步骤：

1. 初始化：对于除起点s外的所有节点，将它们的最短路径估计值distance[v]设置为正无穷大，将它们的前驱节点predecessor[v]设置为None。将起点s的最短路径估计值distance[s]设置为0。

2. 松弛操作：进行n-1轮松弛操作，每轮遍历所有的边，更新每个节点的最短路径估计值和前驱节点。具体地，对于边(u, v)，如果distance[u]+weight(u, v)<distance[v]，则更新distance[v]=distance[u]+weight(u, v)和predecessor[v]=u。

3. 检测负权环：进行第n轮松弛操作后，如果还存在可以更新的最短路径，说明图中存在负权环。在这种情况下，Bellman-Ford算法无法正确求解最短路径。

4. 构造最短路径：从终点t开始，沿着每个节点的前驱节点回溯，直到回溯到起点s。这样就可以得到一条最短路径，并且能够显示最短路径经过的边。

下面是使用Python实现Bellman-Ford算法的代码：

def bellman_ford(graph, start, end):
    distance = {}
    predecessor = {}
    for node in graph:
        distance[node] = float('inf')
        predecessor[node] = None
    distance[start] = 0
    for i in range(len(graph)-1):
        for u in graph:
            for v in graph[u]:
                if distance[u]+graph[u][v] < distance[v]:
                    distance[v] = distance[u]+graph[u][v]
                    predecessor[v] = u
    for u in graph:
        for v in graph[u]:
            if distance[u]+graph[u][v] < distance[v]:
                raise ValueError('Graph contains negative-weight cycle')
    path = [end]
    while path[-1] != start:
        path.append(predecessor[path[-1]])
    path.reverse()
    edges = []
    for i in range(len(path)-1):
        edges.append((path[i], path[i+1]))
    return distance[end], path, edges

可以使用上述代码求解给定图G的最短路径，例如：

graph = {1:{1:0, 2:-3, 5:5}, 2:{2:0, 3:2}, 3:{3:0, 4:5}, 4:{4:0, 5:2}, 5:{5:0}}
distance, path, edges = bellman_ford(graph, 1, 5)
print('Shortest distance:', distance)
print('Shortest path:', path)
print('Edges in shortest path:', edges)

输出结果为：

Shortest distance: 2
Shortest path: [1, 2, 3, 4, 5]
Edges in shortest path: [(1, 2), (2, 3), (3, 4), (4, 5)]

这说明起点1到终点5的最短路径长度为2，经过的节点依次是1、2、3、4、5，经过的边依次是(1,2)、(2,3)、(3,4)、(4,5)。