Python BFS没有给出最短路径

Question

I have implemented breadth-first search according to the pseudo-code in CLRS.

However, it's not always giving me the shortest path between two nodes, as you can clearly see on the image below.

Here it went 10 -> 5 -> 1 -> 6 -> 0 but it should clearly have gone through 10 -> 1 -> 0.

Nodes and edges:

[[6, 7], [5, 0, 4], [6, 0, 4], [9, 4], [8, 2], [4, 9, 10], [1], [0], [9, 0], [7, 7], [8, 3, 1]]

Distances:

[0, 2, 4, 5, 3, 3, 1, 1, 4, 4, 4]

Colors ( 2 stands for black ):

[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]

Predecessors:

[None, 6, 4, 10, 1, 1, 0, 0, 4, 5, 5]

I can't figure out what's happening here as it seems that I'm doing exactly what's described in CLRS. Most of the times it gets the right path but sometimes it goes wrong for unknown reasons. There's also a possibility that I'm just drawing the graph wrong with networkx, I don't know.

The overall idea is that the code below generates random graphs until it finds one where it's possible to draw the shortest path between nodes a and b (ie a and b are not disjoint ).

Graph() is my own class and nx.Graph() is a different function from the networkx library.

from collections import deque
import networkx as nx
import matplotlib.pyplot as plt
import random

class Graph(object):
    def __init__(self,graph):
        self.nodes = graph
        self.colors = [0] * len(graph)
        self.distances = [len(graph) + 1000] * len(graph)
        self.predecessor = [None] * len(graph)
        self.queue = deque()
        self.nodelist = ['red'] * len(graph)

    def BFS(self,start):
        self.__init__(self.nodes)
        self.colors[start] = 1 #GRAY
        self.distances[start] = 0
        self.queue.append(start)
        while self.queue:
            current = self.queue.popleft()
            for node in self.nodes[current]:
                if self.colors[node] == 0: #WHITE
                    self.colors[node] = 1 #GRAY
                    self.distances[node] = self.distances[current] + 1
                    self.predecessor[node] = current
                    self.queue.append(node)
            self.colors[current] = 2 #BLACK

    def draw_path(self,start,end):
        self.nodelist[start] = 'green'
        previous = end
        while previous != start:
            self.nodelist[previous] = 'green'
            previous = self.predecessor[previous]
            print(previous,self.distances[previous])
        return


while 1:
    try:
        graph = []

        for i in range(0,15):
            t = random.randint(0,3)
            if t == 0:
                graph.append([random.randint(0,10)])
            if t == 1:
                graph.append([random.randint(0,10),random.randint(0,10)])
            if t == 2:
                graph.append([random.randint(0,10),random.randint(0,10),random.randint(0,10)])
        x = Graph(graph)
        a = 0
        b = 10

        x.BFS(0)
        x.draw_path(a,b)
        print(x.nodes)
        print(x.distances)
        print(x.colors)
        print(x.predecessor)

        y = nx.Graph()
        for i in range(len(graph)):
            y.add_node(i)

        for i in range(len(graph)):
            for j in graph[i]:
                y.add_edge(i,j)

        graph_label = 'Shortest path from {0} to {1}'.format(a,b)
        nx.draw_networkx(y,with_labels=True,node_color=x.nodelist)
        plt.title(graph_label)
        plt.show()
        break
    except:
        pass

Answer 1

In the question, the provided graph is

[[6, 7], [5, 0, 4], [6, 0, 4], [9, 4], [8, 2], [4, 9, 10], [1], [0], [9, 0], [7, 7], [8, 3, 1]]

Which suggest that this is a directed graph, and as the start node is 0 not 10, the path is correct, as it travels backward from end to start :

10 <- 5 <- 1 <- 6 <- 0